}

	if orig, _ := gtyp.(*Alias); orig != nil {
		return check.instance(ix.Pos(), orig, targs, nil, check.context())
	}

	orig := asNamed(gtyp)
	if orig == nil {
		panic(fmt.Sprintf("%v: cannot instantiate %v", ix.Pos(), gtyp))
	}

	// create the instance
	inst := asNamed(check.instance(ix.Pos(), orig, targs, nil, check.context()))

	// orig.tparams may not be set up, so we need to do expansion later.

                }
            }
        }
    }
}
"""
        // This is a directory named 'directory'
        file("src/other/directory").mkdirs()
        // This is a header named 'directory'
        file("src/main/headers/directory") << '#pragma message("including directory named header")'
        file("src/main/headers/macro.h") << '#pragma message("including macro header")'

        sourceFile << """

        0 * _
        mutable.asMap() == [
            (CATEGORY_ATTRIBUTE): named(Category, LIBRARY),
            (USAGE_ATTRIBUTE): named(Usage, JAVA_RUNTIME),
            (BUNDLING_ATTRIBUTE): named(Bundling, EXTERNAL),
            (LIBRARY_ELEMENTS_ATTRIBUTE): named(LibraryElements, LibraryElements.JAR),
            (TARGET_JVM_ENVIRONMENT_ATTRIBUTE): named(TargetJvmEnvironment, STANDARD_JVM)
        ]
    }

     *
     * @param elements the elements with possibly duplicated names
     * @return a Map containing the new name for each element that has to be renamed
     */
    public Map<T, String> deduplicate(Iterable<? extends T> elements) {
        return new StatefulDeduplicator(elements).getNewNames();
    }

    /*

func hasVarSize(t Type, seen map[*Named]bool) (varSized bool) {
	// Cycles are only possible through *Named types.
	// The seen map is used to detect cycles and track
	// the results of previously seen types.
	if named := asNamed(t); named != nil {
		if v, ok := seen[named]; ok {
			return v
		}
		if seen == nil {
			seen = make(map[*Named]bool)
		}
		seen[named] = true // possibly cyclic until proven otherwise

        and:
        container.findByName("task") != null
        container.findByName("task") == task

        and:
        container.withType(DefaultTask).named("task").isPresent()
        container.withType(DefaultTask).named("task").get() == task

        and:
        1 * taskFactory.create(_ as TaskIdentity) >> task
        1 * action.execute(_) >> { throw new RuntimeException("Failing creation rule") }

        when:
        run "compile"
        then:
        skipped ":compile"

        when:
        file("lib1.jar").renameTo(file("lib1-renamed.jar"))
        buildFile.text = buildScriptWithClasspath("lib1-renamed.jar", "lib2.jar")

        run "compile"
        then:
        skipped ":compile"
    }

    def buildScriptWithClasspath(String... dependencies) {
        """

	if err != nil {
		return errors.Wrapf(err, "failure loading certificate for %s", l.uxName)
	}
	// Validate period
	CheckCertificatePeriodValidity(l.uxName, caCert)

	// Check if cert is a CA
	if !caCert.IsCA {
		return errors.Errorf("certificate %s is not a CA", l.uxName)
	}
	return nil
}

// validateCACertAndKey tries to load a x509 certificate and private key from pkiDir,

 */
@ServiceScope({Scope.Global.class, Scope.Project.class})
public interface ObjectFactory {
    /**
     * Creates a simple immutable {@link Named} object of the given type and name.
     *
     * <p>The given type can be an interface that extends {@link Named} or an abstract class that 'implements' {@link Named}. An abstract class, if provided:</p>
     * <ul>
     *     <li>Must provide a zero-args constructor that is not private.</li>

        archive.assertContainsFile('file2.txt')
        archive.content("file1.txt") == "dir1/file1.txt"

        where:
        archiveType << ['tar', 'zip']
    }

    def "renamed file will be treated as duplicate in #archiveType"() {
        given:
        createFilesStructureForDupeTests()
        buildFile << """
                task archive(type: ${archiveType.capitalize()}) {