test10reflect1()
		test10reflect2()
	}
	test11()
	if !interp {
		test11reflect1()
		test11reflect2()
	}
	test111()
	test12()
	if !interp {
		test12reflect1()
		test12reflect2()
	}
	test13()
	if !interp {
		test13reflect1()
		test13reflect2()
	}
	test14()
	if !interp {
		test14reflect1()
		test14reflect2()
		test15()
		test16()
	}
}

func die() {

        then:
        found == ['test1', 'test2', 'test3', 'system1', 'system2', 'DEFINED']

        where:
        directive << ["include", "import"]
    }

    def "finds #directive with no whitespace"() {
        when:
        sourceFile << """
#include"test1"
#include<test2>
"""
        useDirective(directive)

        then:
        found == ['test1', 'test2']

        where:

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

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

                @AfterClass
                public void afterClass() {
                    System.out.println("TestFactory[" + data + "].afterClass()");

class GradleTaskGetGroupCrossVersionSpec extends ToolingApiSpecification {

    def "provide getGroup on Task using GradleProject"() {
        file("build.gradle") << '''
task test1(group:'task group 1')
task test2(group:'task group 2')
'''

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

        then:

					ExpressionAccessor: &MatchCondition{
						Name: "test2",
					},
				},
			},
			shouldMatch:  false,
			returnedName: "test1",
		},
		{
			name: "test mixed with no match last",
			evaluations: []cel.EvaluationResult{
				{
					EvalResult: celtypes.True,
					ExpressionAccessor: &MatchCondition{
						Name: "test2",
					},
				},
				{
					EvalResult: celtypes.False,

                implementation "org.test:b2:1.0"
            }
        """

        when:
        checkDependencies()

        then:
        checkGraph {
            edge("org.test:b1:1.0", ":buildB:b1", "org.test:b1:2.0") {
                configuration = "runtimeElements"
                compositeSubstitute()
            }
            edge("org.test:b2:1.0", ":buildB:b2", "org.test:b2:2.0") {

                }
            }
        """

        server.expectConcurrent("test-1.3.jar", "test2-2.3.jar", "test3-3.3.jar")

        when:
        succeeds ":resolve"

        then:
        outputContains("Transforming test-1.3.jar to test-1.3.jar.txt")
        outputContains("Transforming test2-2.3.jar to test2-2.3.jar.txt")

    assert response.status_code == 200
    assert response.json() == {"foo": "baz"}

    response = client.get("/test2")
    assert response.status_code == 200
    assert response.json() == {"foo": "bar"}

    response = client.get("/test2", params={"var": "baz"})
    assert response.status_code == 200
    assert response.json() == {"foo": "baz"}


def test_nested_router():

        activation = new ProfileActivation();
        performProfileActivation(parser.parse(options, new String[] {"-P", "test1,+test2,?test3,+?test4"}), activation);
        assertThat(activation.getRequiredActiveProfileIds(), containsInAnyOrder("test1", "test2"));
        assertThat(activation.getOptionalActiveProfileIds(), containsInAnyOrder("test3", "test4"));

        activation = new ProfileActivation();

    }

    @Test
    public void test1() {
        System.out.println("Test1.test1()");
    }

    @Test(dependsOnMethods = {"test1"})
    public void test2() {
        System.out.println("Test1.test2()");
    }

    @AfterClass
    public void afterClass() {
        System.out.println("Test1.afterClass()");
    }