then:
        def result = new DefaultTestExecutionResult(testDirectory)

        result.assertTestClassesExecuted("FooTest", "FooServerTest")
        result.testClass("FooTest").assertTestCount(1, 0, 0);
        result.testClass("FooTest").assertTestOutcomes(passedTestOutcome, "testFoo")
        result.testClass("FooServerTest").assertTestCount(1, 0, 0);

    }
    test {
        useTestNG {
            systemProperty 'name', 'value'
        }
    }
"""
        file("src/test/java/FooTest.java") << """
            import org.testng.annotations.*;

            public class FooTest {
                @Test public void foo() {
                  assert System.getProperty("name").equals("value");
                }
            }
        """

    @Issue("GRADLE-1710")
    def "reports suite fatal failure"() {
        TestNGCoverage.enableTestNG(buildFile, '6.3.1')
        file("src/test/java/FooTest.java") << """
            import org.testng.annotations.*;

            public class FooTest {
                public FooTest() { throw new NullPointerException(); }
                @Test public void foo() {}
            }
        """

        expect:
        fails("test")

typedef testing::Types<char, int, unsigned int> MyTypes;
TYPED_TEST_CASE(FooTest, MyTypes);

// If the type list contains only one type, you can write that type
// directly without Types<...>:
//   TYPED_TEST_CASE(FooTest, int);

// Then, use TYPED_TEST() instead of TEST_F() to define as many typed
// tests for this test case as you want.
TYPED_TEST(FooTest, DoesBlah) {
  // Inside a test, refer to TypeParam to get the type parameter.

// these names:
//
//    * InstantiationName/FooTest.DoesBlah/0 for "meeny"
//    * InstantiationName/FooTest.DoesBlah/1 for "miny"
//    * InstantiationName/FooTest.DoesBlah/2 for "moe"
//    * InstantiationName/FooTest.HasBlahBlah/0 for "meeny"
//    * InstantiationName/FooTest.HasBlahBlah/1 for "miny"
//    * InstantiationName/FooTest.HasBlahBlah/2 for "moe"
//
// You can use these names in --gtest_filter.

        def fooTest = new TestClassResult(1, 'FooTest', 100)
            .add(new TestMethodResult(1, "foo"))

        def barTest = new TestClassResult(2, 'BarTest', 100)
            .add(new TestMethodResult(2, "bar"))
            .add(new TestMethodResult(3, "bar2"))

        resultsProvider.visitClasses(_) >> { Action action ->
            action.execute(fooTest)
            action.execute(barTest)
        }

typedef testing::Types<char, int, unsigned int> MyTypes;
TYPED_TEST_CASE(FooTest, MyTypes);

// If the type list contains only one type, you can write that type
// directly without Types<...>:
//   TYPED_TEST_CASE(FooTest, int);

// Then, use TYPED_TEST() instead of TEST_F() to define as many typed
// tests for this test case as you want.
TYPED_TEST(FooTest, DoesBlah) {
  // Inside a test, refer to TypeParam to get the type parameter.

        """.stripIndent()

        when:
        run("test", "--tests", "FooTest.pass")

        then:
        def result = new DefaultTestExecutionResult(testDirectory)
        result.assertTestClassesExecuted("FooTest")
        result.testClass("FooTest").assertTestsExecuted("other", "pass")

        when:
        fails("test", "--tests", "FooTest.ignored")

        then:

        def someJdk = AvailableJavaHomes.differentJdk
        buildscriptWithToolchain(someJdk)

        file("src/main/java/Foo.java") << "public class Foo {}"
        file("src/test/java/FooTest.java") << testClass("FooTest")

        when:
        runWithToolchainConfigured(someJdk)
        runWithToolchainConfigured(someJdk)

        then:
        outputContains("Task :compileJava UP-TO-DATE")

                            }
                        }
                    }
                }
            }
        """

        file("src/test/java/FooTest.java") << """
            ${testFrameworkImports}
            public class FooTest {
                @Test public void foo() {
                    System.err.println("Run foo!");
                }
            }
        """