Switch case statement falls through to default

I am new to go and can't figure out why the last case clauses (connect and test) fall through to default. But the ones with the new line characters (exit\r\n and connect\r\n) don't

There is no fallthrough statement.

I've tried labeling the switch and calling break [lbl] but the default block still gets executed

package main

import (
"fmt"
"strings"
"bufio"
"os"
)

func main() {

var cmd string
bio := bufio.NewReader(os.Stdin)
fmt.Println("Hello")

proceed := true

for proceed {

	fmt.Print(">> ")
	cmd, _ = bio.ReadString('\n')
	cmds := strings.Split(cmd, " ")

	for i := range cmds{
		switch cmds[i]{
			case "exit\r\n" :
				proceed = false
			case "connect\r\n":
				fmt.Println("The connect command requires more input")
			case "connect":
				if i + 2 >= len(cmds) {
					fmt.Println("Connect command usage: connect host port")
				} else {
					i++
					constring := cmds[i]
					i++
					port := cmds[i]
					con(constring, port)	
				}
				fmt.Println("dont print anything else, dont fall through to default. There should be no reason why the default caluse is executed???")
			case "test":
				fmt.Println("dont print anything else, dont fall through to default. There should be no reason why the default caluse is executed???")
			default:
				fmt.Println("Unrecognised command: " + cmds[i])
		} 
		
	}

}
}

func con (conStr, port string){
panic (conStr)
}

> The Go Programming Language Specification
>
> Switch statements
>
> "Switch" statements provide multi-way execution. An expression or type
> specifier is compared to the "cases" inside
>
> Expression switches
>
> In an expression switch, the switch expression is evaluated and the
> case expressions, which need not be constants, are evaluated
> left-to-right and top-to-bottom; the first one that equals the switch
> expression triggers execution of the statements of the associated
> case; the other cases are skipped. If no case matches and there is a
> "default" case, its statements are executed. There can be at most one
> default case and it may appear anywhere in the "switch" statement. A
> missing switch expression is equivalent to the boolean value true.
>
> ExprSwitchStmt = "switch" [ SimpleStmt ";" ] [ Expression ] "{" { ExprCaseClause } "}" .
> ExprCaseClause = ExprSwitchCase ":" StatementList .
> ExprSwitchCase = "case" ExpressionList | "default" .

The last switch case clauses ("connect" and "test") do not fall through to the default case clause. A break statement in a switch statement case clause breaks out of the switch statement; it does not break out of a surrounding for clause.

You have not provided us with a reproducible example: How to create a Minimal, Complete, and Verifiable example.. For example, you haven't shown us your input and output.

Here's an example, which is working as expected. There is a reason that the default clause is executed.

>> test 127.0.0.1 8080
dont print anything else, dont fall through to default. There should be no reason why the default caluse is executed???
Unrecognised command: 127.0.0.1
Unrecognised command: 8080

>> 

The value of cmds, fmt.Printf("%q\n", cmds), is ["test" "127.0.0.1" "8080\r\n"].

Your program logic is badly flawed.

Try wrapping the subject of your switch statement with strings.Trim() like so:

switch strings.TrimSpace(cmds[i]) {
   // your cases
}

In general though, it looks like the inner for loop is the wrong construct to be using in this case. Based on this snippet of code you probably want to remove that and just have the first element of the cmds array be the subject of your switch statement