processor.startProcessing(resultProcessor)
        processor.processTestClass(test1)
        processor.processTestClass(test2)

        then:
        1 * factory.create() >> delegate
        1 * delegate.startProcessing(resultProcessor)
        then:
        1 * delegate.processTestClass(test1)
        then:
        1 * delegate.processTestClass(test2)
        then:
        1 * delegate.stop()
        0 * _._

        when:

        DisposableUtil.dispose();
    }

    /**
     * @throws Exception
     */
    @Test
    public void test1() throws Exception {
        DisposableUtil.add(new TestDisposable("a"));
        assertThat(DisposableUtil.disposables.size(), is(1));
        DisposableUtil.dispose();
        assertThat(count, is(1));
        assertThat(names, is("a"));

        def defaultToolChain1 = unavailableToolChain("test1")
        def defaultToolChain2 = availableToolChain("test2")
        def defaultToolChain3 = availableToolChain("test3")

        when:
        registry.registerDefaultToolChain("test1", TestNativeToolChain)
        registry.registerDefaultToolChain("test2", TestNativeToolChain)
        registry.registerDefaultToolChain("test3", TestNativeToolChain)
        registry.addDefaultToolChains()

        def header1 = includeDir.createFile("test.h")
        includePaths << includeDir

        macros << macro("TEST", '"test.h"')
        macroFunctions << macroFunction("TEST1", "TEST")
        macros << macro("TEST2", "TEST1()")
        macros << macro("TEST3", "TEST2")
        macros << unresolvableMacro("IGNORE")

        expect:
        def result = resolve(include('TEST3'))
        result.complete

			expected: `STATUS    REASON               MESSAGE
Failure   test-status-reason   test-status-message
`,
		},
		// Test non-table default printing for a Status resource with NoHeaders options.
		{
			object:   testStatus,
			options:  PrintOptions{NoHeaders: true},
			expected: "Failure   test-status-reason   test-status-message\n",
		},
	}
	for _, test := range tests {
		// Print the table
		out := bytes.NewBuffer([]byte{})

	// storing the services out of time order to test that it's being sorted properly.
	testOutboundListenerConflict(t,
		buildServiceWithPort("test1.com", 3306, protocol.HTTP, tnow.Add(1*time.Second)),
		buildServiceWithPort("test2.com", 3306, protocol.MySQL, tnow))
	testOutboundListenerConflict(t,
		buildServiceWithPort("test1.com", 9999, protocol.HTTP, tnow.Add(1*time.Second)),
		buildServiceWithPort("test2.com", 9999, protocol.MySQL, tnow))
}

	m1v("")
	m2v := b1.m2
	m2v("")
	b2v := b2.m2
	b2v("")
}

// actual test case from issue

type A[T any] struct{}

func (*A[T]) f(T) {}

type B[T any] struct{ A[T] }

func test3() {
	var b B[string]
	b.A.f("")
	b.f("")
}

func main() {
	test1[string]("")
	test2()
	test3()

package main

import "./a"

// Testing inlining of functions that refer to instantiated exported and non-exported
// generic types.

func main() {
	a.Test1()
	a.Test2()
	a.Test3()

        run 'show'

        then:
        outputContains("files: [test-1.0, test-1.0, test-1.0-classy]")
        outputContains("display-names: [test-1.0 (org:test:1.0), test-1.0 (org:test:1.0), test-1.0-classy (org:test:1.0)]")
        outputContains("ids: [test-1.0 (org:test:1.0), test-1.0 (org:test:1.0), test-1.0-classy (org:test:1.0)]")
        outputContains("names: [test::jar, test::, test::]")
        outputContains("classifiers: [null, null, classy]")

	in2 In2
	in3 In3
	out Out
}

func test1[In, Out any](t *testing.T, tests []testCase1[In, Out], name string, f func(In) Out) {
	t.Helper()
	for _, tt := range tests {
		if out := f(tt.in); !reflect.DeepEqual(out, tt.out) {
			t.Errorf("%s(%v) = %v, want %v", name, tt.in, out, tt.out)
		}
	}
}

func test2[In1, In2, Out any](t *testing.T, tests []testCase2[In1, In2, Out], name string, f func(In1, In2) Out) {