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

  parent.Set(String("test3"), Integer(3));
  Object child;
  child.Set(String("test1"), Integer(1));
  child.Set(String("test2"), Integer(2));
  child.Set(Object::ParentKey(), parent);
  EXPECT_EQ(child.Get<Integer>(String("test1"))->get(), 1);
  EXPECT_EQ(child.Get<Integer>(String("test2"))->get(), 2);
  EXPECT_EQ(child.Get<Integer>(String("test3"))->get(), 3);
  ASSERT_FALSE(child.Get<Integer>(String("test4")).status().ok());

// containing faulting frame.

package main

import "runtime"

func main() {
	test1()
	test2()
	test3()
}

func test1() {
	// test1f will panic without its own defer.
	// The runtime.GC checks that we can walk the stack
	// at that point and not get confused.
	// The recover lets test1 exit normally.
	defer func() {
		runtime.GC()
		recover()
	}()
	test1f()
}

func test1f() {

			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))
}

// Copyright 2013 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package b

import "./a"

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

	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()