continue
		}
		meta := partsMetadata[i]

		if meta.Deleted || meta.IsRemote() {
			continue
		}

		// Always check data, if we got it.
		if (len(meta.Data) > 0 || meta.Size == 0) && len(meta.Parts) > 0 {
			checksumInfo := meta.Erasure.GetChecksumInfo(meta.Parts[0].Number)
			verifyErr := bitrotVerify(bytes.NewReader(meta.Data),
				int64(len(meta.Data)),
				meta.Erasure.ShardFileSize(meta.Size),

<idea-plugin xmlns:xi="http://www.w3.org/2001/XInclude">
  <xi:include href="/META-INF/analysis-api/analysis-api-impl-base.xml"/>
  <xi:include href="/META-INF/analysis-api/low-level-api-fir.xml"/>
  <xi:include href="/META-INF/analysis-api/symbol-light-classes.xml"/>

  <xi:include href="/META-INF/extensions/compiler.xml"/>

  <extensions defaultExtensionNs="com.intellij">
    <projectService

        def classFile = file("build/classes/java/main/Thing.class")
        classFile.isFile()
        def jarFile = file("build/libs/somelib.jar")
        new ZipTestFixture(jarFile).hasDescendants("META-INF/MANIFEST.MF", "Thing.class", "answer.txt", "META-INF/some.Service")

        when:
        configurationCacheRun "build"

        then:
        assertStateLoaded()

				exit = true
			}
			metaMu.Lock()
			meta := *mc.meta
			meta, err = o.updateMetacacheListing(meta, rpc)
			if err == nil && time.Since(meta.lastHandout) > metacacheMaxClientWait {
				cancel()
				exit = true
				meta.status = scanStateError
				meta.error = fmt.Sprintf("listing canceled since time since last handout was %v ago", time.Since(meta.lastHandout).Round(time.Second))

		t.Fatalf("Failed to read xl meta data %v", reducedErr)
	}

	// Test 1: Test that all disks are returned without any failures with
	// unmodified meta data
	partsMetadata, errs := readAllFileInfo(ctx, erasureDisks, "", bucket, object, "", false, true)
	if err != nil {
		t.Fatalf("Failed to read xl meta data %v", err)
	}

	vmSupport := true
	if vmP := cfg.Meta.Bool(vmSupportMetaKey); vmP != nil {
		vmSupport = *vmP
	}

	return &Cluster{
		filename:  kubeconfigPath,
		CLIClient: client,
		vmSupport: vmSupport,
		Topology:  topology,
	}, nil
}

func validConfig(cfg cluster.Config) (cluster.Config, error) {
	// only include kube-specific validation here
	if cfg.Meta.String(kubeconfigMetaKey) == "" {

}

var filterTestConfigs = []config.Config{
	{
		Meta: config.Meta{Name: "wasm-network-authz", Namespace: "istio-system", GroupVersionKind: gvk.WasmPlugin},
		Spec: &extensions.WasmPlugin{
			Phase: extensions.PluginPhase_AUTHZ,
			Type:  extensions.PluginType_NETWORK,
		},
	},
	{
		Meta: config.Meta{Name: "wasm-network-authn", Namespace: "istio-system", GroupVersionKind: gvk.WasmPlugin},

            return packageName.startsWith("org.gradle.")
        }
        if (name.equals("META-INF/groovy/org.codehaus.groovy.runtime.ExtensionModule")) {
            return true
        }
        if (name.equals("META-INF/services/org.codehaus.groovy.transform.ASTTransformation")) {
            return true
        }
        if (name.matches(Regex("META-INF/.*\\.kotlin_module"))) {
            return true
        }
        return false

	ProxyKubectlOnly   bool       `yaml:"proxyKubectlOnly,omitempty"`
	PrimaryClusterName string     `yaml:"primaryClusterName,omitempty"`
	ConfigClusterName  string     `yaml:"configClusterName,omitempty"`
	Meta               config.Map `yaml:"meta,omitempty"`

            if (currentMetaAnnotations != null) {
                val classId = annotation.classId ?: continue
                if (classId in currentMetaAnnotations) {
                    appendLine("<recursive meta-annotation ${classId}>".indented(indent + 4))
                    continue
                }

                val metaAnnotations = with(analysisSession) { getClassOrObjectSymbolByClassId(classId)?.annotations }