Object unpacked = DeferredUtil.unpackOrNull(value);
        return finalizeValue(unpacked);
    }

    @Nullable
    private static Object finalizeValue(@Nullable Object unpacked) {
        if (unpacked instanceof GString) {
            return unpacked.toString();
        }
        return unpacked;
    }

                inputFile.set(createArchive.flatMap { it.outputFile })
                outputFile.set(layout.buildDirectory.file("unpacked/file.txt"))
            }
        """

        when:
        run "myTask"

        then:
        file("build/unpacked/file.txt").isFile()

        where:
        archiveType << ['gzip', 'bzip2']
    }

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

        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:

    RankedTensorType word_type = RankedTensorType::get({}, state_element_type);
    auto unpacked = rewriter.create<UnpackOp>(
        loc, SmallVector<Type, 4>(state_size, word_type), state, 0);
    Value key = unpacked.getResult(counter_size);

    SmallVector<Value, 4> counter;
    for (int i = 0; i < counter_size; ++i) {
      counter.push_back(unpacked.getResult(i));
    }

    // Set the increment to 256 * delta.

    }

    /**
     * Unpacks and installs the given JDK archive. Returns a file pointing to the java home directory.
     */
    public File provisionFromArchive(JavaToolchainSpec spec, File jdkArchive, URI uri) throws IOException {
        // Unpack into temporary directory (but on same file system as our target directory location)
        File unpackFolder = unpack(jdkArchive);
        try {

</msg>
</logentry>
</log>
-- conf/authz --
-- conf/passwd --
-- conf/svnserve.conf --
-- db/current --
0
-- db/format --
6
layout sharded 1000
-- db/fs-type --
fsfs
-- db/fsfs.conf --
-- db/min-unpacked-rev --
0
-- db/revprops/0/0 --
K 8
svn:date
V 27
2017-09-22T01:11:53.895835Z
END
-- db/revs/0/0 --
PLAIN
END
ENDREP
id: 0.0.r0/17
type: dir
count: 0

                    "({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);