public RunDefaultTasksExecutionRequest(@Nullable String projectPath, @Nullable File rootDir) {
        this.projectPath = projectPath;
        this.rootDir = rootDir;
    }

    @Override
    public List<String> getArgs() {
        return Collections.emptyList();
    }

    @Nullable
    @Override
    public String getProjectPath() {
        return projectPath;
    }

    @Nullable
    @Override

                <tr>
                    <td>Name</td>
                </tr>
            </thead>
            <tr>
                <td>dir</td>
            </tr>
            <tr>
                <td>getDirs</td>
            </tr>
        </table>
    </section>

public interface TaskExecutionRequest {
    /**
     * The arguments to use to select and optionally configure the tasks, as if provided on the command-line.
     *
     * @return task name.
     */
    List<String> getArgs();

    /**
     * Project path associated with this task request if any.
     *
     * @return project path or {@code null} to use the default project path.
     */
    @Nullable String getProjectPath();

        this.workDirectory = workDirectory;
        this.args = args;
        this.context = context;
        this.oplogger = oplogger;
    }

    @Override
    public Iterable<String> getArgs() {
        return args;
    }

    @Override
    public BuildOperationLogger getLogger() {
        return oplogger;
    }

    @Override
    public File getWorkDirectory() {

package org.gradle.api.flow;

import org.gradle.api.Incubating;

/**
 * Marker interface for {@link FlowAction dataflow action} parameters.
 *
 * <p>
 * Parameter types should be interfaces, only declaring getters for {@link org.gradle.api.provider.Property}-like objects.
 * Example:
 * </p>
 * <pre>
 * public interface MyFlowParameters extends FlowParameters {
 *    Property&lt;String&gt; getString();

        this.backingDescriptor = backingDescriptor;
    }

    @Override
    public Type getType() {
        return Type.FLAT_DIR;
    }

    public ImmutableList<File> getDirs() {
        return dirs;
    }

    public IvyRepositoryDescriptor getBackingDescriptor() {
        return backingDescriptor;
    }

    @Override

    @Override
    ExecHandle build() {
        if (OperatingSystem.current().isWindows()) {
            def theArgs = ['/d', '/c', executable.replace('/', File.separator)] + getArgs()
            setArgs(theArgs) //split purposefully to avoid weird windows CI issue
            executable = 'cmd.exe'
        } else {
            executable = "${workingDir}/${executable}"
        }

 */

package org.gradle.test.fixtures.ivy

import org.gradle.test.fixtures.resource.RemoteArtifact

interface RemoteIvyModule extends IvyModule {
    RemoteArtifact getIvy()
    RemoteArtifact getJar()

    }

    public List<TaskSelection> parseTasks(TaskExecutionRequest taskExecutionRequest) {
        List<TaskSelection> out = new ArrayList<>();
        List<String> remainingPaths = new LinkedList<String>(taskExecutionRequest.getArgs());
        while (!remainingPaths.isEmpty()) {
            String path = remainingPaths.remove(0);

      /*is_qdq_conversion=*/false);

  quantization_driver.Initialize();
  ASSERT_TRUE(quantization_driver.PropagateParamsAndReturnIfChanged());
  EXPECT_THAT(quantization_driver.GetArgs(), Not(IsEmpty()));

  for (const auto& arg : quantization_driver.GetArgs()) {
    const QuantState& state = quantization_driver.GetArgQuantState(arg);
    EXPECT_TRUE(isa<quant::QuantizedType>(state.params));
  }