*/
    void onlyIf(Closure onlyIfClosure);

    /**
     * Do not track the state of the task.
     *
     * <p>Instructs Gradle to treat the task as untracked.
     *
     * @see org.gradle.api.tasks.UntrackedTask
     * @since 7.3
     */
    void doNotTrackState(String reasonNotToTrackState);

    /**

    }

    def "getProperty(String) is tracked for non-string values"() {
        when:
        def result = getMapUnderTestToRead().getProperty('keyWithNonStringValue')

        then:
        result == null
        1 * listener.onAccess('keyWithNonStringValue', NON_STRING_VALUE)
    }

    def "getProperty(String, String) is tracked for non-string values"() {
        when:

        0 * onChange._
    }

    def "remove(null) is not tracked and throws"() {
        when:
        getMapUnderTestToWrite().remove(null)

        then:
        thrown(NullPointerException)
        0 * onAccess._
        0 * onChange._
        0 * onRemove._
    }

    def "keySet().remove(null) is not tracked and throws"() {
        when:

        when:
        provider.calculateValue(ValueSupplier.ValueConsumer.IgnoreUnsafeRead)
        provider.calculateExecutionTimeValue()

        then:
        0 * _ // no side effects when values are not unpacked

        when:
        counter.set(23)
        def unpackedValue = getter(provider, method, 88)
        then:
        unpackedValue == 23
        1 * sideEffect.execute(23)

        when:

		var ref OtherInterface
		tracked := &resource.FakeResource{IDValue: "1"}
		err := act(&ref, tracked)
		g.Expect(err).To(BeNil())
		g.Expect(tracked).To(Equal(ref))
	})
	t.Run("slice reference", func(t *testing.T) {
		g := NewWithT(t)
		existing := &resource.FakeResource{IDValue: "1"}
		tracked := &resource.FakeResource{IDValue: "2"}
		ref := []OtherInterface{existing}
		err := act(&ref, tracked)
		g.Expect(err).To(BeNil())

        // Unpack into temporary directory (but on same file system as our target directory location)
        File unpackFolder = unpack(jdkArchive);
        try {
            // Get the folder that is the real root of the unpacked JDK, skipping any archive root folder
            UnpackedRoot unpackedRoot = determineUnpackedRoot(unpackFolder);

            validateMetadataMatchesSpec(spec, uri, unpackedRoot.metadata);

        return objectFileDir;
    }

    /**
     * Returns the header directories to be used for compilation.
     */
    @Internal("The paths for include directories are tracked via the includePaths property, the contents are tracked via discovered inputs")
    public ConfigurableFileCollection getIncludes() {
        return includes;
    }

    /**

    // Last write is indirectly tracked by any read predecessor we added.
    is_last_write_indirectly_tracked =
        !access_info.reads_since_last_write.empty();
  }
  if (!is_last_write_indirectly_tracked) {
    // Add last write as predecessor since it was not indirectly tracked.
    new_control_predecessors.insert(access_info.last_writes.begin(),

        def value = provider.calculateValue(ValueSupplier.ValueConsumer.IgnoreUnsafeRead)
        def executionTimeValue = provider.calculateExecutionTimeValue()
        then:
        0 * _ // no side effects when values are not unpacked

        when:
        def unpackedValue = value.get()
        then:
        unpackedValue == someValue()
        1 * sideEffect.execute(someValue())
        0 * _

        when:

        def jansiLibraryLocator = new JansiStorageLocator()
        def jansiStorage = jansiLibraryLocator.locate(nativeDir)
        library = jansiStorage.targetLibFile
    }

    def "native services libs are unpacked to gradle user home dir"() {
        given:
        executer.withArguments('-q')

        when:
        succeeds("help")

        then:
        nativeDir.directory
    }