import org.gradle.api.internal.component.ArtifactType;
import org.gradle.api.internal.tasks.DefaultTaskDependency;
import org.gradle.api.tasks.TaskDependency;
import org.gradle.internal.Factory;
import org.gradle.internal.action.InstantiatingAction;
import org.gradle.internal.component.external.model.DefaultModuleComponentArtifactIdentifier;

        }

        @Provides
        DefaultUrlArtifactRepository.Factory createDefaultUrlArtifactRepositoryFactory(FileResolver fileResolver) {
            return new DefaultUrlArtifactRepository.Factory(fileResolver);
        }

        @Provides
        BaseRepositoryFactory createBaseRepositoryFactory(

    public static Serializer<Message> create(Serializer<BuildAction> buildActionSerializer) {
        BaseSerializerFactory factory = new BaseSerializerFactory();
        Serializer<LogLevel> logLevelSerializer = factory.getSerializerFor(LogLevel.class);
        Serializer<Throwable> throwableSerializer = factory.getSerializerFor(Throwable.class);
        DefaultSerializerRegistry registry = new DefaultSerializerRegistry();

        def instance = schema.factory.create()
        instance.value = "12"
        instance.number = 12

        expect:
        def sameSchema = schema.factory.create()
        sameSchema.value == "12"
        sameSchema.number == 12

        def schema2 = extractor.extract(AbstractPropertyRules)
        def differentSchema = schema2.factory.create()
        differentSchema.value == null

    val isBlockFragment = fragmentText.any { it == '\n' }

    val project = ktFile.project
    val factory = KtPsiFactory(project, markGenerated = false)

    return when {
        isBlockFragment -> factory.createBlockCodeFragment(fragmentText, contextElement)
        else -> factory.createExpressionCodeFragment(fragmentText, contextElement)
    }
}

        }
    }

    private
    fun <T> pairOf(bean: T) = bean.let { it to it }

    private
    fun <T : Any> verifyRoundtripOf(factory: () -> T, verify: (T) -> Unit) {
        verify(javaSerializationRoundtripOf(factory()))
        verify(configurationCacheRoundtripOf(factory()))
    }

    private
    fun <T : Any> javaSerializationRoundtripOf(bean: T): T =
        javaDeserialize(javaSerialize(bean)).uncheckedCast()

        if (crawlerClientFactory != null) {
            return crawlerClientFactory;
        }
        final CrawlerClientFactory factory = creator.get();

        final Map<String, String> paramMap = getHandlerParameterMap();

        final Map<String, Object> factoryParamMap = new HashMap<>();
        factory.setInitParameterMap(factoryParamMap);

        // parameters

    }

    private static SnippetsFactory makeFactory(String summary, Function<ExternalProcessFixture, Snippets> factory) {
        return new SnippetsFactory() {
            @Override
            Snippets newSnippets(ExternalProcessFixture fixture) {
                return factory.apply(fixture)
            }

            @Override
            String getSummary() {
                return summary
            }

        getValidator() >> Mock(MutationValidator)
    }
    private DefaultRootComponentMetadataBuilder.Factory rootComponentMetadataBuilderFactory = Mock(DefaultRootComponentMetadataBuilder.Factory) {
        create(_) >> metadataBuilder
    }
    private DefaultConfigurationFactory configurationFactory = new DefaultConfigurationFactory(
        instantiator,
        resolver,

                            }
                            testMethodSuite("anotherTestFactory()") {
                                operationDisplayName "another test factory"
                                testDisplayName "another test factory"
                                test("anotherTestFactory()[1]") {
                                    operationDisplayName "foo"
                                    testDisplayName "foo"