func TestIsControlLatin1(t *testing.T) {
	for i := rune(0); i <= MaxLatin1; i++ {
		got := IsControl(i)
		want := false
		switch {
		case 0x00 <= i && i <= 0x1F:
			want = true
		case 0x7F <= i && i <= 0x9F:
			want = true
		}
		if got != want {
			t.Errorf("%U incorrect: got %t; want %t", i, got, want)
		}
	}
}

func TestIsLetterLatin1(t *testing.T) {
	for i := rune(0); i <= MaxLatin1; i++ {
		got := IsLetter(i)

	}
	return isExcludingLatin(Letter, r)
}

// IsMark reports whether the rune is a mark character (category [M]).
func IsMark(r rune) bool {
	// There are no mark characters in Latin-1.
	return isExcludingLatin(Mark, r)
}

// IsNumber reports whether the rune is a number (category [N]).
func IsNumber(r rune) bool {
	if uint32(r) <= MaxLatin1 {
		return properties[uint8(r)]&pN != 0
	}

package p

type Foo[T any] struct {
}

func (foo Foo[T]) Get()  {
}

var(
	_ = Foo[byte]{}
	_ = Foo[[]byte]{}
	_ = Foo[map[byte]rune]{}

	_ = Foo[rune]{}
	_ = Foo[[]rune]{}
	_ = Foo[map[rune]byte]{}

)

const (
	percent    rune = '%'
	underscore rune = '_'
	runeZero   rune = 0
)

func evalSQLLike(text, pattern string, escape rune) (match bool, err error) {
	s := []rune{}
	prev := runeZero
	hasLeadingPercent := false
	patLen := len([]rune(pattern))
	for i, r := range pattern {
		if i > 0 && prev == escape {
			switch r {

    def writesTasksWithDetailDisabled() {
        TaskDetails task1 = taskDetails(':task1', description: 'task1Description')
        taskDetails(':task2')
        TaskDetails task3 = taskDetails(':task3')
        RuleDetails rule1 = [getDescription: {'rule1Description'}] as RuleDetails
        RuleDetails rule2 = [getDescription: {'rule2Description'}] as RuleDetails

        List testDefaultTasks = ['task1', 'task2']

        when:

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

package unicode_test

import (
	"testing"
	. "unicode"
)

type T struct {
	rune   rune
	script string
}

var inCategoryTest = []T{
	{0x0081, "Cc"},
	{0x200B, "Cf"},
	{0xf0000, "Co"},
	{0xdb80, "Cs"},
	{0x0236, "Ll"},
	{0x1d9d, "Lm"},
	{0x07cf, "Lo"},
	{0x1f8a, "Lt"},

		// must be new code
		rune32 = true
	default:
		panic("rune != int and rune != int32")
	}

	if rune32 {
		x = int32(4)
	} else {
		x = int(5)
	}
	switch x.(type) {
	case rune:
		// ok
	default:
		panic("int (or int32) != rune")
	}

	checkBytes([]byte(mystring("")), `[]byte(mystring(""))`)
	checkBytes(mybytes(""), `mybytes("")`)
	checkBytes(mybytes(mystring("")), `mybytes(mystring(""))`)

	checkRunes([]rune(""), `[]rune("")`)
	checkRunes([]rune(mystring("")), `[]rune(mystring(""))`)
	checkRunes(myrunes(""), `myrunes("")`)
	checkRunes(myrunes(mystring("")), `myrunes(mystring(""))`)

// license that can be found in the LICENSE file.

package main

func ascii(r rune) rune {
	switch {
	case 97 <= r && r <= 122:
		return r - 32
	case 65 <= r && r <= 90:
		return r + 32
	default:
		return r
	}
}

func main() {
	nomeObjeto := "ABE1FK21"
	println(string(nomeObjeto[1:4]))
	println(ascii(rune(nomeObjeto[4])) >= 48 && ascii(rune(nomeObjeto[4])) <= 57)
	println(string(nomeObjeto[5]))

// ERROR "newline in character literal|newline in rune literal"
// ERROR "invalid character literal \(missing closing '\)|rune literal not terminated"

const (
	_ = ''     // ERROR "empty character literal or unescaped ' in character literal|empty rune literal"
	_ = 'f'
	_ = 'foo'  // ERROR "invalid character literal \(more than one character\)|more than one character in rune literal"
//line issue15611.go:11
	_ = '