),
            result
        )
        assertEquals(
            listOf(ResolutionError(imports[1], ErrorReason.AmbiguousImport(DefaultFqName("a.c", "C")))),
            analysisContext.errorCollector.errors
        )
    }

    @Test
    fun `does not report errors on the same import appearing more than once`() {
        val imports = listOf(
            importOf("a", "b", "C"),
            importOf("a", "b", "C"),

plugins {
    id("org.fmiw.plantuml") version "0.1"
}

defaultTasks = listOf("generateDiagrams")

plantuml {
    options {
        outputDir = file("images")
    }
    diagrams {
        for (diagram in listOf("C4_1_Context", "C4_2_Container", "C4_3_Component")) {
            register(diagram) {
                sourceFile = file("$diagram.puml")
            }
        }
    }

                    TypedProjectSchema(
                        extensions = listOf(
                            entry<Project, ExtraPropertiesExtension>("extra")
                        ),
                        conventions = listOf(
                            entry<Project, CustomConvention>("customConvention")
                        ),
                        tasks = listOf(
                            entry<TaskContainer, Delete>("delete")

    testJava: JvmCategory,
    testTypes: List<DocsTestType>
) : Project({
    id(asDocsTestId(model, os))
    name = "Docs Test - ${testJava.version.name.toCapitalized()} ${os.asName()}"
}) {
    val docsTests: List<BaseGradleBuildType>

    init {
        docsTests = testTypes.flatMap {
            listOf(
                DocsTest(model, stage, os, testJava, 1, it, INCLUDE, listOf("org.gradle.docs.samples.Bucket1SnippetsTest=docsTest")),

            """.trimIndent()
        )

        assertEquals(listOf("foo()", "bar()", "plugins { id(\"x\") }"), result.map { it.location.sourceData.text() })
        assertTrue(result.all { it.reason == DocumentCheckFailureReason.PluginManagementBlockOrderViolated })
    }

    private
    fun EvaluationSchema.runChecks(code: String): List<DocumentCheckFailure> {

        }
    }

    private
    val reportedMembers = listOf(
        "Class" to "AddedClass"
    ) + reportedMembersFor("AddedClass") + listOf(
        "Constructor" to "AddedClass(java.lang.String)",
        "Constructor" to "AddedClass()",
        "Class" to "AddedEnum",
        "Field" to "FOO"
    ) + reportedMembersFor("AddedEnum", isEnum = true) + listOf(
        "Method" to "AddedEnum.valueOf(java.lang.String)",

        val silencer = ExperimentalCompilerWarningSilencer(listOf("SOME"))

        val message = "Hello, World!"
        val rewritten = silencer.rewrite(LogLevel.WARN, message)

        assertThat(rewritten, equalTo(message))
    }

    @Test
    fun `silences unsafe internal compiler arguments`() {
        val silencer = ExperimentalCompilerWarningSilencer(listOf("-XXLanguage:+DisableCompatibilityModeForNewInference"))

}
// end::dependency-management[]

// tag::configure-target-machines[]
library {
    targetMachines = listOf(machines.linux.x86_64,
        machines.windows.x86, machines.windows.x86_64,
        machines.macOS.x86_64)
}
// end::configure-target-machines[]

// tag::configure-linkages[]
library {
    linkage = listOf(Linkage.STATIC, Linkage.SHARED)
}

import org.gradle.internal.declarativedsl.schemaBuilder.schemaFromTypes


val schema = schemaFromTypes(
    topLevelReceiver = Abc::class,
    types = listOf(Abc::class, C::class, D::class),
    externalFunctions = listOf(::newD),
    defaultImports = listOf(DefaultFqName("com.example", "newD"))
)


object SimpleAnalysisDemo {
    @JvmStatic
    fun main(args: Array<String>) {
        printResolutionResults(

    testImplementation("junit:junit:4.13")
}

// tag::custom-source-locations[]
sourceSets {
    main {
        scala {
            setSrcDirs(listOf("src/scala"))
        }
    }
    test {
        scala {
            setSrcDirs(listOf("test/scala"))
        }
    }
}