func ExampleClean() {
	paths := []string{
		"a/c",
		"a//c",
		"a/c/.",
		"a/c/b/..",
		"/../a/c",
		"/../a/b/../././/c",
		"",
	}

	for _, p := range paths {
		fmt.Printf("Clean(%q) = %q\n", p, path.Clean(p))
	}

	// Output:
	// Clean("a/c") = "a/c"
	// Clean("a//c") = "a/c"
	// Clean("a/c/.") = "a/c"
	// Clean("a/c/b/..") = "a/c"
	// Clean("/../a/c") = "/a/c"
	// Clean("/../a/b/../././/c") = "/a/c"

        where:
        executedTasks << [':a', ':b', ':c'].permutations().findAll { it != [':a', ':b', ':c'] } + [
            [':a', ':c'],
            [':a', ':b'],
            [':b', ':c'],
            [':a', ':c', ':b', ':d'],
            [':z', ':b', ':a', ':c'],
            [':z', ':c', ':x', ':y', ':b', ':a', ':d'],
            []
        ]
    }

    def "can match any order (#executedTasks)"() {

#:HA#280:E	(ab|a|c|bcd){0,}(d*)	ababcd	(0,6)(3,6)(6,6)
:HA#280:E	(ab|a|c|bcd){0,}(d*)	ababcd	(0,6)(4,5)(5,6)	RE2/Go
#:HA#281:E	(ab|a|c|bcd){1,}(d*)	ababcd	(0,6)(3,6)(6,6)
:HA#281:E	(ab|a|c|bcd){1,}(d*)	ababcd	(0,6)(4,5)(5,6)	RE2/Go
#:HA#282:E	(ab|a|c|bcd){2,}(d*)	ababcd	(0,6)(3,6)(6,6)
:HA#282:E	(ab|a|c|bcd){2,}(d*)	ababcd	(0,6)(4,5)(5,6)	RE2/Go
#:HA#283:E	(ab|a|c|bcd){3,}(d*)	ababcd	(0,6)(3,6)(6,6)

                <name>�4g(Y*��</name>
                <access kind="email"></access>
                <access kind="url">http://www.taro.com/</access>
                <image file="taro.png" />
        </item>

                <name>4�(g*Yΐ</name>
                <access kind="email"></access>
                <access kind="url">http://www.taro.com/</access>
                <image file="taro.png" />
        </item>

		a = b + bits.RotateLeft32((((c^d)&b)^d)+a+x8+0x698098d8, 7)
		d = a + bits.RotateLeft32((((b^c)&a)^c)+d+x9+0x8b44f7af, 12)
		c = d + bits.RotateLeft32((((a^b)&d)^b)+c+xa+0xffff5bb1, 17)
		b = c + bits.RotateLeft32((((d^a)&c)^a)+b+xb+0x895cd7be, 22)
		a = b + bits.RotateLeft32((((c^d)&b)^d)+a+xc+0x6b901122, 7)
		d = a + bits.RotateLeft32((((b^c)&a)^c)+d+xd+0xfd987193, 12)

		c[i] = "cccc"
	}

	for j := 0; j < b.N; j++ {
		_ = a == c
	}
}

func BenchmarkEqArrayOfFloats5(b *testing.B) {
	var a [5]float32
	var c [5]float32

	for i := 0; i < b.N; i++ {
		_ = a == c
	}
}

func BenchmarkEqArrayOfFloats64(b *testing.B) {
	var a [64]float32
	var c [64]float32

	for i := 0; i < b.N; i++ {
		_ = a == c
	}
}

func BenchmarkEqArrayOfFloats1024(b *testing.B) {

! go list ./a/c
stderr 'directory a[\\/]c is contained in a module that is not one of the workspace modules listed in go.work. You can add the module to the workspace using:\n\tgo work use a'

! go install ./a/c

        def matcher = new FixedStepPathMatcher(step("a"), matchesLastOrSecondLast("c"))

        expect:
        matcher.matches(["a", "c"] as String[], 0)
        matcher.matches(["a", "c", "d"] as String[], 0)
        matcher.matches(["prefix", "a", "c"] as String[], 1)

        and:
        !matcher.matches([] as String[], 0)
        !matcher.matches(["a"] as String[], 0)

        declaredDependencies 'a', 'c'
        declaredReplacements 'a->e'
        //resolution sequence: a,c,b,d,e!
        publishedMavenModules 'a->b', 'c->d', 'd->e'
        expect:
        resolvedModules 'c', 'd', 'e' //'b' is evicted
    }

    def "replaces transitive module"() {
        declaredDependencies 'a', 'c'
        declaredReplacements 'b->d'