switch (x.(type)) { // should become: switch x.(type) {
	case int:
	}

	switch x.(type) { // should remain the same
	case []int:
	}

	// Parenthesized (x.(type)) in type switches containing cases
	// with unnamed (literal) types were never permitted by gofmt;
	// thus there won't be any code in the wild using this style if
	// the code was gofmt-ed.
	/*
	switch (x.(type)) {
	case []int:
	}
	*/

            // entries by putting a list as value into the 'entryAttributes' Map.
            // For exmaple: entryAttributes['add-exports'] = ['java.base/jdk.internal.access=ALL-UNNAMED', 'java.base/jdk.internal.loader=ALL-UNNAMED']
            if (value instanceof Iterable) {
                Cast.<Iterable<?>>uncheckedCast(value).forEach(valueElement ->
                    attributesNode.appendNode("attribute", ImmutableMap.of(

        task.actions[5].displayName == "I have a name"

    }

    def "unconventionally added actions that are not describable are unnamed"() {
        when:
        task.actions.add(Mock(Action))

        then:
        task.actions[0].displayName == "Execute unnamed action"
    }

    def "can detect tasks with custom actions added"() {
        expect:
        !task.hasCustomActions

        when:

 */
package org.gradle.api.internal.model

import org.gradle.integtests.fixtures.AbstractIntegrationSpec

class CustomPluginObjectFactoryIntegrationTest extends AbstractIntegrationSpec {

    def "plugin can create unnamed instances of class using injected factory"() {
        buildFile """

            @groovy.transform.Canonical
            class CustomExtension {
                NestedExtension nested

            }
            @Override
            Iterable<String> asArguments() {
                return test.javaVersion.isCompatibleWith(JavaVersion.VERSION_1_9)
                    ? ["--add-opens=java.base/java.lang=ALL-UNNAMED"]
                    : []
            }
        }
        tasks.withType(Test).configureEach {
            jvmArgumentProviders.add(new AddOpensArgProvider(it))
        }
        """
    }

	Sfm
	m()
}](p P) {
	_ = p.f
	p.f = 0
	p.m()
}

var _ = f2[Sfm]

// special case: core type is a named pointer type

type PSfm *Sfm

func f3[P interface{ PSfm }](p P) {
	_ = p.f
	p.f = 0
}

var _ = f3[PSfm]

// special case: core type is an unnamed pointer type

func f4[P interface{ *Sfm }](p P) {
	_ = p.f
	p.f = 0
}

var _ = f4[*Sfm]

type A int
type B int

     * should use the {@link #getPath()} method for a unique identifier for the project.
     * If the root project is unnamed and is located on a file system root it will have a randomly-generated name
     * </p>
     *
     * @return The name of this project. Never return null.
     * @since 8.8
     */
    String getName();

    /**

     */
    String CLASSPATH_JAR = "classpath-jar";

    /**
     * Artifact type name for a JAR file to unconditionally place on the module-path.
     * If the JAR is not modular, then it is loaded by Java as an unnamed module.
     * This type is new in Maven 4.
     */
    String MODULAR_JAR = "modular-jar";

    /**
     * Artifact type name for a JAR file that can be placed either on the annotation processor class-path

		},
		{
			name:       "forbid create of unnamed eviction for unknown pod",
			podsGetter: noExistingPods,
			attributes: admission.NewAttributesRecord(unnamedEviction, nil, evictionKind, coremypod.Namespace, coremypod.Name, podResource, "eviction", admission.Create, &metav1.CreateOptions{}, false, mynode),
			err:        "not found",
		},

		// Eviction for unnamed pod
		{

    override val allKtModules: List<KtModule>,
) : KtStaticProjectStructureProvider() {
    private val ktNotUnderContentRootModuleWithoutPsiFile by lazy {
        KtNotUnderContentRootModuleImpl(
            name = "unnamed-outside-content-root",
            moduleDescription = "Standalone-not-under-content-root-module-without-psi-file",
            project = project,
        )
    }