"""

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

:last-child.list-group-item {
	border-radius: 0px;
}

#result ol li {
	margin: 1em 0;
}

#result ol li:first-child {
	margin-top: 0;
}

#result .title a:visited {
	color: #014c8c;
}

#result .body {
	display: flex;
	align-items: flex-start;
}

#result .site cite {
	color: #093;
	font-style: normal;
}

#result .more {
	display: none;
}

#result .info {

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

    }

    def "reads multiple lines"() {
        expect:
        def reader = new PreprocessingReader(new StringReader("""
line 1

line 2""".replace('\n', eol)))
        def result = new StringBuilder()
        reader.readNextLine(result)
        result.toString() == ""

        result.setLength(0)
        reader.readNextLine(result)
        result.toString() == "line 1"

        result.setLength(0)

        String result = original;

        // Unquote
        if (result.indexOf('\"') >= 0) {
            final Matcher m = QUOTE_REPLACE_PATTERN.matcher(original);
            if (m.matches()) {
                result = m.group(1);
            }

            // Unescape
            if (result.indexOf(ESCAPED_QUOTE) >= 0) {
                result = result.replace(ESCAPED_QUOTE, "\"");
            }

				},
			},
			"SELECT * FROM `users` ORDER BY FIELD(id, ?,?,?)",
			[]interface{}{1, 2, 3},
		},
	}

	for idx, result := range results {
		t.Run(fmt.Sprintf("case #%v", idx), func(t *testing.T) {
			checkBuildClauses(t, result.Clauses, result.Result, result.Vars)
		})
	}