import XCTest

class SomeIntegTest: XCTestCase {
    public static var allTests = [
        ("test1", test1),
        ("test2", test2)
    ]
    func test1() {}
    func test2() {}

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

package main

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

type I interface {
	f()
	g()
	h()
}

//go:noinline
func ld[T any]() {
	var x I
	if _, ok := x.(T); ok {
	}
}

func isI(x any) {
	_ = x.(I)
}

func test1() {
	defer func() { recover() }()
	ld[bool]() // add <bool,I> itab to binary
	_ = any(false).(I)
}

			evaluations: []cel.EvaluationResult{
				{
					EvalResult: celtypes.False,
					ExpressionAccessor: &MatchCondition{
						Name: "test1",
					},
				},
				{
					EvalResult: celtypes.True,
					ExpressionAccessor: &MatchCondition{
						Name: "test2",
					},
				},
			},
			shouldMatch:  false,
			returnedName: "test1",
		},
		{

        System.out.println("TestFactory[" + data + "].beforeClass()");
    }

    @Test
    public void test1() {
        System.out.println("TestFactory[" + data + "].test1()");
    }

    @Test(dependsOnMethods = {"test1"})
    public void test2() {
        System.out.println("TestFactory[" + data + "].test2()");
    }

    @AfterClass
    public void afterClass() {

    def logsCountOfTestsExecuted() {
        TestDescriptor test1 = test()
        TestDescriptor test2 = test()

        logger.beforeSuite(rootSuite)

        when:
        logger.afterTest(test1, result())
        logger.beforeTest(test2)

        then:
        1 * progressLogger.progress('1 test completed')

        when:
        logger.afterTest(test2, result())
        logger.afterSuite(rootSuite, result())

								BytesSent:     10,
								EndpointId:    "test",
								InstanceId:    "test",
							},
						},
					},
					{
						container: hcsshim.ContainerProperties{
							ID: "c2",
						}, hcsStats: []hcsshim.NetworkStats{
							{
								BytesReceived: 2,
								BytesSent:     20,
								EndpointId:    "test2",
								InstanceId:    "test2",
							},
						},
					},
				},

                }

                @Test
                public void test1() {
                    System.out.println("TestFactory[" + data + "].test1()");
                }

                @Test(dependsOnMethods = {"test1"})
                public void test2() {
                    System.out.println("TestFactory[" + data + "].test2()");
                }

                @AfterClass

        when:
        grammar("Test1", "Test2")
        then:
        succeeds("generateGrammarSource")

        test1TokenFile.exists()
        test1LexerFile.exists()
        test1ParserFile.exists()

        test2TokenFile.exists()
        test2LexerFile.exists()
        test2ParserFile.exists()

        when:
        removedGrammar("Test1")

        then:

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

            assert it.group == "task group ${it.name-'test'}"
        }
    }

    def "provide getGroup on Task using GradleProject shouldn't fail if group is null"() {
        file("build.gradle") << '''
task test1()
task test2()
'''

        when:
        def gradleProject = withConnection { ProjectConnection connection ->
            connection.getModel(GradleProject)
        }