when:
        def result = new DefaultTestResult(state)

        then:
        result.getStartTime() == 100L
        result.getEndTime() == 200L
        result.resultType == ResultType.SKIPPED
        result.exceptions == state.failures.collect { it.rawFailure }
        result.testCount == state.testCount
        result.successfulTestCount == state.successfulCount
        result.failedTestCount == state.failedCount
    }

        def result = serialize(event, serializer)

        then:
        result instanceof LogEvent
        result.timestamp == TIMESTAMP
        result.category == CATEGORY
        result.logLevel == LogLevel.LIFECYCLE
        result.message == MESSAGE
        result.throwable.getClass() == event.throwable.getClass()
        result.throwable.message == event.throwable.message

    }

    @Override
    protected <RESULT extends WebConfig> RESULT createEntity(Map<String, Object> source, Class<? extends RESULT> entityType) {
        try {
            final RESULT result = entityType.newInstance();
            result.setAvailable(DfTypeUtil.toBoolean(source.get("available")));
            result.setBoost(DfTypeUtil.toFloat(source.get("boost")));

    def "caches result from backing cache and reuses for other instances with the same cache id"() {
        given:
        def cache = cacheFactory.decorator(100, true).decorate("path/fileSnapshots.bin", "fileSnapshots", target, crossProcessCacheAccess, asyncCacheAccess)

        when:
        def result = cache.getIfPresent("key")

        then:
        result == "result"

        and:

        """

        when:
        def result = runner("helloWorld1", "helloWorldBuildSrc")
            .withPluginClasspath(plugin.implClasspath)
            .build()

        then:
        result.task(":helloWorld1").outcome == SUCCESS
        result.task(":helloWorldBuildSrc").outcome == SUCCESS
        result.output.contains "Hello world!1"
        result.output.contains "Hello world! (buildSrc)"
    }

        result.result

        then:
        def e = thrown(RuntimeException)
        e == failure
    }

    def "can mark as successful after failed"() {
        given:
        def failure = new RuntimeException()
        result.failed(failure)
        result.resolved("result")

        expect:
        result.hasResult()
        result.successful
        result.failure == null
        result.result == "result"

     */
    class Result {
        private final boolean hasResult;
        private final Object result;
        private final Throwable buildFailure;
        private final Throwable clientFailure;
        private static final Result NOTHING = new Result(false, null, null, null);
        private static final Result NULL = new Result(true, null, null, null);

        this.projectSelector = new ProjectSelector(); // if necessary switch to DI
    }

    @Override
    public Result<ProjectDependencyGraph> build(MavenSession session) {
        try {
            Result<ProjectDependencyGraph> result = sessionDependencyGraph(session);

            if (result == null) {
                final List<MavenProject> projects = getProjectsForMavenReactor(session);

    Stream<Entry<T>> stream();

    <RESULT> RESULT withNode(VfsRelativePath targetPath, CaseSensitivity caseSensitivity, NodeHandler<T, RESULT> handler);

    interface NodeHandler<T, RESULT> {
        RESULT handleAsDescendantOfChild(VfsRelativePath pathInChild, T child);
        RESULT handleAsAncestorOfChild(String childPath, T child);
        RESULT handleExactMatchWithChild(T child);
        RESULT handleUnrelatedToAnyChild();
    }

        this.result = result
    }

    SomeTypeWithMultipleConstructors(Number result) {
        this.result = result
    }
}

class SomeTypeWithPrimitiveTypes {
    final Object result

    SomeTypeWithPrimitiveTypes(boolean result) {
        this.result = result
    }
}

class TypeWithAmbiguousConstructor {
    TypeWithAmbiguousConstructor(CharSequence param) {
    }