"""

        when:
        run "sync"

        then:
        file("output").assertHasDescendants("file1.txt", "file2.txt")

        when:
        run "sync"

        then:
        result.assertTaskSkipped(':sync')

        when:
        file("files/dir2").deleteDir()
        file("files/dir3/file3.txt") << ""
        run "sync"

        then:

    override suspend fun WriteContext.encode(value: ProviderInternal<*>) {
        // TODO - should write the provider value type
        providerCodec.run { encodeProvider(value) }
    }

    override suspend fun ReadContext.decode() =
        providerCodec.run { decodeProvider() }
}


class BuildServiceProviderCodec(
    private val buildStateRegistry: BuildStateRegistry
) : Codec<BuildServiceProvider<*, *>> {

                }
            }
            is ConfigurationCacheFingerprint.DirectoryChildren -> input.run {
                if (hasDirectoryChanged(file, hash)) {
                    return "directory '${displayNameOf(file)}' has changed"
                }
            }
            is ConfigurationCacheFingerprint.InputFileSystemEntry -> input.run {
                val newType = fileSystemEntryType(file)
                if (newType != fileType) {

                    void run() {
                        println('task.nested.property = ' + property.orNull)
                    }
                }

                @Nested
                abstract SomeTaskInputs getSomeTaskInputs()

                @TaskAction
                void run() {
                    someTaskInputs.run()
                }
            }

	@(env bash $(PWD)/docs/site-replication/run-multi-site-minio-idp.sh)
	@echo "Running tests for automatic site replication of SSE-C objects"
	@(env bash $(PWD)/docs/site-replication/run-ssec-object-replication.sh)
	@echo "Running tests for automatic site replication of SSE-C objects with SSE-KMS enabled for bucket"
	@(env bash $(PWD)/docs/site-replication/run-sse-kms-object-replication.sh)

				t.Errorf("after a sleep: %d allocations", inuse)
			}
		})
	}

	run(t, "After", func() { After(Hour) })
	run(t, "Tick", func() { Tick(Hour) })
	run(t, "NewTimer", func() { NewTimer(Hour) })
	run(t, "NewTicker", func() { NewTicker(Hour) })
	run(t, "NewTimerStop", func() { NewTimer(Hour).Stop() })
	run(t, "NewTickerStop", func() { NewTicker(Hour).Stop() })
}

func TestChan(t *testing.T) {

                    writeCollection(task.outputs.doNotCacheIfSpecs)
                    writeReasonNotToTrackState(task)
                    beanStateWriterFor(task.javaClass).run {
                        writeStateOf(task)
                        withTaskReferencesAllowed {
                            writeRegisteredPropertiesOf(
                                task
                            )

            if ($expression) {
                tasks.register("run") {
                    doLast { println("ON CI") }
                }
            } else {
                tasks.register("run") {
                    doLast { println("NOT CI") }
                }
            }
        """

        when:
        configurationCacheRun "run"

        then:
        output.count("NOT CI") == 1

            if ($expression) {
                tasks.register("run") {
                    doLast { println("ON CI") }
                }
            } else {
                tasks.register("run") {
                    doLast { println("NOT CI") }
                }
            }
        """

        when: "running without a file present"
        configurationCacheRun "run"

        then:
        output.count("NOT CI") == 1

    if (pass_state == MlirOptimizationPassState::Enabled) {
      VLOG(2) << "Run MLIR graph optimization pass: " << StringRefToView(name);
      VLOG(2) << "Graph #nodes " << (*graph)->num_nodes() << " #edges "
              << (*graph)->num_edges();
      timings.Reset({kTfMlirCategory, name.str()});
      pass_status = pass_registration.pass->Run(
          function_name, config_proto, *module_ref, **graph, *flib_def);