def root = builder.toRootComponent('conf')

        when:
        def sameConf = builder.toRootComponent('conf')

        then:
        sameConf.rootComponent.is(root.rootComponent)
        sameConf.rootComponent.metadata.is(root.rootComponent.metadata)

        when:
        def differentConf = builder.toRootComponent('conf-2')

        then:

        return question;
    }

    @Override
    public String getPrompt() {
        StringBuilder builder = new StringBuilder();
        builder.append(question);
        builder.append(" [");
        builder.append(StringUtils.join(YesNoQuestionPromptEvent.YES_NO_CHOICES, ", "));
        builder.append("] ");
        return builder.toString();
    }

    @Override
    public PromptResult<Boolean> convert(String text) {

    @Override
    protected void addProperties(ImmutableSortedMap.Builder<String, Object> builder) {
        if (url != null) {
            builder.put(Property.URL.name(), url);
        }
        builder.put(Property.METADATA_SOURCES.name(), metadataSources);
        builder.put(Property.AUTHENTICATED.name(), authenticated);
        builder.put(Property.AUTHENTICATION_SCHEMES.name(), authenticationSchemes);
    }

        builder.startVisitComponent(moduleVersion.resultId, moduleVersion.selectionReason, "repo")
        builder.visitComponentDetails(moduleVersion.componentId, moduleVersion.moduleVersion)
        builder.visitSelectedVariant(moduleVersion.resultId, Stub(ResolvedVariantResult))
        builder.visitComponentVariants([])
        builder.endVisitComponent()
    }

        where:
        severity << [Severity.WARNING, Severity.ERROR]
    }

    def "unbound builder result with modified #changedAspect is not equal"() {
        def problem = createTestProblem()


        when:
        def builder = problem.toBuilder()
        changeClosure.curry(builder).run()
        def newProblem = builder.build()

        then:

        newProblem != problem

        where:

    def builder = Mock(InternalCancellableConnection)

    def modelProducer

    def setup() {
        _ * versionDetails.getVersion() >> "1.0"
        modelProducer = new CancellableModelBuilderBackedModelProducer(adapter, versionDetails, mapping, builder, transformer)
    }

    def "builder not triggered for unsupported Models"() {
        setup:

            return (AdditionalDataBuilder<T>) DefaultTypeValidationData.builder();
        } else if (DeprecationDataSpec.class.isAssignableFrom(type)) {
            return (AdditionalDataBuilder<T>) DefaultDeprecationData.builder();
        } else if (GeneralDataSpec.class.isAssignableFrom(type)) {
            return (AdditionalDataBuilder<T>) DefaultGeneralData.builder();
        } else {

): EvaluationAndConversionSchema {
    val builder = DefaultEvaluationAndConversionSchemaBuilder().apply(schemaComponents)
    val analysisSchema = analysisSchema(topLevelReceiverType, builder)
    return DefaultEvaluationAndConversionSchema(
        analysisSchema,
        analysisStatementFilter,
        operationGenerationId,
        runtimePropertyResolvers = builder.runtimePropertyResolvers,

    override val contextReceivers: List<KaContextReceiver> by cached { firSymbol.createContextReceivers(builder) }

    override val valueParameters: List<KaValueParameterSymbol>
        get() = withValidityAssertion {
            firSymbol.createKtValueParameters(builder)
        }

    override val hasStableParameterNames: Boolean

fun Decoder.readDefaultClassPath(): ClassPath {
    val size = readSmallInt()
    val builder = DefaultClassPath.builderWithExactSize(size)
    for (i in 0 until size) {
        builder.add(readFile())
    }
    return builder.build()
}


internal
fun Decoder.readTransformedClassPath(): ClassPath {
    val size = readSmallInt()
    val builder = TransformedClassPath.builderWithExactSize(size)
    for (i in 0 until size) {