val zip: FileTree = zipTree("someFile.zip")

// Create a TAR file tree using path
val tar: FileTree = tarTree("someFile.tar")

// tar tree attempts to guess the compression based on the file extension
// however if you must specify the compression explicitly you can:
val someTar: FileTree = tarTree(resources.gzip("someTar.ext"))

        failure.assertHasCause("'$badVersion' is not a valid Gradle version string (examples: '1.0', '1.0-rc-1')")
        failure.assertHasResolution("Specify a valid Gradle release listed on https://gradle.org/releases/.")
        failure.assertHasResolution("Use one of the following dynamic version specifications: 'latest', 'release-candidate', 'release-nightly', 'nightly'.")

1. From the distribution's project, such as an application or WAR subproject -> link:../samples/sample_jvm_multi_project_with_code_coverage_distribution.html[distribution sample]
2. Using a standalone project to specify subprojects -> link:../samples/sample_jvm_multi_project_with_code_coverage_standalone.html[standalone sample]

Example 2 could also be used to aggregate results via the root project.

				},
			},
		},
		{
			name:                   "CSRSigningControllerOptions KubeletServingSignerConfiguration no cert file",
			expectErrors:           true,
			expectedErrorSubString: "cannot specify key without cert",
			options: &CSRSigningControllerOptions{
				&csrsigningconfig.CSRSigningControllerConfiguration{
					ClusterSigningCertFile: "",
					ClusterSigningKeyFile:  "",

        then:
        collection.toString() == 'test files'
        files == [tmpDir.file('abc'), tmpDir.file('def')] as Set
    }

    def 'can use a Closure for resolving collection to specify a single file'() {
        def collection = factory.resolving('test files', [{ 'abc' }] as Object[])

        when:
        Set<File> files = collection.getFiles()

        then:

                "Expected 'UnresolvableModelException' not thrown.");
        assertEquals("The requested parent version range '[1,)' does not specify an upper bound", e.getMessage());
    }

    @Test
    void testResolveParentSuccessfullyResolvesExistingParentWithoutRange() throws Exception {
        final Parent parent = new Parent();

                () -> newModelResolver().resolveModel(session, parent, new AtomicReference<>()),
                "Expected 'ModelResolverException' not thrown.");
        assertEquals("The requested version range '[1,)' does not specify an upper bound", e.getMessage());
    }

    @Test
    void testResolveParentSuccessfullyResolvesExistingParentWithoutRange() throws Exception {
        final Parent parent = Parent.newBuilder()

    @Test
    void testFileSource() {
        NullPointerException e = assertThrows(
                NullPointerException.class,
                () -> new FileSource((File) null),
                "Should fail, since you must specify a file");
        assertEquals("file cannot be null", e.getMessage());
    }

    @Test
    void testGetInputStream() throws Exception {
        File txtFile = new File("target/test-classes/source.txt");

        classGenerator,
        new DefaultServiceRegistry(),
        [] as Set,
        new TestCrossBuildInMemoryCacheFactory())

    def "can specify a set of services to inject"() {
        def services = Mock(ServiceLookup)
        _ * services.get(String) >> "value"

        when:
        def value = scheme.withServices(services).instantiator().newInstance(WithServices)

		} else {
			numVolumes++
			allErrs = append(allErrs, validateHostPathVolumeSource(source.HostPath, fldPath.Child("hostPath"))...)
		}
	}
	if source.GitRepo != nil {
		if numVolumes > 0 {
			allErrs = append(allErrs, field.Forbidden(fldPath.Child("gitRepo"), "may not specify more than 1 volume type"))
		} else {
			numVolumes++