when:
        run("-q", ":printScriptOutput")

        then:
        outputContains("Script output")
    }

    def "task with providers.exec provider input is up to date for second run"() {
        given:
        def testScript = ShellScript.builder()
            .printText("Script output")
            .writeTo(testDirectory, "script")

        buildFile """

                def outputFile = new File(buildDir, "output")
                inputs.file("input")
                outputs.file(outputFile)
                outputs.cacheIf { true }

                doLast {
                    outputFile.parentFile.mkdirs()
                    outputFile.text = "done"
                }
            }
"""
        def cacheDir = file("task-output-cache")
        settingsFile << """

        outputs.fileProperties*.propertyFiles*.files.flatten() == [file("a")]
        outputs.fileProperties*.outputFile == [file("a")]
        outputs.fileProperties*.outputType == [FILE]
    }

    def "can register output dir"() {
        when:
        outputs.dir("a")
        then:
        outputs.files.files == files('a')
        outputs.fileProperties*.propertyName == ['$1']

     * as this does not include overlapping outputs not produced by the work.
     */
    ImmutableSortedMap<String, FileSystemSnapshot> getOutputFilesProducedByWork();

    /**
     * The origin metadata of the outputs captured.
     */
    OriginMetadata getOriginMetadata();

    /**
     * Whether the outputs come from a previous execution.
     */
    boolean isReused();

            32,
            16
          ],
          "name": "output",
          "quantization": {
          }
        }
      ],
      "inputs": [
        0,
        1
      ],
      "outputs": [
        2
      ],
      "operators": [
        {
          "inputs": [
            0,
            1
          ],
          "outputs": [
            2
          ],

  //    operators. We also convert the XlaClusterOutput output nodes of the
  //    function call into the outputs of the XlaLaunch operator.
  static Status BuildXlaLaunchOps(Graph* graph);

  struct XlaFunctionInfo {
    int variable_start_index = -1;
    std::string function_name;
  };

  // We need to introduce this version to adapt to the output of gpu inference

    @get:InputArtifact
    @get:Classpath
    abstract val inputArtifact: Provider<FileSystemLocation>

    override fun transform(outputs: TransformOutputs) {
        val jarFile = inputArtifact.get().asFile
        val zipFile = ZipFile(jarFile)
        val outputRoot = outputs.dir("public-api")
        zipFile.stream().forEach { entry ->
            if (entry.shouldInclude()) {

            outputFile = "${sourceSets.main.get().output.resourcesDir}/output.js"
            sourceMap = true
        }
    }
    val unpackKotlinJsStdlib by registering {
        group = "build"
        description = "Unpack the Kotlin JavaScript standard library"
        val outputDir = file("$buildDir/$name")
        inputs.property("compileClasspath", configurations.compileClasspath.get())
        outputs.dir(outputDir)
        doLast {

     *
     * @since 8.3
     */
    NOT_CACHEABLE,

    /**
     * The work has no outputs declared.
     */
    NO_OUTPUTS_DECLARED,

    /**
     * The work has a {@code org.gradle.api.file.FileTree} or {@code org.gradle.api.internal.file.collections.DirectoryFileTree} as an output.
     *
     * @since 5.0
     */
    NON_CACHEABLE_TREE_OUTPUT,

    /**

    private final String[] inputs;

    private final String[] outputs;

    private String[] newInputs;

    private String[] newOutputs;

    public SynonymItem(final long id, final String[] inputs, final String[] outputs) {
        this.id = id;
        this.inputs = inputs;
        this.outputs = outputs;

        if (id == 0) {
            // create
            newInputs = inputs;