def innerContent2 = tmpDir.createDir("inner2")
        innerContent2.file("foo") << "Foo"
        def inner2 = outerContent2.file("inner2.jar")
        innerContent2.zipTo(inner2)
        def outer2 = tmpDir.file("outer2.jar")
        outerContent2.zipTo(outer2)
        def hash2 = zipHasher.hash(snapshotContext(outer2))

        expect:
        hash1 != hash2
    }

        void changeInnerName() {
            source """
                class WithInner2 {
                    SomeInterface getInner() {
                        return new Inner2();
                    }

                    static class Inner2 implements SomeInterface {
                        public int foo() {
                            return 42;
                        }
                    }
                }

        then:
        0 * _
    }

    def "watch only outermost hierarchy"() {
        def outerDir = file("outer").createDir()
        def innerDirBefore = file("outer/inner1").createDir()
        def innerDirAfter = file("outer/inner2").createDir()

        registerWatchableHierarchies([innerDirBefore, outerDir, innerDirAfter])

        when:
        addSnapshotInWatchableHierarchy(outerDir)
        then:

        outputs.deletedClasses 'A$InnerA'
    }

    def "detects rename of an inner class"() {
        source """class A {
            class InnerA {}
        }"""
        source "class B {}"

        outputs.snapshot { run language.compileTaskName }

        when:
        source """class A {
            class InnerA2 {}
        }"""
        run language.compileTaskName

        then:

package clause

type Insert struct {
	Table    Table
	Modifier string
}

// Name insert clause name
func (insert Insert) Name() string {
	return "INSERT"
}

// Build build insert clause
func (insert Insert) Build(builder Builder) {
	if insert.Modifier != "" {
		builder.WriteString(insert.Modifier)
		builder.WriteByte(' ')
	}

	builder.WriteString("INTO ")
	if insert.Table.Name == "" {

	x[3] = 2
	y := [5]int64{1, 2, 3, 4, 5}
	z := "abcd"
	w := make([]byte, 4)
	w[3] = 5
	v := make(map[int]int64)
	v[3] = 18

	test(Index1(x), int64(2))
	test(Index1(y), int64(4))
	test(Index2(z), byte(100))
	test(Index2(w), byte(5))
	test(Index2a(w), byte(5))
	test(Index3(v), int64(18))
	test(Index4(v), int64(18))

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

// issue 2086
// was calling makeclosure twice on the closure

package bug354

type Inner struct {
	F func() error
}

type Outer struct {
	Inners []Inner
}

// calls makeclosure twice on same closure

func (p *Pinner) Pin(pointer any) {
	if p.pinner == nil {
		// Check the pinner cache first.
		mp := acquirem()
		if pp := mp.p.ptr(); pp != nil {
			p.pinner = pp.pinnerCache
			pp.pinnerCache = nil
		}
		releasem(mp)

		if p.pinner == nil {
			// Didn't get anything from the pinner cache.
			p.pinner = new(pinner)
			p.refs = p.refStore[:0]

Emmanuel Odeke <******@****.***> 1460323946 -0700

		// parallel, their test functions return (and are no longer “running”)
		// before the inner subtests are released to run and hang.
		// Only those inner subtests should be reported as running.
		want := []string{
			"TestRunningTests/outer0/inner0",
			"TestRunningTests/outer0/inner1",
			"TestRunningTests/outer1/inner0",
			"TestRunningTests/outer1/inner1",
		}

		got, ok := parseRunningTests(out)
		if slices.Equal(got, want) {