def fileCollectionFactory = TestFiles.fileCollectionFactory(testDirectory)
        def copySpec = new DestinationRootCopySpec(resolver, new DefaultCopySpec(fileCollectionFactory, TestUtil.objectFactory(), TestUtil.instantiatorFactory().decorateLenient(), TestFiles.patternSetFactory))
        copySpec.with {
            into "out"
            from "a", {
                from "b/b1", {
                    it.eachFile {

*/

package metrics

import (
	"context"
	"strings"
	"testing"

	"k8s.io/apiserver/pkg/authorization/authorizer"
	"k8s.io/component-base/metrics/legacyregistry"
	"k8s.io/component-base/metrics/testutil"
)

func TestRecordAuthorizationDecisionsTotal(t *testing.T) {
	prefix := `

	// A single fetch should aggregate and increment regeneration counter.
	if err := testutil.GatherAndCompare(legacyregistry.DefaultGatherer, formatExpectedMetrics(1), interests...); err != nil {
		t.Fatal(err)
	}
	_, _, _ = fetchPath(manager, "application/json", discoveryPath, "")
	// Subsequent fetches should not reaggregate discovery.

    }

    static PreferJavaRuntimeVariant defaultSchema() {
        return new PreferJavaRuntimeVariant(TestUtil.objectInstantiator())
    }

    static PlatformSupport platformSupport() {
        return new PlatformSupport(TestUtil.objectInstantiator())
    }

    static ComponentSelectionDescriptorFactory componentSelectionDescriptorFactory() {
        return new TestComponentDescriptorFactory()
    }

import org.gradle.api.plugins.jvm.PlatformDependencyModifiers
import org.gradle.util.AttributeTestUtil
import org.gradle.util.TestUtil
import spock.lang.Specification

class PlatformDependencyModifiersTest extends Specification {
    def "copies given external dependency to select platform"() {
        def modifier = TestUtil.objectFactory().newInstance(PlatformDependencyModifiers.PlatformDependencyModifier)

        spec.destinationDir = new File("destinationDir")
        spec.compileOptions = TestUtil.newInstance(CompileOptions.class, TestUtil.objectFactory())
        ServiceLookup services = new DefaultServiceRegistry().add(ObjectFactory, TestUtil.objectFactory())
        spec.groovyCompileOptions = new MinimalGroovyCompileOptions(TestUtil.instantiatorFactory().decorateLenient(services).newInstance(GroovyCompileOptions.class))
    }

    @Before public void setUp() {
        testTask = TestUtil.create(temporaryFolder).task(TestTask.class);
        conventionAware = new ConventionAwareHelper(testTask, new DefaultConvention(TestUtil.instantiatorFactory().decorateLenient()));
    }

    @Test
    public void canMapPropertiesUsingClosure() {
        conventionAware.map("list1", TestUtil.toClosure("{ ['a'] }"));

import org.gradle.plugins.ide.idea.IdeaPlugin
import org.gradle.test.fixtures.AbstractProjectBuilderSpec
import org.gradle.util.TestUtil

class IdeaModuleTest extends AbstractProjectBuilderSpec {
    private ProjectInternal moduleProject

    def setup() {
        moduleProject = TestUtil.createChildProject(project, "child", new File("."))
    }

    def "language level is null for non java projects"() {
        given:

    @Before
    public void setUp() {
        projectRegistry = new DefaultProjectRegistry<ProjectInternal>();
        rootMock = TestUtil.create(temporaryFolder).rootProject();
        childMock = TestUtil.createChildProject(rootMock, CHILD_NAME);
        childChildMock = TestUtil.createChildProject(childMock, CHILD_CHILD_NAME);
        projectRegistry.addProject(rootMock);
        projectRegistry.addProject(childMock);

import org.gradle.util.TestUtil
import org.junit.Rule
import spock.lang.Specification

class DefaultGroovyJavaJointCompileSpecFactoryTest extends Specification {

    @Rule
    TestNameTestDirectoryProvider tmpDir = new TestNameTestDirectoryProvider(getClass())

    def "produces correct spec type" () {
        CompileOptions options = TestUtil.newInstance(CompileOptions.class, TestUtil.objectFactory())