def "contains of existing element is tracked"() {
        when:
        def result = set.contains('existing')

        then:
        result
        1 * listener.onAccess('existing')
        0 * listener._
    }

    def "contains of null is tracked"() {
        when:
        def result = set.contains(null)

        then:
        !result
        1 * listener.onAccess(null)
        0 * listener._
    }

        expect:
        def result = event.convert("")
        result.response == 4
        result.newPrompt == null
    }

    def "can have negative minimum value"() {
        def event = new IntQuestionPromptEvent(123, "question?", -5, -2)

        expect:
        def result = event.convert(input)
        result.response == expected
        result.newPrompt == null

        where:

        result.output =~ /VFS> Statistics during current build:/
        result.output =~ /Received \d+ file system events since last build while watching \d+ locations/
        result.output =~ /Virtual file system retained information about \d+ files, \d+ directories and \d+ missing files since last build/
        result.output =~ /Received \d+ file system events during the current build while watching \d+ locations/

                    parent--;
                }
                parent = result.lastIndexOf('/', parent);
                if (parent < 0) {
                    result = result.substring(idx + 4);
                } else {
                    result = result.substring(0, parent) + result.substring(idx + 3);
                }
            }
        }

        return result;
    }

        1 * c2.checkExpiration() >> { new DaemonExpirationResult(c2Status, "r2") }

        then:
        DaemonExpirationResult result = agg.checkExpiration()
        result.status == allStatus
        result.reason == "r1 and r2"

        where:
        c1Status         | c2Status         | allStatus
        QUIET_EXPIRE     | QUIET_EXPIRE     | QUIET_EXPIRE

    @Override
    public int getFailureCount() {
        int result = 0;
        for (XCTestElement element : getTestSuites()) {
            result += element.getFailureCount();
        }
        return result;
    }

    @Override
    public int getPassCount() {
        int result = 0;
        for (XCTestElement element : getTestSuites()) {
            result += element.getPassCount();
        }
        return result;

        when:
        def result = newResolutionResult(root)

        then:
        result.allDependencies == [dep1, dep2] as Set
        result.allComponents == [root, dep1.selected, dep2.selected] as Set

        when:
        result.allDependencies << newDependency('dep3')
        result.allComponents << newModule('foo')

        then:
        result.allDependencies == [dep1, dep2] as Set

        }

        // Version Range Violation

        if (result.hasVersionRangeViolations()) {
            throw result.getVersionRangeViolation(0);
        }

        // Transfer Error

        if (result.hasErrorArtifactExceptions()) {
            throw result.getErrorArtifactExceptions().get(0);
        }

        if (result.hasMissingArtifacts()) {
            throw new MultipleArtifactsNotFoundException(

            return result;
        }

        private Object writeReplace() {
            return new Fixed<>(result());
        }
    }

    private static class Fixed<T> extends Cached<T> {

        private final Try<T> result;

        public Fixed(Try<T> result) {
            this.result = result;
        }

        @Override
        public T get() {
            return result.get();
        }
    }

    public int hashCode() {
        int result;
        result = name.hashCode();
        result = 31 * result + (type != null ? type.hashCode() : 0);
        result = 31 * result + compilerClasspath.hashCode();
        result = 31 * result + classes.hashCode();
        result = 31 * result + javadoc.hashCode();
        result = 31 * result + sources.hashCode();
        return result;
    }