// Each statement in the list of statements for each case clause must be
// terminated with a semicolon. No semicolon is present for the labeled
// statements and because the last token is a colon ":", no semicolon is
// inserted automatically.
//
// Both gccgo and gofmt correctly refuse this program as is and accept it
// when the semicolons are present.

		case len(hostport):
			// There can't be a ':' behind the ']' now.
			return addrErr(hostport, missingPort)
		case i:
			// The expected result.
		default:
			// Either ']' isn't followed by a colon, or it is
			// followed by a colon that is not the last one.
			if hostport[end+1] == ':' {
				return addrErr(hostport, tooManyColons)
			}
			return addrErr(hostport, missingPort)
		}
		host = hostport[1:end]

			continue
		}
		result[n] = b
		n++
	}

	return result[0:n]
}

var pemStart = []byte("\n-----BEGIN ")
var pemEnd = []byte("\n-----END ")
var pemEndOfLine = []byte("-----")
var colon = []byte(":")

// Decode will find the next PEM formatted block (certificate, private key
// etc) in the input. It returns that block and the remainder of the input. If

        'us%5B%5B%23%3B%C3%BCr:pas%23:%5D()' | 'us[[#;ür' | 'pas#:]()'
        'user'                               | null       | null
    }

    def "username cannot contain colon"() {
        // Known limitation. The user should use the DSL
        when:
        def credentials = extractCredentialsFromUserInfo(new URI("https://us%3Aer:******@****.***"))

        then:

        outputDoesNotContain("abbreviated")

        where:
        desc                                    | projectPath                           | resolvedProject
        "root (no colon)"                       | ""                                    | ":"                      // Global root
        "projectA"                              | ":projectA"                           | ":projectA"              // Subprojects

	GEQ      // >=
	DEFINE   // :=
	ELLIPSIS // ...

	LPAREN // (
	LBRACK // [
	LBRACE // {
	COMMA  // ,
	PERIOD // .

	RPAREN    // )
	RBRACK    // ]
	RBRACE    // }
	SEMICOLON // ;
	COLON     // :
	operator_end

	keyword_beg
	// Keywords
	BREAK
	CASE
	CHAN
	CONST
	CONTINUE

	DEFAULT
	DEFER
	ELSE
	FALLTHROUGH
	FOR

	FUNC
	GO
	GOTO
	IF

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package user

import "sync"

const (
	userFile  = "/etc/passwd"
	groupFile = "/etc/group"
)

var colon = []byte{':'}

// Current returns the current user.
//
// The first call will cache the current user information.
// Subsequent calls will return the cached value and will not reflect
// changes to the current user.

	_, err := NewPathElement("r:Hello")
	if err != nil {
		t.Fatalf("Unknown qualifiers should be ignored")
	}
}

func TestNewPathElementError(t *testing.T) {
	tests := []string{
		``,
		`no-colon`,
		`i:index is not a number`,
		`i:1.23`,
		`i:`,
		`v:invalid json`,
		`v:`,
		`k:invalid json`,
		`k:{"name":invalid}`,
	}

	for _, test := range tests {
		t.Run(test, func(t *testing.T) {

		case *RangeClause:
			m = n.X
		case *CaseClause:
			if l := lastStmt(n.Body); l != nil {
				m = l
				continue
			}
			return n.Colon
		case *CommClause:
			if l := lastStmt(n.Body); l != nil {
				m = l
				continue
			}
			return n.Colon

		default:
			return n.Pos()
		}
	}
}

func lastDecl(list []Decl) Decl {
	if l := len(list); l > 0 {
		return list[l-1]
	}

		},
		{
			name:             "parse invalid ipv6",
			expr:             `ip("2001:db8:::68")`,
			expectRuntimeErr: "IP Address \"2001:db8:::68\" parse error during conversion from string: ParseAddr(\"2001:db8:::68\"): each colon-separated field must have at least one digit (at \":68\")",
		},
		{
			name:         "isIP valid ipv6",
			expr:         `isIP("2001:db8::68")`,
			expectResult: trueVal,
		},
		{