def "can create task with invalid model space name"() {
        given:
        def taskName = "-"

        when:
        buildFile << """
            tasks.create('$taskName').doFirst {}
        """

        run taskName

        then:
        executed ":$taskName"

        when:
        ModelPath.validateName(taskName)

        then:
        thrown(ModelPath.InvalidNameException)
    }

            "  auto {0} = Convert{1}ForOptionWriter(op.{2}(), fbb);\n",
            arg_name, mlir::tblgen::Attribute(arg_def).getAttrDefName(),
            op.getGetterName(arg_name));
        options.push_back(arg_name.str());
      }
    }

    // Add options due to derived attributes.
    for (const auto &val : def->getValues()) {
      if (auto *record = dyn_cast<RecordRecTy>(val.getType())) {

        Task.TASK_ACTION, Task.TASK_DEPENDS_ON, Task.TASK_DESCRIPTION, Task.TASK_GROUP, Task.TASK_NAME, Task.TASK_OVERWRITE, Task.TASK_TYPE, Task.TASK_CONSTRUCTOR_ARGS
    );
    private static final Set<String> MANDATORY_TASK_ARGUMENTS = ImmutableSet.of(
        Task.TASK_NAME, Task.TASK_TYPE
    );

    private final TaskIdentityFactory taskIdentityFactory;
    private final ITaskFactory taskFactory;

                                    def taskName = task.name
                                    task.source(p.tasks.compileJava.source)
                                    task.destinationDirectory = project.file("${p.buildDir}/classes/$taskName")
                                    task.classpath = _compileConfig
                                    task.doFirst {

     * which can then be used to extract information from the XML.
     */
    private static getTestResultsFileAsXml(TestFile sampleDir, String testClassName, String taskName = "test") {
        return new XmlSlurper().parse(getTestResultsFile(sampleDir, testClassName, taskName))
    }

    /**
     * Returns the {@code TestFile} instance representing the required JUnit test
     * results file. Assumes the standard test results directory.

        return taskPath("clean");
    }

    private String taskPath(final String taskName) {
        final String projectPath = binary.getComponent().getProjectPath();
        if (":".equals(projectPath)) {
            return ":" + taskName;
        }

        return projectPath + ":" + taskName;
    }

    @Override
    public boolean isDebuggable() {

}

// tagWebhookConfigFromCanonicalWebhook parses configuration needed to create tag webhook from existing revision webhook.
func tagWebhookConfigFromCanonicalWebhook(wh admitv1.MutatingWebhookConfiguration, tagName, istioNS string) (*tagWebhookConfig, error) {
	rev, err := GetWebhookRevision(wh)
	if err != nil {
		return nil, err
	}
	// if the revision is "default", render templates with an empty revision

          <type>String</type>
          <description></description>
        </field>
        <field xml.tagName="role-hint">
          <name>roleHint</name>
          <version>1.0.0+</version>
          <type>String</type>
          <description></description>
        </field>
        <field xml.tagName="field-name">
          <name>fieldName</name>
          <required>true</required>
          <version>1.0.0+</version>

            }
            """
        )

        val taskName = ":writeInputToFile"

        build(taskName, "-PinputString=string1").assertTasksExecutedAndNotSkipped(taskName)

        build(taskName, "-PinputString=string1").assertTasksSkipped(taskName)

        build(taskName, "-PinputString=string2").assertTasksExecutedAndNotSkipped(taskName)
    }

    @Test

    private publishTestPlugin(Repository repository) {
        def pluginBuilder = new PluginBuilder(testDirectory.file("plugin"))

        def message = "from plugin"
        def taskName = "pluginTask"

        pluginBuilder.addPluginWithPrintlnTask(taskName, message, "org.example.plugin")
        if (repository instanceof MavenRepository) {
            pluginBuilder.publishAs("org.example.plugin:plugin:1.0", repository, executer)