class TaskWithSources {
        String outputDir = "build/output"
        File inputFile = file('src/data/input.txt')
        String taskName = 'test'

        String getBuildScript() {
            """
                apply plugin: 'base'

                task ${taskName} {
                    def sources = file("src")
                    inputs.dir sources skipWhenEmpty()

public class DaemonJvmPropertiesConfigurator implements ProjectConfigureAction {

    public static final String TASK_NAME = "updateDaemonJvm";

    @Override
    public void execute(ProjectInternal project) {
        // Only useful for the root project
        if (project.getParent() == null) {
            project.getTasks().register(TASK_NAME, UpdateDaemonJvm.class, task -> {
                task.setGroup("Build Setup");

        }
    }

    private void executeTaskViaGradleProjectLaunchable(String taskName) {
        withConnection { connection ->
            def gradleProjects = connection.action(new LoadCompositeModel(GradleProject)).run()
            def launchables = findLaunchables(gradleProjects, taskName)
            assert launchables.size == 1
            def build = connection.newBuild()

@ServiceScope(Scope.BuildTree.class)
public interface TaskSelector {
    Spec<Task> getFilter(SelectionContext context, ProjectState project, String taskName, boolean selectAllMatching);

    TaskSelection getSelection(SelectionContext context, ProjectState project, String taskName, boolean selectAllMatching);

    class SelectionContext {
        private final Path originalPath;
        private final String type;

{% for section_name, section_content in external_links.items() %}

## {{ section_name }}

{% for lang_name, lang_content in section_content.items() %}

### {{ lang_name }}

{% for item in lang_content %}

            return true;
        }
        return false;
    }

    public void addChildUrlRule(final String tagName, final String attrName) {
        if (StringUtil.isNotBlank(tagName) && StringUtil.isNotBlank(attrName)) {
            childUrlRuleMap.put(tagName, attrName);
        }
    }

    protected XPathAPI getXPathAPI() {
        XPathAPI cachedXPathAPI = xpathAPI.get();

    /**
     * Generates a name for a task that performs some action on the binary.
     */
    String taskName(String verb);

    /**
     * Generates a name for a task that performs some action on the binary.
     */
    String taskName(String verb, String object);

    /**
     * The task that can be used to assemble this binary.
     */
    Task getBuild();

    /**

        return backingRepo.createBranch(branchName);
    }

    @Override
    public Ref createLightWeightTag(String tagName) throws GitAPIException {
        return backingRepo.createLightWeightTag(tagName);
    }

    public BlockingHttpServer.ExpectedRequest listVersions() {
        return server.get(backingRepo.getName() + "/info/refs", getRefsAction());
    }

    }

    protected ExecutionResult runTask(taskName, settingsScript = "rootProject.name = 'root'", buildScript) {
        def settingsFile = file("settings.gradle")
        settingsFile << settingsScript

        def buildFile = file("build.gradle")
        buildFile << buildScript

        return executer.withTasks(taskName).run()
    }

    protected TestFile getFile(Map options, String filename) {

        expect:
        def namingScheme = createNamingScheme(parentName, type, dimensions)
        namingScheme.getTaskName(verb, target) == taskName

        where:
        parentName | type   | dimensions     | verb       | target    | taskName
        null       | "type" | []             | null       | null      | "type"
        null       | "type" | ["one", "two"] | null       | null      | "oneTwoType"