Pon `List` como el tipo.

Como la lista es un tipo que permite tener un "sub-tipo" pones el sub-tipo en corchetes `[]`:

```Python hl_lines="4"
{!../../../docs_src/python_types/tutorial006.py!}
```

Esto significa: la variable `items` es una `list` y cada uno de los ítems en esta lista es un `str`.

 */
val QUICK_CROSS_VERSION_BUCKETS = listOf(
    listOf("0.0", "3.0"), // 0.0 <= version < 3.0
    listOf("3.0", "4.0"), // 3.0 <= version < 4.0
    listOf("4.0", "5.0"), // 4.0 <= version < 5.0
    listOf("5.0", "6.0"), // 5.0 <=version < 6.0
    listOf("6.0", "7.0"), // 6.0 <=version < 7.0
    listOf("7.0", "8.0"), // 7.0 <=version < 8.0
    listOf("8.0", "9.0"), // 8.0 <=version < 9.0
    listOf("9.0", "10.0"), // 9.0 <=version < 10.0

            Stage(
                StageName.PULL_REQUEST_FEEDBACK,
                performanceTests = listOf(PerformanceTestCoverage(1, PerformanceTestType.per_commit, Os.LINUX))
            ),
            PerformanceTestCoverage(1, PerformanceTestType.per_commit, Os.LINUX),
            "Description",
            "performance",
            listOf("largeTestProject", "smallTestProject"),
            2,
            extraParameters = "extraParameters"

        // Kotlin/JS
        // https://youtrack.jetbrains.com/issue/KT-50881
        task.name in listOf("generateExternals") -> true

        // JMH plugin
        task.name in listOf("jmh", "jmhJar", "jmhReport") -> true

        // Gradle Doctor plugin
        task.name in listOf(
            "graph", "graphMain",
            "projectGraphReport",
            "ripples",
            "aggregateAdvice",

                    KaClassKind.CLASS -> listOf(KtTokens.CLASS_KEYWORD)
                    KaClassKind.ENUM_CLASS -> listOf(KtTokens.ENUM_KEYWORD, KtTokens.CLASS_KEYWORD)
                    KaClassKind.ANNOTATION_CLASS -> listOf(KtTokens.ANNOTATION_KEYWORD, KtTokens.CLASS_KEYWORD)
                    KaClassKind.OBJECT -> listOf(KtTokens.OBJECT_KEYWORD)
                    KaClassKind.COMPANION_OBJECT -> listOf(KtTokens.COMPANION_KEYWORD, KtTokens.OBJECT_KEYWORD)

    }

    @Test
    fun `recognizes relative paths against rootDirectory`() {
        val instance = createFromPaths(listOf("test/123"))
        assertTrue(instance.isFileSystemCheckIgnoredFor(rootDir.resolve("test/123")))
    }

    @Test
    fun `recognizes multiple paths`() {
        val instance = createFromPaths(listOf("path/one", "path/two"))
        assertTrue(instance.isFileSystemCheckIgnoredFor(File("path/one")))

    val buildScanTags: List<String> = emptyList(),
    val stages: List<Stage> = listOf(
        Stage(
            StageName.QUICK_FEEDBACK_LINUX_ONLY,
            specificBuilds = listOf(
                SpecificBuild.CompileAll, SpecificBuild.SanityCheck
            ),
            functionalTests = listOf(

        fromString()      | "ProcessGroovyMethods.execute(command, listOf(\"FOOBAR=foobar\"), file(\"$pwd\"))"  | pwd               | "foobar"
        fromStringArray() | "ProcessGroovyMethods.execute(command, listOf(\"FOOBAR=foobar\"), file(\"$pwd\"))"  | pwd               | "foobar"
        fromStringList()  | "ProcessGroovyMethods.execute(command, listOf(\"FOOBAR=foobar\"), file(\"$pwd\"))"  | pwd               | "foobar"

            importsToAdd = listOf(
                "org.jetbrains.kotlin.psi.KtExpression",
                "org.jetbrains.kotlin.psi"
            )
        ),
        KtSourceElement::class to HLFunctionCallConversion(
            "({0} as? KtPsiSourceElement)?.psi",
            PsiElement::class.createType(nullable = true),
            importsToAdd = listOf(
                "org.jetbrains.kotlin.psi",

    def "empty lists are the same"() {
        expect:
        PersistentList.of() == PersistentList.of()
    }

    def "lists with elements #elements are the same"() {
        expect:
        listOf(elements) == listOf(elements)

        where:
        elements << [["a"], ["a", "b"]]
    }

    def "has a nice toString method"() {
        expect:
        PersistentList.of().toString() == "Nil"