/**
 * Represents an {@link Encoder} that buffers encoded data prior to writing to the backing stream.
 */
public interface FlushableEncoder extends Encoder, Flushable {
    /**
     * Ensures that all buffered data has been written to the backing stream. Does not flush the backing stream.
     */
    @Override
    void flush() throws IOException;

     */
    ComponentIdentifier getId();

    /**
     * The immutable metadata for this component.
     */
    ComponentGraphResolveMetadata getMetadata();

    /**
     * Returns the public view of all variants of this component that are available for variant selection, either during graph resolution or artifact resolution.
     */
    List<ResolvedVariantResult> getAllSelectableVariantResults();

    /**

[[sub:viewing_toolchains]]
=== Viewing and debugging toolchains

Gradle can display the list of all detected toolchains including their metadata.

For example, to show all toolchains of a project, run:

```
gradle -q javaToolchains
```

.Output of **`gradle -q javaToolchains`**
----
> gradle -q javaToolchains

 + Options

                            )
                        )
                    )
                ]
            )""".trimIndent()
        results.assert(expected)
    }

    @Test
    fun `parses call chain`() {
        val results = parse("f(1).g(2).h(3)")

        val expected = """
            FunctionCall [indexes: 10..14, line/column: 1/11..1/15, file: test] (
                name = h

You can also list the tasks only available in the `app` subproject by running `./gradlew :app:tasks`.

TIP: You can obtain more information in the task listing using the `--all` option: `./gradlew tasks --all`.

In <<part1_gradle_init.adoc#part1_begin,part 1>> of the tutorial, we ran the `build` task using the `./gradlew build` command.

== Step 2. Understanding Tasks

}

table.grid-all th.tableblock,
table.grid-all td.tableblock {
	border-width: 0 1px 1px 0;
}

table.grid-all tfoot>tr>th.tableblock,
table.grid-all tfoot>tr>td.tableblock {
	border-width: 1px 1px 0 0;
}

table.grid-cols th.tableblock,
table.grid-cols td.tableblock {
	border-width: 0 1px 0 0;
}

table.grid-all *>tr>.tableblock:last-child,

import static org.gradle.api.internal.artifacts.result.ResolutionResultDataBuilder.newVariant

class DefaultResolutionResultTest extends Specification {

    def "provides all modules and dependencies including unresolved"() {
        given:
        def dep1 = newDependency('dep1')
        def dep2 = newDependency('dep2')

        def root = newModule('root').addDependency(dep1).addDependency(dep2)

        buildFile << """
            tasks.register("foo")
        """

        when:
        configurationCacheRun(":foo")
        then:
        def realizeOps = buildOperations.all(RealizeTaskBuildOperationType)
        realizeOps.size() == 2
        realizeOps*.details.each {
            assert it.taskPath == ":foo"
        }
        realizeOps.first().details.eager == false

        List<String> jvmOptions
        if (!originalJvmOptions) {
            jvmOptions = []
        } else {
            jvmOptions = originalJvmOptions.collect { it.toString() }  // makes sure that all elements are java.lang.String instances
        }
        if (!JavaVersion.current().isJava8Compatible() && jvmOptions.count { it.startsWith('-XX:MaxPermSize=') } == 0) {
            jvmOptions << '-XX:MaxPermSize=256m'
        }

        def resultHandler = new TestResultHandler()

        when:
        def connector = toolingApi.connector()
        ProjectConnection connection = connector.connect() // using withConnection would call close after the closure

        def build = connection.newBuild()
        build.forTasks('hang')
        build.run(resultHandler)
        sync.waitForAllPendingCalls(resultHandler)
        connector.disconnect()