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.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
        // the launchable may hold onto. For example, GradleTask implementations hold onto every task for every project in the build

// 			"aOption":"foo",
// 		},
// 	}
//
// So what happens? Decode first uses json or yaml to unmarshal the serialized data into
// 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

// 			"aOption":"foo",
// 		},
// 	}
//
// So what happens? Decode first uses json or yaml to unmarshal the serialized data into
// 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

//			"aOption":"foo",
//		},
//	}
//
// So what happens? Decode first uses json or yaml to unmarshal the serialized data into
// 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

</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

            unpackedValue = ((Provider<?>) unpackedValue).getOrNull();
        }
        if (unpackedValue == null) {
            return;
        }
        // From here on, we already unpacked providers, so we can fail if any of the file collections contains a provider which is not present.
        if (filePropertyType == OutputFilePropertyType.DIRECTORIES || filePropertyType == OutputFilePropertyType.FILES) {

// RUN:   -split-input-file | FileCheck %s --check-prefix=CHECK-NO-UNPACK

// Tests that a simple dot_general (lifted as a function) with CustomAggregators
// around it is quantized. The resulting graph has quantized types unpacked into
// int ops.
func.func @main(%arg0: tensor<1x1024xf32>) -> tensor<1x3xf32> {
  %0 = "tf.Const"() <{value = dense<0.5> : tensor<1024x3xf32>}> : () -> tensor<1024x3xf32>

    /**
     * To further categorize tests. (We should simplify this and get rid of the subclasses if possible)
     */
    @get:Internal
    abstract val prefix: String

    /**
     * A local Gradle installation (unpacked distribution) to test against if the tests should fork a new Gradle process (non-embedded)
     */
    @Internal
    val gradleInstallationForTest = GradleInstallationForTestEnvironmentProvider(project, this)

    /**