1 * delegate.processTestClass(test1)
        then:
        1 * delegate.processTestClass(test2)
        then:
        1 * delegate.stop()
        0 * _._
    }

    def 'uses single batch when n equals zero'() {
        given:
        processor = new RestartEveryNTestClassProcessor(factory, 0)

        when:
        processor.startProcessing(resultProcessor)
        processor.processTestClass(test1)

                    .addConverter(new groovy.json.JsonGenerator.Converter() {
                        @Override
                        public boolean handles(Class<?> type) {
                            return Class.class.equals(type);
                        }

                        @Override
                        public Object convert(Object value, String key) {
                            Class<?> clazz = (Class<?>) value;

                }

                int hashCode() {
                    assert a != null && z != null
                    a.hashCode() ^ z.hashCode()
                }

                boolean equals(Object other) {
                    assert a != null && z != null
                    (other instanceof Circular) && a == other.a && z == other.z
                }

                String toString() {

        workerClass.imports.add("java.net.URL")
        workerClass.action += """
            assert new File('${normaliseFileSeparators(differentJvm.jre.absolutePath)}').canonicalPath.equals(new File(System.getProperty("java.home")).canonicalPath);
        """
        return workerClass
    }

    WorkerExecutorFixture.WorkActionClass getWorkActionThatVerifiesOptions(OptionsVerifier optionsVerifier) {

        !spec.isSatisfiedBy(GradleVersion.version("1.5"))
        !spec.isSatisfiedBy(GradleVersion.version("1.5-rc-1"))
        !spec.isSatisfiedBy(GradleVersion.version("12.45"))
    }

    def "equals version constraint matches versions with same base version"() {
        def spec = new GradleVersionSpec().toSpec("=1.4")

        expect:
        spec.isSatisfiedBy(GradleVersion.version("1.4"))

        path('a').getPath() == 'a'
        path('a:b:c').getPath() == 'a:b:c'
        path(':a').getPath() == ':a'
        path(':a:b').getPath() == ':a:b'
        path(':a:b:').getPath() == ':a:b'
    }

    def "equals and hashCode"() {
        expect:
        strictlyEquals(Path.ROOT, Path.ROOT)
        strictlyEquals(path('path'), path('path'))
        strictlyEquals(path(':a:path'), path(':a:path'))

    def "passes with equal values"() {
        when:
        ToolingApiModelChecker.checkModel(
            dummyModel("someValue"),
            dummyModel("some" + "Value"),
            [
                { it.value }
            ]
        )

        then:
        noExceptionThrown()
    }

    def "passes with equal values from different model implementations"() {

class VersionParserTest extends Specification {

    @Subject
    VersionParser versionParser = new VersionParser()

    def "parsed version is equal when source string is equal"() {
        def v = parse("1.2.b")
        def equal = parse("1.2.b")

        expect:
        v strictlyEqual(equal)
        v != parse("1.2.c")
        v != parse("1.2")
        v != parse("1.2.b.0")
        v != parse("1.2-b")
        v != parse("1.2b")

        def s5 = setOfAutomaticAccessorsFor(["java"])

        expect:
        assertThat(s1, not(equalTo(s2))) // application ≠ java
        assertThat(s1, equalTo(s3))      // application = application
        assertThat(s2, equalTo(s5))      // java        = java
        assertThat(s1, equalTo(s4))      // application ⊇ java
    }

    private void assertAccessorsInClassPathOf(File buildFile) {

                .assertTestFailed("encodesAttributeValues", equalTo('java.lang.RuntimeException: html: <> cdata: ]]>'))
                .assertStdout(containsString(
                    "< html allowed, cdata closing token ]]> encoded!\n" +
                    "no EOL, non-asci char: ż\n" +
                    "xml entity: &amp;"
                ))
                .assertStderr(equalTo("< html allowed, cdata closing token ]]> encoded!\n"))
    }