result.assertTestClassesExecuted("org.gradle.FooTest")
        result.testClass("org.gradle.FooTest").assertTestOutcomes(testOutcome, testName)
        if (dryRun) {
            result.testClassByXml("org.gradle.FooTest").assertStderr(Matchers.emptyString())
        } else {
            result.testClassByXml("org.gradle.FooTest").assertStderr(Matchers.containsString("ran FooTest.${testName}!"))
        }

        where:

        """Test suite '$testSuiteName' -> beforeTest out
Test suite '$testSuiteName' -> beforeTest err
Test class FooTest -> beforeClass out
Test class FooTest -> beforeClass err
Test method m1(FooTest) -> m1: α</html>
Test method m1(FooTest) -> m1 err
Test method m2(FooTest) -> m2 out
Test method m2(FooTest) -> m2 err
Test suite '$testSuiteName' -> afterClass out
Test suite '$testSuiteName' -> afterClass err

        results.size() == 1
        def fooTest = results.values().toList().first()
        fooTest.className == 'FooTest'
        fooTest.startTime == 100
        fooTest.testsCount == 2
        fooTest.failuresCount == 1
        fooTest.duration == 200
        fooTest.results.size() == 2
        fooTest.results.find { it.name == 'testMethod' && it.endTime == 200 && it.duration == 100 }

        """.stripIndent()
        file("src/test/java/FooTest.java") << """
            ${testFrameworkImports}
            public class FooTest {
                private final static org.slf4j.Logger SLF4J = org.slf4j.LoggerFactory.getLogger(FooTest.class);
                private final static java.util.logging.Logger JUL = java.util.logging.Logger.getLogger(FooTest.class.getName());

                @Test

<testsuite name="com.foo.FooTest" tests="4" skipped="1" failures="1" errors="0" timestamp="2012-11-19T17:09:28" hostname="localhost" time="0.045">
  <properties/>
  <testcase name="some test" classname="com.foo.FooTest" time="0.015"/>
  <testcase name="some test two" classname="com.foo.FooTest" time="0.015"/>
  <testcase name="some failing test" classname="com.foo.FooTest" time="0.01">

// 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.

		{buildPodsByCreationTime(), 2, 1},
	}

	for _, fooTest := range fooTests {
		fooi := fooTest.pods[fooTest.i]
		fooj := fooTest.pods[fooTest.j]
		fooTest.pods.Swap(fooTest.i, fooTest.j)
		if fooi.GetName() != fooTest.pods[fooTest.j].GetName() || fooj.GetName() != fooTest.pods[fooTest.i].GetName() {
			t.Errorf("failed to swap for %v", fooTest)
		}
	}
}

func TestPodsByCreationTimeLess(t *testing.T) {

                            'class' (name: 'FooTest')
                            'class' (name: 'BarTest')
                        }
                    }
                }
              }
            }
        """

        file("src/test/java/FooTest.java") << """
            ${testFrameworkImports}
            public class FooTest {
                @Test public void pass() {}
            }

        expect: spec.includePatterns.isEmpty()

        when:
        spec.includeTestsMatching("*fooMethod")
        spec.includeTestsMatching("*.FooTest.*")

        then: spec.includePatterns == ["*fooMethod", "*.FooTest.*"] as Set

        when: spec.setIncludePatterns("x")

        then: spec.includePatterns == ["x"] as Set
    }

    def "allows configuring by test class and methodname"() {

        result.assertTestClassesExecuted("FooTest")
        result.testClass("FooTest").assertTestsExecuted("testPass")

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

        then:
        failure.assertHasCause("No tests found for given includes: [FooTest.unknown]")
    }