1 * listener2.doSomething("param") >> { throw failure2 }
        1 * listener3.dispatch(invocation)
        0 * _
    }

    def "can remove listener implemented using Proxy that does not implement equals()"() {
        TestListener other1 = Stub(TestListener)
        TestListener other2 = Stub(TestListener)

        } else {
            return CacheVersion.parse("0.1");
        }
    }

    @Override
    boolean wrapperCanExecute(GradleVersion version) {
        if (version.equals(GradleVersion.version("0.8")) || isVersion("0.8")) {
            // There was a breaking change after 0.8
            return false;
        }
        if (isVersion("0.9.1")) {

    }

    def "parses properties args with no property value"() {
        expect:
        convert("-Aa", "-Ab=") == [a: "", b: ""]
    }

    def "parses properties arg containing equals"() {
        expect:
        convert("-Aprop=a b=c", "-Aprop2==", "-Aprop3=ab=") == [prop: 'a b=c', prop2: '=', prop3: 'ab=']
    }

            public class SkippingRuleTests {

                @Rule
                public MethodRule misbehavingSkippingRule = (statement, method, target) -> {
                    assumeFalse(method.getName().equals("b"));
                    return statement;
                };

                @Test
                public void a() {
                }

                @Test
                public void b() {

            } else {
                return vendorComparison
            }
        } else {
            return gcComparison
        }
    }

    boolean equals(o) {
        if (this.is(o)) {
            return true
        }
        if (getClass() != o.class) {
            return false
        }

}

class TestDomainObject implements Attachable<TestDomainObject>, Serializable {
    def value

    TestDomainObject(String value) {
        this.value = value
    }

    @Override
    boolean equals(Object o) {
        return o.value == value
    }

    @Override
    int hashCode() {
        return value.hashCode()
    }

    void attach(ClassMetaDataRepository<TestDomainObject> repository) {

    enum LeftValue {
        LEFT, LEFT2
    }

    enum RightValue {
        RIGHT, RIGHT2
    }

    def left = either(LEFT)
    def right = either(RIGHT)

    def "equals() works"() {
        expect:
        either(LEFT) == either(LEFT)
        either(LEFT2) == either(LEFT2)
        either(LEFT) != either(LEFT2)
        either(LEFT2) != either(LEFT)
        either(LEFT) != either(RIGHT)

        writeCursor == Cursor.at(startRow, TERMINAL_WIDTH)
        writePos == writeCursor
        0 * newLineListener._
    }

    def "a new line after a line wrap will callback the listener with a column value equals to the number of char left from the wrap"() {
        given:
        consoleMetaData.cols >> TERMINAL_WIDTH
        Cursor writePos = Cursor.at(1, 0)
        int startRow = writePos.row

            import java.security.Permission;

            public class MySecurityManager extends SecurityManager {
                public MySecurityManager() {
                    assert getClass().getName().equals(System.getProperty("java.security.manager"));
                }

                @Override
                public void checkPermission(Permission permission) {
                }
            }

        settingsFile << """
          pluginManagement {
            repositories {
              ${repo instanceof MavenRepository ? "maven" : "ivy"} {
                  url "${PathType.ABSOLUTE.equals(pathType) ? repo.uri : repo.rootDir.name}"
              }
            }
          }
        """
        repo.uri
    }

    def "can resolve plugin from #pathType #repoType repo"() {
        given: