!leftIsArray && !rightIsArray -> left == right
        else -> false
    }
}


internal fun List<ConstantValue<*>>.expandArrayAnnotationValue(
    containingArrayType: KotlinType,
    analysisContext: Fe10AnalysisContext,
): List<KaAnnotationValue> = flatMap { constantValue: ConstantValue<*> ->
    val constantType = constantValue.getType(analysisContext.resolveSession.moduleDescriptor)

    val ephemeral_keys_supported: Boolean,
    val rating: String,
    val tls_version: String,
    val able_to_detect_n_minus_one_splitting: Boolean,
    val insecure_cipher_suites: Map<String, List<String>>,
    val given_cipher_suites: List<String>?,
  )

  @Test
  @Disabled
  fun testSSLFeatures() {
    assumeNetwork()

    val request = Request.Builder().url("https://www.howsmyssl.com/a/check").build()

        mapAnnotationParameters(annotations[index]),
        builder
    )
}

private inline fun List<FirAnnotation>.mapIndexedToAnnotationApplication(
    useSiteSession: FirSession,
    classId: ClassId,
    transformer: (index: Int, annotation: FirAnnotation) -> KaAnnotation?,
): List<KaAnnotation> = mapIndexedNotNull { index, annotation ->
    if (annotation.toAnnotationClassId(useSiteSession) != classId) {

    }

    assertThat(buffer.readByteString()).isEqualTo("300a1505536d6974680101ff".decodeHex())
  }

  @Test fun `sequence of`() {
    val bytes = "3009020107020108020109".decodeHex()
    val sequenceOf = listOf(7L, 8L, 9L)
    val adapter = Adapters.INTEGER_AS_LONG.asSequenceOf()
    assertThat(adapter.fromDer(bytes)).isEqualTo(sequenceOf)
    assertThat(adapter.toDer(sequenceOf)).isEqualTo(bytes)
  }

    // Find all references here https://developer.android.com/studio/archive
    // Update verification-metadata.xml
    const val performanceTestAndroidStudioVersion = "2023.3.1.18"
    val performanceTestAndroidStudioJvmArgs = listOf("-Xms256m", "-Xmx4096m")
}


@Suppress("unused")
class PerformanceTestPlugin : Plugin<Project> {
    override fun apply(project: Project): Unit = project.run {

            return symbolImplementationPackageNames.none { qualifiedName.startsWith("$it.") }
        }

        val valueClass = value::class
        val allClasses = listOf(valueClass) + valueClass.allSuperclasses

        val matchingClasses = allClasses.filter { it.isFrontendIndependent() }
        val matchingClassSet = matchingClasses.toSet()

        assertThat(
            "Only the generated Gradle Plugin wrapper is not internal",
            generatedAccessors.filterNot { it.visibility == Visibilities.Internal },
            equalTo(
                listOf(
                    Declaration(
                        "",
                        "JavaProjectPlugin",
                        Visibilities.Public
                    )
                )
            )

        val binDir = newFolder("bin")
        compileToDirectory(
            binDir,
            KotlinCompilerOptions(),
            "test",
            listOf(sourceFile),
            loggerFor<KotlinApiClassExtractorTest>(),
            emptyList()
        )

        return ClassFixture(scriptBody, binDir.toPath().resolve(scriptClass).toFile().readBytes())
    }
}

            @Suppress("unchecked_cast")
            val freeCompilerArgs: List<String> = getProperty("freeCompilerArgs") as List<String>
            setProperty("freeCompilerArgs", freeCompilerArgs + scriptTemplatesArgs + resolverEnvironment.mappedToScriptResolverEnvironmentArg.get())
        }
    }
}


private
val scriptTemplatesArgs
    get() = listOf("-script-templates", scriptTemplates)


private

        compileKotlin()
        val generated = file("build/generated-sources/kotlin-dsl-plugins/kotlin").walkTopDown().filter { it.isFile }.map { it.name }
        assertThat(generated.toList(), equalTo(listOf("CorrectPlugin.kt")))
    }

    @Issue("https://github.com/gradle/gradle/issues/16154")
    @Test
    fun `file annotations and package statement in precompiled script plugin handled correctly`() {