include::sample[dir="snippets/tasks/incrementalBuild-incrementalBuildAdvanced/groovy",files="build.gradle[tags=git-clone]"]
====
<1> Declare the task as untracked.
<2> Use the output directory to run the external tool.
<3> Add the task and configure the output directory in your build.

[[sec:configure_input_normalization]]
=== Configure input normalization

            task unpack(type: Copy) {
                from $treeMethod("$archName")
                into 'unpacked'
            }
            """

        when:
        run "unpack"
        and:
        then:
        file("unpacked/testdir").mode == 0753
        file("unpacked/testdir/reference.txt").mode == 0762
        where:
        taskName | packMethod | treeMethod

    }

    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:

    def "contains of existing element is tracked"() {
        when:
        def result = set.contains('existing')

        then:
        result
        1 * listener.onAccess('existing')
        0 * listener._
    }

    def "contains of null is tracked"() {
        when:
        def result = set.contains(null)

        then:
        !result

    def "get(null) is not tracked and throws"() {
        when:
        getMapUnderTestToRead().get(null)

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

    def "getOrDefault(null) is not tracked and throws"() {
        when:
        getMapUnderTestToRead().getOrDefault(null, "defaultValue")

        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:

}

// Returns true if the given `value` has the specified rank or has unranked
// type.
inline bool IsOfRankOrUnranked(Value value, int64_t rank) {
  RankedTensorType type = GetRankedTensorTypeForOperand(value);
  return !type || type.getRank() == rank;
}

// Returns true if the given `value` has at least the specified rank or has
// unranked type.
inline bool HasRankAtLeast(Value value, int64_t rank) {

        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:

            return viewBuilder.build(parameter)!!
        }

        override fun getHash(): HashCode {
            val unpacked = ToolingParameterProxy.unpackProperties(parameter)
            return Hashing.hashHashable(valueSnapshotter.snapshot(unpacked))
        }
    }

		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())