type myByte byte

func _(a []byte, b []myByte) {
	f00(a, b)
	f01(a, b)
	f02(a, b)
	f03(a, b)
	f04(a, b)
	f05(a, b)
	f06(a, b)
	f07(a, b)
	f08(a, b)
	f09(a, b)
	f10(a, b)
	f11(a, b)
	f12(a, b)
	f13(a, b)
	f14(a, b)
	f15(a, b)
	f16(a, b)
	f17(a, b)
	f18(a, b)
	f19(a, b)
	f20(a, b)
	f21(a, b)
	f22(a, b)
	f23(a, b)
}

// Constraint type inference may have to iterate.

        ['a']                | ['b']                | ['a']                | []         | ['b']
        ['a', 'b', 'd']      | ['c', 'e', 'f', 'g'] | ['a', 'b', 'd']      | []         | ['c', 'e', 'f', 'g']
        ['a', 'b', 'd', 'e'] | ['c', 'e', 'f', 'g'] | ['a', 'b', 'd']      | ['e']      | ['c', 'f', 'g']

	LEAL	const(e)(SI*1), e

#define ROUND1(a, b, c, d, e, index) \
	LOAD(index, e); \
	FUNC1(a, b, c, d, e); \
	MIX(a, b, c, d, e, 0x5A827999)

#define ROUND1x(a, b, c, d, e, index) \
	SHUFFLE(index, e); \
	FUNC1(a, b, c, d, e); \
	MIX(a, b, c, d, e, 0x5A827999)

#define ROUND2(a, b, c, d, e, index) \
	SHUFFLE(index, e); \
	FUNC2(a, b, c, d, e); \
	MIX(a, b, c, d, e, 0x6ED9EBA1)

	ok      bool
}{
	{"a", "a", true},
	{"a", "b", false},
	{"a/**", "a", true},
	{"a/**", "b", false},
	{"a/**", "a/b", true},
	{"a/**", "b/b", false},
	{"a/**", "a/b/c/d/e/f", true},
	{"a/**", "z/a/b/c/d/e/f", false},
	{"**/a", "a", true},
	{"**/a", "b", false},
	{"**/a", "x/a", true},
	{"**/a", "x/a/b", false},
	{"**/a", "x/y/z/a", true},
	{"**/a", "x/y/z/a/b", false},

package p

type Eq[T any] interface {
	Eqv(a T, b T) bool
}

type EqFunc[T any] func(a, b T) bool

func (r EqFunc[T]) Eqv(a, b T) bool {
	return r(a, b)
}

func New[T any](f func(a, b T) bool) Eq[T] {
	return EqFunc[T](f)
}

func Equal(a, b []byte) bool {
	return string(a) == string(b)
}

func fEqPtrEqPtr(a, b *int, f float64) bool {
	return a == b && f > Cf2 || a == b && f < -Cf2 // ERROR "Redirect EqPtr based on EqPtr$"
}

func fEqPtrNeqPtr(a, b *int, f float64) bool {
	return a == b && f > Cf2 || a != b && f < -Cf2 // ERROR "Redirect NeqPtr based on EqPtr$"
}

func fNeqPtrEqPtr(a, b *int, f float64) bool {

        path.url == 'file://$ROOT_DIR$/a/b'
        path.relPath == '$ROOT_DIR$/a/b'
    }

    def createsRelativePathForAnAncestorOfRootDir() {
        factory.addPathVariable('ROOT_DIR', tmpDir.testDirectory)

        expect:
        def path = factory.relativePath('ROOT_DIR', tmpDir.testDirectory.parentFile.parentFile.file('a/b'))
        path.url == 'file://$ROOT_DIR$/../../a/b'

        expect:
        set.collect { it } == ['a', 'b', 'c']
        set.iterator().collect { it } == ['a', 'b', 'c']
    }

    def canGetElementsAsAList() {
        ImmutableDomainObjectSet<String> set = new ImmutableDomainObjectSet<String>(['a', 'b', 'c'])

        expect:
        set.all == ['a', 'b', 'c']
    }

fun foo(a: Int): Int {
    val b: Int = 1
    for (n in 1..a) {
        <expr>if (a + b > 0) break
        consume(a - b)
        if (a - b > 0) break
        consume(a + b)</expr>
    }
    return 1
}

	{"ab[^b-d]", "abc", false, nil},
	{"ab[^e-g]", "abc", true, nil},
	{"a\\*b", "a*b", true, nil},
	{"a\\*b", "ab", false, nil},
	{"a?b", "a☺b", true, nil},
	{"a[^a]b", "a☺b", true, nil},
	{"a???b", "a☺b", false, nil},
	{"a[^a][^a][^a]b", "a☺b", false, nil},
	{"[a-ζ]*", "α", true, nil},
	{"*[a-ζ]", "A", false, nil},
	{"a?b", "a/b", false, nil},
	{"a*b", "a/b", false, nil},
	{"[\\]a]", "]", true, nil},
	{"[\\-]", "-", true, nil},