return tpar.is(func(t *term) bool { return t != nil && isBasic(t.typ, info) })
	}
	return isBasic(t, info)
}

// hasName reports whether t has a name. This includes
// predeclared types, defined types, and type parameters.
// hasName may be called with types that are not fully set up.
func hasName(t Type) bool {
	switch Unalias(t).(type) {
	case *Basic, *Named, *TypeParam:
		return true
	}
	return false
}

import static com.tngtech.archunit.core.domain.properties.HasModifiers.Predicates.modifier;
import static com.tngtech.archunit.core.domain.properties.HasName.Functions.GET_NAME;
import static com.tngtech.archunit.core.domain.properties.HasName.Predicates.nameMatching;
import static com.tngtech.archunit.core.domain.properties.HasType.Functions.GET_RAW_TYPE;
import static java.util.stream.Collectors.toSet;

		t.Run(tt.name, func(t *testing.T) {
			hasNames, err := HasNames(tt.args)
			if !reflect.DeepEqual(tt.expectedError, err) {
				t.Errorf("expected HasName to error:\n%s\tgot:\n%s", tt.expectedError, err)
			}
			if hasNames != tt.expectedHasName {
				t.Errorf("expected HasName to return %v for %s", tt.expectedHasName, tt.args)
			}
		})
	}
}

func TestUnstructured(t *testing.T) {
	// create test dirs

	// escape types. noescape here help avoid unnecessary escape
	// of v.
	return (*Type)(NoEscape(unsafe.Pointer(eface.Type)))
}

func (t *Type) Kind() Kind { return t.Kind_ & KindMask }

func (t *Type) HasName() bool {
	return t.TFlag&TFlagNamed != 0
}

// Pointers reports whether t contains pointers.
func (t *Type) Pointers() bool { return t.PtrBytes != 0 }

	// x's type V is identical to T?
	if T == V {
		return true
	}

	// Otherwise at least one of T and V must not be defined
	// and they must have the same kind.
	if T.HasName() && V.HasName() || T.Kind() != V.Kind() {
		return false
	}

	if T.Kind() == abi.Chan && specialChannelAssignability(T, V) {
		return true
	}

	// x's type T and V must have identical underlying types.

class FlakyTestQuarantine(model: CIBuildModel, stage: Stage, os: Os, arch: Arch = Arch.AMD64) : BaseGradleBuildType(stage = stage, init = {
    id("${model.projectId}_FlakyQuarantine_${os.asName()}_${arch.asName()}")
    name = "Flaky Test Quarantine - ${os.asName()} ${arch.asName()}"
    description = "Run all flaky tests skipped multiple times"

    applyDefaultSettings(os = os, arch = arch, buildJvm = BuildToolBuildJvm, timeout = 180)

import jetbrains.buildServer.configs.kotlin.ParameterDisplay

class RerunFlakyTest(os: Os, arch: Arch = Arch.AMD64) : BuildType({
    val id = "Util_RerunFlakyTest${os.asName()}${arch.asName()}"
    name = "Rerun Flaky Test - ${os.asName()} ${arch.asName()}"
    description = "Allows you to rerun a selected flaky test 10 times"
    id(id)
    val testJvmVendorParameter = "testJavaVendor"
    val testJvmVersionParameter = "testJavaVersion"

    override
    fun asConfigurationId(model: CIBuildModel) =
        "${model.projectId}_${oldUuid ?: "PerformanceTest$uuid"}"

    override
    fun asName(): String =
        "${type.displayName} - ${os.asName()}${if (withoutDependencies) " without dependencies" else ""}"

    override
    fun channel() =

abstract class AdHocPerformanceScenario(os: Os, arch: Arch = Arch.AMD64) : BuildType({
    val id = "Util_Performance_AdHocPerformanceScenario${os.asName()}${arch.asName()}"
    name = "AdHoc Performance Scenario - ${os.asName()} ${arch.asName()}"
    id(id)

    applyPerformanceTestSettings(os = os, arch = arch, timeout = 420)
    artifactRules = individualPerformanceTestArtifactRules

    params {

    return "${model.projectId}_DocsTest_${os.asName()}"
}

class DocsTestProject(
    model: CIBuildModel,
    stage: Stage,
    val os: Os,
    testJava: JvmCategory,
    testTypes: List<DocsTestType>
) : Project({
    id(asDocsTestId(model, os))
    name = "Docs Test - ${testJava.version.name.toCapitalized()} ${os.asName()}"
}) {
    val docsTests: List<BaseGradleBuildType>

    init {