// Verify some assumptions: that we've got the correct characters in there, and that we're not using the system encoding
        assert code.contains(new String(Character.toChars(0x3b1)))
        assert !Arrays.equals(code.bytes, file.bytes)
    }

    def badCode() {
        file("src/main/scala/compile/test/Person.scala") << """package compile.test

class Person(val name: String, val age: Int) {

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

        e.message.contains("Unexpected type for attribute 'test' provided. Expected a value of type java.lang.String but found a value of type java.lang.Integer.")
    }

    def "equals should return true for 2 containers with different provider instances that return the same value"() {
        Property<String> testProperty1 = new DefaultProperty<>(Mock(PropertyHost), String).convention("value")

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

        result.testClass("LoggingTest").assertStderr(equalTo("This is stderr.\n"))

        when:
        executer.withArguments("-DLogLessStuff=true")
        run "test"

        then:
        result.testClass("LoggingTest").assertStdout(equalTo("stdout.\n"))
        result.testClass("LoggingTest").assertStderr(equalTo("stderr.\n"))
    }

        !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"))

                            asNode().dependencyManagement.dependencies.dependency.findAll { node ->
                                node.groupId[0].text().equals('org.test') &&
                                node.artifactId[0].text().equals('platform') &&
                                node.scope[0].text().equals('import')
                            }.each { node -> node.replaceNode {} }
                        }
                    }

                                                                     ExtensionContext extensionContext) {
                                        return parameterContext.getParameter().getType().equals(Locale.class);
                                    }

                                    @Override
                                    public Object resolveParameter(ParameterContext parameterContext,