import java.lang.annotation.Target

/**
 * This annotation is a marker and guarantees all integration tests are tagged.
 *
 * When we use JUnit Platform `includeTags('SomeTag')`, all spock tests are excluded:
 * https://github.com/spockframework/spock/issues/1288 . As a workaround,
 * we tag all non-spock integration tests and use `includeTags(none() | SomeTag)` to make
 * sure spock engine tests are executed.
 */

            scriptLanguage
        )
        spec.setup(this)

        def excludedByBuildScriptFileName = "excluded-by-build-script.txt"
        def excludedByBuildScriptFile = file("input/${excludedByBuildScriptFileName}")
        def excludedByBuildScriptFileCopy = file("build/output/${excludedByBuildScriptFileName}")
        excludedByBuildScriptFile.text = "input"

	// AuditAnnotationActionExclude indicates that the audit annotation should be excluded
	// because the valueExpression evaluated to null, or because FailurePolicy is Ignore
	// and the expression failed with a parse error, type check error, or runtime error.
	AuditAnnotationActionExclude PolicyAuditAnnotationAction = "exclude"
)

type PolicyAuditAnnotation struct {
	Key     string
	Value   string
	Elapsed time.Duration

	webhookPluginInitializer := webhookinit.NewPluginInitializer(webhookAuthResolverWrapper, serviceResolver)

	kubePluginInitializer := NewPluginInitializer(
		quotainstall.NewQuotaConfigurationForAdmission(),
		exclusion.Excluded(),
	)

	return []admission.PluginInitializer{webhookPluginInitializer, kubePluginInitializer}, nil

        verifier.verify(logger, calls(1)).debug("  Excluded: {}", "group1:artifact2:ext:classifier1:null");
        verifier.verify(logger, calls(1))
                .debug("Populating class realm {}", "project>modelGroup1:modelArtifact1:modelVersion1");
        verifier.verify(logger, calls(1)).debug("  Included: {}", "group1:artifact1:ext:classifier1:null");
    }

    @Test

 *
 * <p>If not all classes on the classpath should be covered, {@link #ignoreClasses} can be used to
 * exclude certain classes. As a special case, classes with an underscore in the name (like {@code
 * AutoValue_Foo}) can be excluded using <code>ignoreClasses({@link #UNDERSCORE_IN_NAME})</code>.
 *
 * <p>{@link #setDefault} allows subclasses to specify default values for types.
 *

        result.assertTasksExecuted(":a:one", ":a:two")
        fixture.assertProjectsConfigured(":", ":a")
    }

    @ToBeFixedForIsolatedProjects(because = "allprojects")
    def "does not configure all projects when excluded task path is not qualified and is exact match for task in default project"() {
        createDirs("a", "a/child", "b", "b/child", "c")
        settingsFile << "include 'a', 'a:child', 'b', 'b:child', 'c'"

    }

    /**
     * List of class names that should be excluded from analysis. Names can use wildcard (* and ?). Defaults to an empty list.
     */
    @Nullable
    @Optional
    @Input
    public List<String> getExcludes() {
        return excludes;
    }

    public void setExcludes(@Nullable List<String> excludes) {
        this.excludes = excludes;
    }

    /**

#### `excludes` value

This value, nested in elements of the `dependencies` node, must contain an array with zero or more elements. Each element has the same meaning as `exclude` in the Gradle DSL.

Each element must be an object with the of the following values:

- `group`: The group to exclude from transitive dependencies, or wildcard '*' if any group may be excluded.

        List<ExcludeMetadata> excludeRules = []
        if (args.exclude) {
            ComponentGraphResolveState excluded = args.exclude
            excludeRules << new DefaultExclude(moduleIdentifierFactory.module(excluded.metadata.moduleVersionId.group, excluded.metadata.moduleVersionId.name))
        }
        def dependencyMetaData = new LocalComponentDependencyMetadata(componentSelector,