this.tasks = tasks;
        this.throwable = throwable;
    }

    public BuildOperationParameters getBuildOperationParameters() {
        return buildOperationParameters;
    }

    public String getOutput() {
        return output;
    }

    public List<BuildTask> getTasks() {
        return tasks;
    }

    public Throwable getThrowable() {
        return throwable;
    }

    void item(String title, Iterable<String> values);

    void item(String title, File value);

    void item(String value);

    void item(File value);

    StyledTextOutput getOutput();

    // argument in the list.
    auto arg = bb.getArgument(0);

    auto remove_quantize_op = [&](QuantizeOp quantize_op) {
      auto quantize_output = quantize_op.getOutput();
      auto quantize_type = quantize_output.getType();
      input_types.push_back(quantize_type);
      auto new_arg = bb.addArgument(quantize_type, loc);
      quantize_output.replaceAllUsesWith(new_arg);

        return new EclipseClasspathFixture(userHomeDir, new XmlParser().parse(file))
    }

    List<Node> getEntries() {
        return this.classpath.classpathentry as List
    }

    String getOutput() {
        return this.classpath.classpathentry.find { it.@kind == 'output' }.@path
    }

    List<String> getContainers() {
        return this.classpath.classpathentry.findAll { it.@kind == 'con' }.collect { it.@path }

        assertEquals(1, stemmerOverrideItem.getId());
        assertEquals("aaa", stemmerOverrideItem.getInput());
        assertEquals("a", stemmerOverrideItem.getOutput());
        assertNull(stemmerOverrideItem.getNewInput());
        assertNull(stemmerOverrideItem.getNewOutput());
        assertFalse(stemmerOverrideItem.isUpdated());
        assertFalse(stemmerOverrideItem.isDeleted());

            return delegateResult
        }
        0 * _

        when:
        def output = result.getOutputAs(Object)

        then:
        output.get() == delegateOutput
        1 * delegateExecution.getOutput(workspace) >> delegateOutput
        0 * _
    }

        task.getJvmArgumentProviders().add(new JacocoAgent(extension));
        task.doFirst(new JacocoOutputCleanupTestTaskAction(
            fs,
            providers.provider(() -> extension.isEnabled() && extension.getOutput() == JacocoTaskExtension.Output.FILE),
            providers.provider(extension::getDestinationFile)
        ));

        // Do not cache the task if we are not writing execution data to a file

     * @throws CIFSException
     */
    InputStream getInput () throws CIFSException;


    /**
     * 
     * @return this pipe's output stream
     * @throws CIFSException
     */
    OutputStream getOutput () throws CIFSException;


    /**
     * {@inheritDoc}
     * 
     * @throws CIFSException
     *
     * @see java.lang.AutoCloseable#close()
     */
    @Override

                    .nagUser();

                return ((JvmTestSuite) testing.getSuites().findByName(JvmTestSuitePlugin.DEFAULT_TEST_SUITE_NAME)).getSources().getOutput().getClassesDirs();
            });
            test.getConventionMapping().map("classpath", () -> {
                DeprecationLogger.deprecate("Relying on the convention for Test.classpath in custom Test tasks")

                        .withArguments("customTask")
                        .withPluginClasspath()
                        .build();

                    assertTrue(result.getOutput().contains("Hello from plugin"));
                    assertTrue(result.getOutput().contains("Hello from custom task"));
                }
            }
        """
    }