and:
        buildFile << """
            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:

            return viewBuilder.build(parameter)!!
        }

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

                    "({languageVersion=99, vendor=matching('exotic'), implementation=vendor-specific}) from '$archiveUri', " +
                    "due to: Unpacked JDK archive does not contain a Java home: " + temporaryFolder.testDirectory.file("user-home", ".tmp", "jdks", "toolchain"))
    }

    def "can download with basic authentication"() {
        settingsFile <<

                                     ArrayAttr explicit_paddings,
                                     Value &padding, int num_dims = 4);

// Given value that is in 8bit type, but holds 4bit data in unpacked format,
// pack to nibble format along pack_dim.
// If the pack_dim size is odd, add 1-size 0 padding and then pack.
Value PackOperand(OpBuilder &builder, Location loc, Value value, int pack_dim);

     */
    @Nullable
    Object unpackState();

    /**
     * Is this object graph immutable? Returns false if this object may be mutable, in which case the state should be unpacked and isolated.
     */
    boolean isImmutable();

    /**
     * Returns the public type of this managed instance. Currently is used to identify the implementation.
     */
    Class<?> publicType();

    /**

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

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

        when:
        def result = provider.getOrNull()

        then:
        result == ["left", "right"]
        1 * leftSideEffect.execute("left")

        then: // ensure ordering

        def dslDir = sample.dir.file(dsl)
        executer.inDirectory(dslDir)

        when:
        succeeds('javadocJar', 'unpackJavadocs')

        then: "The HTML Javadoc files are unpacked to the 'dist' directory"
        dslDir.file('build/dist/org/example/app/HelloApp.html').isFile()

        where:
        dsl << ['groovy', 'kotlin']
    }

    @UsesSample("antMigration/multiProject")

 * Nested {@code Map}s, {@code Iterable}s are resolved as child properties.
 * Nested iterables and maps can be further nested, i.e. {@code Map<String, Iterable<Iterable<String>>>} is supported.
 * Nested {@link Provider}s are unpacked, and the provided type is traversed transparently.
 */
public interface TypeMetadataWalker<T, V extends TypeMetadataWalker.TypeMetadataVisitor<T>> {

    /**

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

class ProviderStartParameterConverter {

    private List<TaskExecutionRequest> unpack(final List<InternalLaunchable> launchables) {
        // Important that the launchables are unpacked on the client side, to avoid sending back any additional internal state that

// your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked.
// The next step is to copy (using pkg/conversion) into the internal struct. The runtime
// package's DefaultScheme has conversion functions installed which will unpack the
// JSON stored in RawExtension, turning it into the correct object type, and storing it