| // Copyright (c) 2023, the R8 project authors. Please see the AUTHORS file |
| // for details. All rights reserved. Use of this source code is governed by a |
| // BSD-style license that can be found in the LICENSE file. |
| |
| import DependenciesPlugin.Companion.computeRoot |
| import java.io.File |
| import java.nio.file.Paths |
| import java.security.MessageDigest |
| import java.util.UUID |
| import kotlin.reflect.full.declaredMemberProperties |
| import org.gradle.api.Plugin |
| import org.gradle.api.Project |
| import org.gradle.api.artifacts.Dependency |
| import org.gradle.api.artifacts.dsl.DependencyHandler |
| import org.gradle.api.attributes.Attribute |
| import org.gradle.api.file.ConfigurableFileCollection |
| import org.gradle.api.file.Directory |
| import org.gradle.api.file.FileCollection |
| import org.gradle.api.file.RegularFile |
| import org.gradle.api.provider.Provider |
| import org.gradle.api.tasks.Input |
| import org.gradle.api.tasks.InputFiles |
| import org.gradle.api.tasks.PathSensitive |
| import org.gradle.api.tasks.PathSensitivity |
| import org.gradle.api.tasks.testing.Test |
| import org.gradle.jvm.toolchain.JavaInstallationMetadata |
| import org.gradle.jvm.toolchain.JavaLanguageVersion |
| import org.gradle.jvm.toolchain.JavaLauncher |
| import org.gradle.jvm.toolchain.internal.DefaultJavaLanguageVersion |
| import org.gradle.nativeplatform.platform.OperatingSystem |
| import org.gradle.nativeplatform.platform.internal.DefaultNativePlatform |
| import org.gradle.process.CommandLineArgumentProvider |
| |
| public val TEST_DEP_PROP: Attribute<String> = |
| Attribute.of("com.android.tools.r8.testdep.prop", String::class.java) |
| |
| public fun DependencyHandler.runtimeOnlyData(dependencyNotation: Any): Dependency? { |
| return add("runtimeOnlyDataScope", dependencyNotation) |
| } |
| |
| public fun DependencyHandler.runtimeOnlyDataScope(dependencyNotation: Any): Dependency? { |
| return add("runtimeOnlyDataScope", dependencyNotation) |
| } |
| |
| public class TestDepsCommandLineArgumentProvider( |
| @get:InputFiles @get:PathSensitive(PathSensitivity.NONE) public val files: FileCollection, |
| @get:Input public val arguments: Provider<List<String>>, |
| ) : CommandLineArgumentProvider { |
| override fun asArguments(): Iterable<String> { |
| return arguments.get() |
| } |
| } |
| |
| public class DependenciesPlugin : Plugin<Project> { |
| |
| override fun apply(target: Project) { |
| // Setup all test tasks to listen after system properties passed in by test.py. |
| val testTask = target.tasks.findByName("test") as Test? |
| testTask?.configure(isR8Lib = false, r8Jar = null, r8LibPartitionMapFile = null) |
| |
| // runtimeOnlyData is similar to runtimeOnly where -DTest_DEP_<x> is set to point to the |
| // location. |
| // com.android.tools.r8.TestDeps handles the runtime reading of these properties. |
| val runtimeOnlyDataScope = target.configurations.dependencyScope("runtimeOnlyDataScope") |
| target.configurations.consumable("runtimeOnlyDataElements") { |
| extendsFrom(runtimeOnlyDataScope.get()) |
| } |
| val runtimeOnlyDataConfig = |
| target.configurations.resolvable("runtimeOnlyDataConfig") { |
| extendsFrom(runtimeOnlyDataScope.get()) |
| } |
| |
| val testDepsArguments: Provider<List<String>> = |
| runtimeOnlyDataConfig.flatMap { config -> |
| config.incoming.artifacts.resolvedArtifacts.map { artifacts -> |
| artifacts |
| .mapNotNull { artifact -> |
| val prop = artifact.variant.attributes.getAttribute(TEST_DEP_PROP) |
| if (prop != null) { |
| "-DTEST_DEP_${prop}=${artifact.file.absolutePath}" |
| } else { |
| null |
| } |
| } |
| .distinct() |
| } |
| } |
| val testDepsFiles = target.files(runtimeOnlyDataConfig) |
| |
| target.tasks.withType(Test::class.java).configureEach { |
| outputs.doNotCacheIf("Test runs should not and cannot not be cached") { true } |
| jvmArgumentProviders.add( |
| TestDepsCommandLineArgumentProvider(files = testDepsFiles, arguments = testDepsArguments) |
| ) |
| } |
| } |
| |
| public companion object { |
| public fun computeRoot(file: File): File { |
| // The root folder name is setup dependent. |
| // It is instead identified by being a folder with a child folder called 'd8_r8'. |
| var current: File? = file |
| while (current != null) { |
| if (current.resolve("d8_r8").isDirectory) { |
| return current |
| } else { |
| current = current.getParentFile() |
| } |
| } |
| throw RuntimeException("Could not find root dir from $file") |
| } |
| } |
| } |
| |
| public enum class Jdk(public val folder: String, public val version: Int) { |
| // Only include LTS and latest non-LTS GA. |
| JDK_8("jdk8", 8), |
| JDK_9("openjdk-9.0.4", 9), // JDK-9 not LTS, but still used. |
| JDK_11("jdk-11", 11), |
| JDK_17("jdk-17", 17), |
| JDK_21("jdk-21", 21), |
| JDK_25("jdk-25", 25), |
| JDK_27("jdk-27", 27); |
| |
| public fun isJdk8(): Boolean { |
| return this == JDK_8 |
| } |
| |
| public fun getThirdPartyDependency(): ThirdPartyDependency { |
| val os: OperatingSystem = DefaultNativePlatform.getCurrentOperatingSystem() |
| val subFolder: String |
| if (os.isLinux) { |
| subFolder = if (isJdk8()) "linux-x86" else "linux" |
| } else if (os.isMacOsX) { |
| subFolder = if (isJdk8()) "darwin-x86" else "osx" |
| } else { |
| assert(os.isWindows) |
| if (isJdk8()) { |
| throw RuntimeException("No Jdk8 on Windows") |
| } |
| subFolder = "windows" |
| } |
| return ThirdPartyDependency( |
| name, |
| Paths.get("third_party", "openjdk", folder, subFolder).toFile(), |
| ) |
| } |
| } |
| |
| public fun Test.configure(isR8Lib: Boolean, r8Jar: File?, r8LibPartitionMapFile: File? = null) { |
| project.plugins.apply("org.gradle.test-retry") |
| TestConfigurationHelper.setupTestTask(this, isR8Lib, r8Jar, r8LibPartitionMapFile) |
| } |
| |
| public fun Project.getRoot(): File { |
| return computeRoot(this.projectDir) |
| } |
| |
| // See https://datatracker.ietf.org/doc/html/rfc4122#section-4.3 for the algorithm. |
| public fun uuid5(namespace: UUID, name: String): UUID { |
| val md = MessageDigest.getInstance("SHA-1") |
| md.update(uuidToBytes(namespace)) |
| md.update(name.encodeToByteArray()) |
| val sha1Bytes = md.digest() |
| // Set version 5 (upper 4 bits of octet 6). |
| sha1Bytes[6] = (sha1Bytes[6].toInt() and 0x0f).toByte() |
| sha1Bytes[6] = (sha1Bytes[6].toInt() or 0x50).toByte() |
| // Set two upper bits of octet 8 to 10. |
| sha1Bytes[8] = (sha1Bytes[8].toInt() and 0x3f).toByte() |
| sha1Bytes[8] = (sha1Bytes[8].toInt() or 0x80).toByte() |
| return uuidFromBytes(sha1Bytes) |
| } |
| |
| private fun uuidFromBytes(data: ByteArray): UUID { |
| assert(data.size >= 16) |
| return UUID(toNetworkOrder(data, 0), toNetworkOrder(data, 8)) |
| } |
| |
| private fun uuidToBytes(uuid: UUID): ByteArray { |
| val result = ByteArray(16) |
| fromNetworkByteOrder(uuid.mostSignificantBits, result, 0) |
| fromNetworkByteOrder(uuid.leastSignificantBits, result, 8) |
| return result |
| } |
| |
| private fun toNetworkOrder(data: ByteArray, dataIndex: Int): Long { |
| var result: Long = 0 |
| for (i in 0..7) result = result shl 8 or (data[dataIndex + i].toInt() and 0xff).toLong() |
| return result |
| } |
| |
| private fun fromNetworkByteOrder(value: Long, dest: ByteArray, destIndex: Int) { |
| for (i in 0..7) dest[i + destIndex] = (value shr (7 - i) * 8 and 0xffL).toByte() |
| } |
| |
| public fun Project.resolve( |
| thirdPartyDependency: ThirdPartyDependency, |
| vararg paths: String, |
| ): ConfigurableFileCollection { |
| return files(project.getRoot().resolve(thirdPartyDependency.path).resolveAll(*paths)) |
| } |
| |
| public fun File.resolveAll(vararg xs: String): File { |
| var that = this |
| for (x in xs) { |
| that = that.resolve(x) |
| } |
| return that |
| } |
| |
| public fun Project.getJavaHome(jdk: Jdk): File { |
| val os: OperatingSystem = DefaultNativePlatform.getCurrentOperatingSystem() |
| var osFolder = "linux" |
| if (os.isWindows) { |
| osFolder = "windows" |
| } |
| if (os.isMacOsX) { |
| osFolder = "osx/Contents/Home" |
| } |
| return getRoot().resolveAll("third_party", "openjdk", jdk.folder, osFolder) |
| } |
| |
| public fun Project.getCompilerPath(jdk: Jdk): String { |
| val os: OperatingSystem = DefaultNativePlatform.getCurrentOperatingSystem() |
| val binary = if (os.isWindows) "javac.exe" else "javac" |
| return getJavaHome(jdk).resolveAll("bin", binary).toString() |
| } |
| |
| private fun Project.getJavaPath(jdk: Jdk): String { |
| val os: OperatingSystem = DefaultNativePlatform.getCurrentOperatingSystem() |
| val binary = if (os.isWindows) "java.exe" else "java" |
| return getJavaHome(jdk).resolveAll("bin", binary).toString() |
| } |
| |
| public fun Project.getJavaLauncher(jdk: Jdk): JavaLauncher { |
| val installationPath = project.layout.projectDirectory.dir(getJavaHome(jdk).toString()) |
| val executablePath = project.layout.projectDirectory.file(getJavaPath(jdk)) |
| return object : JavaLauncher { |
| override fun getMetadata(): JavaInstallationMetadata { |
| return object : JavaInstallationMetadata { |
| override fun getLanguageVersion(): JavaLanguageVersion { |
| return DefaultJavaLanguageVersion.of(jdk.version) |
| } |
| |
| override fun getJavaRuntimeVersion(): String { |
| return jdk.name |
| } |
| |
| override fun getJvmVersion(): String { |
| return jdk.name |
| } |
| |
| override fun getVendor(): String { |
| return "vendor" |
| } |
| |
| override fun getInstallationPath(): Directory { |
| return installationPath |
| } |
| |
| override fun isCurrentJvm(): Boolean { |
| return false |
| } |
| } |
| } |
| |
| override fun getExecutablePath(): RegularFile { |
| return executablePath |
| } |
| } |
| } |
| |
| public object JvmCompatibility { |
| public const val release: Int = 11 |
| } |
| |
| public object ThirdPartyDeps { |
| public val aapt2: ThirdPartyDependency = |
| ThirdPartyDependency("aapt2", Paths.get("third_party", "aapt2").toFile()) |
| public val agsa: ThirdPartyDependency = |
| ThirdPartyDependency( |
| "agsa", |
| Paths.get("third_party", "closedsource-apps", "agsa", "20250412-v16.14.47").toFile(), |
| testOnly = true, |
| type = DependencyType.X20, |
| ) |
| public val androidJars: List<ThirdPartyDependency> = getThirdPartyAndroidJars() |
| public val androidVMs: List<ThirdPartyDependency> = getThirdPartyAndroidVms() |
| public val dex2Oats: List<ThirdPartyDependency> = getThirdPartyDex2Oats() |
| public val apiDatabase: ThirdPartyDependency = |
| ThirdPartyDependency( |
| "apiDatabase", |
| Paths.get("third_party", "api_database", "api_database").toFile(), |
| ) |
| public val artTests: ThirdPartyDependency = |
| ThirdPartyDependency("art-tests", Paths.get("tests", "2017-10-04", "art").toFile()) |
| public val artTestsLegacy: ThirdPartyDependency = |
| ThirdPartyDependency("art-tests-legacy", Paths.get("tests", "2016-12-19", "art").toFile()) |
| public val bundletool: ThirdPartyDependency = |
| ThirdPartyDependency( |
| "bundletool", |
| Paths.get("third_party", "bundletool", "bundletool-1.11.0").toFile(), |
| ) |
| public val clank: ThirdPartyDependency = |
| ThirdPartyDependency( |
| "clank", |
| Paths.get("third_party", "chrome", "clank_google3_prebuilt").toFile(), |
| testOnly = true, |
| type = DependencyType.X20, |
| ) |
| public val chrome: ThirdPartyDependency = |
| ThirdPartyDependency( |
| "chrome", |
| Paths.get("third_party", "chrome", "chrome_200430").toFile(), |
| testOnly = true, |
| type = DependencyType.X20, |
| ) |
| public val chromeBenchmark: ThirdPartyDependency = |
| ThirdPartyDependency( |
| "chrome-benchmark", |
| Paths.get("third_party", "opensource-apps", "chrome").toFile(), |
| ) |
| public val chromeHeadless: ThirdPartyDependency = getThirdPartyChromeHeadless() |
| public val compilerApi: ThirdPartyDependency = |
| ThirdPartyDependency( |
| "compiler-api", |
| Paths.get("third_party", "binary_compatibility_tests", "compiler_api_tests").toFile(), |
| ) |
| public val composeExamplesChangedBitwiseValuePropagation: ThirdPartyDependency = |
| ThirdPartyDependency( |
| "compose-examples-changed-bitwise-value-propagation", |
| Paths.get( |
| "third_party", |
| "opensource-apps", |
| "compose-examples", |
| "changed-bitwise-value-propagation", |
| ) |
| .toFile(), |
| ) |
| public val composeSamplesCrane: ThirdPartyDependency = |
| ThirdPartyDependency( |
| "compose-samples-crane", |
| Paths.get("third_party", "opensource-apps", "android", "compose-samples", "crane").toFile(), |
| ) |
| public val composeSamplesJetCaster: ThirdPartyDependency = |
| ThirdPartyDependency( |
| "compose-samples-jetcaster", |
| Paths.get("third_party", "opensource-apps", "android", "compose-samples", "jetcaster") |
| .toFile(), |
| ) |
| public val composeSamplesJetChat: ThirdPartyDependency = |
| ThirdPartyDependency( |
| "compose-samples-jetchat", |
| Paths.get("third_party", "opensource-apps", "android", "compose-samples", "jetchat").toFile(), |
| ) |
| public val composeSamplesJetLagged: ThirdPartyDependency = |
| ThirdPartyDependency( |
| "compose-samples-jetlagged", |
| Paths.get("third_party", "opensource-apps", "android", "compose-samples", "jetlagged") |
| .toFile(), |
| ) |
| public val composeSamplesJetNews: ThirdPartyDependency = |
| ThirdPartyDependency( |
| "compose-samples-jetnews", |
| Paths.get("third_party", "opensource-apps", "android", "compose-samples", "jetnews").toFile(), |
| ) |
| public val composeSamplesJetSnack: ThirdPartyDependency = |
| ThirdPartyDependency( |
| "compose-samples-jetsnack", |
| Paths.get("third_party", "opensource-apps", "android", "compose-samples", "jetsnack").toFile(), |
| ) |
| public val composeSamplesOwl: ThirdPartyDependency = |
| ThirdPartyDependency( |
| "compose-samples-owl", |
| Paths.get("third_party", "opensource-apps", "android", "compose-samples", "owl").toFile(), |
| ) |
| public val composeSamplesReply: ThirdPartyDependency = |
| ThirdPartyDependency( |
| "compose-samples-reply", |
| Paths.get("third_party", "opensource-apps", "android", "compose-samples", "reply").toFile(), |
| ) |
| public val coreLambdaStubs: ThirdPartyDependency = |
| ThirdPartyDependency("coreLambdaStubs", Paths.get("third_party", "core-lambda-stubs").toFile()) |
| public val desugarLibraryConversions: ThirdPartyDependency = |
| ThirdPartyDependency( |
| "customConversion", |
| Paths.get("third_party", "openjdk", "custom_conversion").toFile(), |
| ) |
| public val dagger: ThirdPartyDependency = |
| ThirdPartyDependency("dagger", Paths.get("third_party", "dagger", "2.41").toFile()) |
| public val dartSdk: ThirdPartyDependency = |
| ThirdPartyDependency("dart-sdk", Paths.get("third_party", "dart-sdk").toFile()) |
| public val examples: ThirdPartyDependency = |
| ThirdPartyDependency("examples", Paths.get("third_party", "examples").toFile()) |
| public val examplesAndroidN: ThirdPartyDependency = |
| ThirdPartyDependency("examplesAndroidN", Paths.get("third_party", "examplesAndroidN").toFile()) |
| public val examplesAndroidO: ThirdPartyDependency = |
| ThirdPartyDependency("examplesAndroidO", Paths.get("third_party", "examplesAndroidO").toFile()) |
| public val examplesAndroidOGenerated: ThirdPartyDependency = |
| ThirdPartyDependency( |
| "examplesAndroidOGenerated", |
| Paths.get("third_party", "examplesAndroidOGenerated").toFile(), |
| ) |
| public val examplesAndroidOLegacy: ThirdPartyDependency = |
| ThirdPartyDependency( |
| "examplesAndroidOLegacy", |
| Paths.get("third_party", "examplesAndroidOLegacy").toFile(), |
| ) |
| public val examplesAndroidP: ThirdPartyDependency = |
| ThirdPartyDependency("examplesAndroidP", Paths.get("third_party", "examplesAndroidP").toFile()) |
| public val examplesAndroidPGenerated: ThirdPartyDependency = |
| ThirdPartyDependency( |
| "examplesAndroidPGenerated", |
| Paths.get("third_party", "examplesAndroidPGenerated").toFile(), |
| ) |
| public val desugarJdkLibs: ThirdPartyDependency = |
| ThirdPartyDependency( |
| "desugar-jdk-libs", |
| Paths.get("third_party", "openjdk", "desugar_jdk_libs").toFile(), |
| ) |
| public val desugarJdkLibsLegacy: ThirdPartyDependency = |
| ThirdPartyDependency( |
| "desugar-jdk-libs-legacy", |
| Paths.get("third_party", "openjdk", "desugar_jdk_libs_legacy").toFile(), |
| ) |
| public val desugarLibraryReleases: List<ThirdPartyDependency> = |
| getThirdPartyDesugarLibraryReleases() |
| // TODO(b/289363570): This could probably be removed. |
| public val framework: ThirdPartyDependency = |
| ThirdPartyDependency( |
| "framework", |
| Paths.get("third_party", "framework").toFile(), |
| testOnly = true, |
| type = DependencyType.X20, |
| ) |
| public val googleJavaFormat: ThirdPartyDependency = |
| ThirdPartyDependency( |
| "google-java-format-1.24", |
| Paths.get("third_party", "google", "google-java-format", "1.24.0").toFile(), |
| ) |
| public val googleKotlinFormat: ThirdPartyDependency = |
| ThirdPartyDependency( |
| "google-kotlin-format-0.54", |
| Paths.get("third_party", "google", "google-kotlin-format", "0.54").toFile(), |
| ) |
| public val googleYapf_20231013: ThirdPartyDependency = |
| ThirdPartyDependency( |
| "google-yapf-20231013", |
| Paths.get("third_party", "google", "yapf", "20231013").toFile(), |
| ) |
| public val gson: ThirdPartyDependency = |
| ThirdPartyDependency("gson", Paths.get("third_party", "gson", "gson-2.10.1").toFile()) |
| public val guavaJre: ThirdPartyDependency = |
| ThirdPartyDependency( |
| "guava-jre", |
| Paths.get("third_party", "guava", "guava-32.1.2-jre").toFile(), |
| ) |
| public val desugarJdkLibs11: ThirdPartyDependency = |
| ThirdPartyDependency( |
| "desugar-jdk-libs-11", |
| Paths.get("third_party", "openjdk", "desugar_jdk_libs_11").toFile(), |
| ) |
| public val gmscoreVersions: List<ThirdPartyDependency> = getGmsCoreVersions() |
| public val internalIssues: List<ThirdPartyDependency> = getInternalIssues() |
| public val jacoco: ThirdPartyDependency = |
| ThirdPartyDependency("jacoco", Paths.get("third_party", "jacoco", "0.8.6").toFile()) |
| public val jasmin: ThirdPartyDependency = |
| ThirdPartyDependency("jasmin", Paths.get("third_party", "jasmin").toFile()) |
| public val jsr223: ThirdPartyDependency = |
| ThirdPartyDependency("jsr223", Paths.get("third_party", "jsr223-api-1.0").toFile()) |
| public val java8Runtime: ThirdPartyDependency = |
| ThirdPartyDependency( |
| "openjdk-rt-1.8", |
| Paths.get("third_party", "openjdk", "openjdk-rt-1.8").toFile(), |
| ) |
| public val jdks: List<ThirdPartyDependency> = getJdks() |
| public val jdk11Test: ThirdPartyDependency = |
| ThirdPartyDependency("jdk-11-test", Paths.get("third_party", "openjdk", "jdk-11-test").toFile()) |
| public val jdk21Float16Test: ThirdPartyDependency = |
| ThirdPartyDependency( |
| "float16-test", |
| Paths.get("third_party", "openjdk", "float16-test").toFile(), |
| ) |
| public val junit: ThirdPartyDependency = |
| ThirdPartyDependency("junit", Paths.get("third_party", "junit").toFile()) |
| public val jdwpTests: ThirdPartyDependency = |
| ThirdPartyDependency("jdwp-tests", Paths.get("third_party", "jdwp-tests").toFile()) |
| public val kotlinCompilers: List<ThirdPartyDependency> = getThirdPartyKotlinCompilers() |
| public val kotlinR8TestResources: ThirdPartyDependency = |
| ThirdPartyDependency( |
| "kotlinR8TestResources", |
| Paths.get("third_party", "kotlinR8TestResources").toFile(), |
| ) |
| public val kotlinxCoroutines: ThirdPartyDependency = |
| ThirdPartyDependency( |
| "kotlinx-coroutines-1.3.6", |
| Paths.get("third_party", "kotlinx-coroutines-1.3.6").toFile(), |
| ) |
| public val multidex: ThirdPartyDependency = |
| ThirdPartyDependency("multidex", Paths.get("third_party", "multidex").toFile()) |
| public val nest: ThirdPartyDependency = |
| ThirdPartyDependency( |
| "nest", |
| Paths.get("third_party", "nest", "nest_20180926_7c6cfb").toFile(), |
| testOnly = true, |
| type = DependencyType.X20, |
| ) |
| public val node: ThirdPartyDependency = |
| ThirdPartyDependency("node", Paths.get("third_party", "node", "24.16.0", "linux").toFile()) |
| public val nowinandroid: ThirdPartyDependency = |
| ThirdPartyDependency( |
| "nowinandroid", |
| Paths.get("third_party", "opensource-apps", "android", "nowinandroid").toFile(), |
| ) |
| public val prettier: ThirdPartyDependency = |
| ThirdPartyDependency("prettier", Paths.get("third_party", "prettier", "3.8.3").toFile()) |
| public val processKeepRulesBinaryCompatibility: ThirdPartyDependency = |
| ThirdPartyDependency( |
| "processkeeprules-binary-compatibility", |
| Paths.get("third_party", "processkeeprules", "binary_compatibility").toFile(), |
| ) |
| public val proguards: List<ThirdPartyDependency> = getThirdPartyProguards() |
| public val proguardsettings: ThirdPartyDependency = |
| ThirdPartyDependency( |
| "proguardsettings", |
| Paths.get("third_party", "proguardsettings").toFile(), |
| testOnly = true, |
| type = DependencyType.X20, |
| ) |
| public val protoc: ThirdPartyDependency = |
| ThirdPartyDependency("protoc", Paths.get("third_party", "protoc").toFile()) |
| public val protoRuntimeEdition2023: ThirdPartyDependency = |
| ThirdPartyDependency( |
| "protoRuntimeEdition2023", |
| Paths.get("third_party", "proto", "runtime", "edition2023").toFile(), |
| testOnly = true, |
| type = DependencyType.X20, |
| ) |
| public val protoRuntimeLegacy: ThirdPartyDependency = |
| ThirdPartyDependency( |
| "protoRuntimeLegacy", |
| Paths.get("third_party", "proto", "runtime", "legacy").toFile(), |
| testOnly = true, |
| type = DependencyType.X20, |
| ) |
| public val protoTestEdition2023: ThirdPartyDependency = |
| ThirdPartyDependency( |
| "protoTestEdition2023", |
| Paths.get("third_party", "proto", "test", "edition2023").toFile(), |
| testOnly = true, |
| type = DependencyType.X20, |
| ) |
| public val protoTestProto2: ThirdPartyDependency = |
| ThirdPartyDependency( |
| "protoTestProto2", |
| Paths.get("third_party", "proto", "test", "proto2").toFile(), |
| testOnly = true, |
| type = DependencyType.X20, |
| ) |
| public val protoTestProto3: ThirdPartyDependency = |
| ThirdPartyDependency( |
| "protoTestProto3", |
| Paths.get("third_party", "proto", "test", "proto3").toFile(), |
| testOnly = true, |
| type = DependencyType.X20, |
| ) |
| public val r8: ThirdPartyDependency = |
| ThirdPartyDependency("r8", Paths.get("third_party", "r8").toFile()) |
| public val r8Mappings: ThirdPartyDependency = |
| ThirdPartyDependency("r8-mappings", Paths.get("third_party", "r8mappings").toFile()) |
| public val r8v2_0_74: ThirdPartyDependency = |
| ThirdPartyDependency("r8-v2-0-74", Paths.get("third_party", "r8-releases", "2.0.74").toFile()) |
| public val r8v3_2_54: ThirdPartyDependency = |
| ThirdPartyDependency("r8-v3-2-54", Paths.get("third_party", "r8-releases", "3.2.54").toFile()) |
| public val r8v8_0_46: ThirdPartyDependency = |
| ThirdPartyDependency("r8-v8-0-46", Paths.get("third_party", "r8-releases", "8.0.46").toFile()) |
| public val retraceBenchmark: ThirdPartyDependency = |
| ThirdPartyDependency( |
| "retrace-benchmark", |
| Paths.get("third_party", "retrace_benchmark").toFile(), |
| ) |
| public val retraceBinaryCompatibility: ThirdPartyDependency = |
| ThirdPartyDependency( |
| "retrace-binary-compatibility", |
| Paths.get("third_party", "retrace", "binary_compatibility").toFile(), |
| ) |
| public val retracePartitionFormats: ThirdPartyDependency = |
| ThirdPartyDependency( |
| "retrace-partition-formats", |
| Paths.get("third_party", "retrace", "partition_formats").toFile(), |
| ) |
| public val retraceInternal: ThirdPartyDependency = |
| ThirdPartyDependency( |
| "retrace-internal", |
| Paths.get("third_party", "retrace_internal").toFile(), |
| testOnly = true, |
| type = DependencyType.X20, |
| ) |
| public val rhino: ThirdPartyDependency = |
| ThirdPartyDependency("rhino", Paths.get("third_party", "rhino-1.7.10").toFile()) |
| public val rhinoAndroid: ThirdPartyDependency = |
| ThirdPartyDependency("rhino-android", Paths.get("third_party", "rhino-android-1.1.1").toFile()) |
| public val smali: ThirdPartyDependency = |
| ThirdPartyDependency("smali", Paths.get("third_party", "smali").toFile()) |
| public val systemUI: ThirdPartyDependency = |
| ThirdPartyDependency( |
| "systemUI", |
| Paths.get("third_party", "closedsource-apps", "systemui").toFile(), |
| testOnly = true, |
| type = DependencyType.X20, |
| ) |
| public val tivi: ThirdPartyDependency = |
| ThirdPartyDependency("tivi", Paths.get("third_party", "opensource-apps", "tivi").toFile()) |
| public val youtube1719: ThirdPartyDependency = |
| ThirdPartyDependency( |
| "youtube-17.19", |
| Paths.get("third_party", "youtube", "youtube.android_17.19").toFile(), |
| testOnly = true, |
| type = DependencyType.X20, |
| ) |
| } |
| |
| private fun getThirdPartyAndroidJars(): List<ThirdPartyDependency> { |
| return listOf( |
| "libcore_latest", |
| "lib-main", |
| "lib-v14", |
| "lib-v15", |
| "lib-v19", |
| "lib-v21", |
| "lib-v22", |
| "lib-v23", |
| "lib-v24", |
| "lib-v25", |
| "lib-v26", |
| "lib-v27", |
| "lib-v28", |
| "lib-v29", |
| "lib-v30", |
| "lib-v31", |
| "lib-v32", |
| "lib-v33", |
| "lib-v34", |
| "lib-v35", |
| "lib-v36", |
| "lib-v36.1", |
| "lib-v37", |
| ) |
| .map(::getThirdPartyAndroidJar) |
| } |
| |
| private fun getThirdPartyAndroidJar(version: String): ThirdPartyDependency { |
| return ThirdPartyDependency(version, Paths.get("third_party", "android_jar", version).toFile()) |
| } |
| |
| private fun getThirdPartyDex2Oats(): List<ThirdPartyDependency> { |
| return listOf("head", "36.0", "35.14", "33.10").map(::getThirdPartyDex2Oat) |
| } |
| |
| private fun getThirdPartyDex2Oat(version: String): ThirdPartyDependency { |
| return ThirdPartyDependency(version, Paths.get("third_party", "dex2oat", version).toFile()) |
| } |
| |
| private fun getThirdPartyAndroidVms(): List<ThirdPartyDependency> { |
| return listOf( |
| listOf("host", "art-master"), |
| listOf("host", "art-17.0.0-beta4"), |
| listOf("host", "art-16.0.0"), |
| listOf("host", "art-15.0.0-beta2"), |
| listOf("host", "art-14.0.0-beta3"), |
| listOf("host", "art-13.0.0"), |
| listOf("host", "art-12.0.0-beta4"), |
| listOf("art-10.0.0"), |
| listOf("art-5.1.1"), |
| listOf("art-6.0.1"), |
| listOf("art-7.0.0"), |
| listOf("art-8.1.0"), |
| listOf("art-9.0.0"), |
| listOf("art"), |
| listOf("dalvik-4.0.4"), |
| listOf("dalvik"), |
| ) |
| .map(::getThirdPartyAndroidVm) |
| } |
| |
| private fun getThirdPartyAndroidVm(version: List<String>): ThirdPartyDependency { |
| return ThirdPartyDependency( |
| version.last(), |
| Paths.get("tools", "linux", *version.slice(0..version.size - 2).toTypedArray(), version.last()) |
| .toFile(), |
| ) |
| } |
| |
| private fun getThirdPartyChromeHeadless(): ThirdPartyDependency { |
| val os: OperatingSystem = DefaultNativePlatform.getCurrentOperatingSystem() |
| val subFolder = |
| when { |
| os.isLinux -> "linux" |
| os.isMacOsX -> "mac" |
| else -> { |
| assert(os.isWindows) |
| "windows" |
| } |
| } |
| return ThirdPartyDependency( |
| "chrome_headless", |
| Paths.get("third_party", "chrome_headless", subFolder).toFile(), |
| testOnly = true, |
| ) |
| } |
| |
| private fun getJdks(): List<ThirdPartyDependency> { |
| val os: OperatingSystem = DefaultNativePlatform.getCurrentOperatingSystem() |
| if (os.isLinux || os.isMacOsX) { |
| return Jdk.values().map { it.getThirdPartyDependency() } |
| } else { |
| return Jdk.values().filter { !it.isJdk8() }.map { it.getThirdPartyDependency() } |
| } |
| } |
| |
| private fun getThirdPartyProguards(): List<ThirdPartyDependency> { |
| return listOf("proguard-7.0.0", "proguard-7.7.0").map { |
| ThirdPartyDependency(it, Paths.get("third_party", "proguard", it).toFile()) |
| } |
| } |
| |
| private fun getThirdPartyKotlinCompilers(): List<ThirdPartyDependency> { |
| return listOf( |
| "kotlin-compiler-1.3.72", |
| "kotlin-compiler-1.4.20", |
| "kotlin-compiler-1.5.0", |
| "kotlin-compiler-1.6.0", |
| "kotlin-compiler-1.7.0", |
| "kotlin-compiler-1.8.0", |
| "kotlin-compiler-1.9.21", |
| "kotlin-compiler-2.0.20", |
| "kotlin-compiler-2.1.10", |
| "kotlin-compiler-2.2.0", |
| "kotlin-compiler-2.3.10", |
| "kotlin-compiler-2.4.20", |
| "kotlin-compiler-dev", |
| ) |
| .map { ThirdPartyDependency(it, Paths.get("third_party", "kotlin", it).toFile()) } |
| } |
| |
| private fun getThirdPartyDesugarLibraryReleases(): List<ThirdPartyDependency> { |
| return listOf("1.0.9", "1.0.10", "1.1.0", "1.1.1", "1.1.5", "2.0.3").map { |
| ThirdPartyDependency( |
| "desugar-library-release-$it", |
| Paths.get("third_party", "openjdk", "desugar_jdk_libs_releases", it).toFile(), |
| ) |
| } |
| } |
| |
| private fun getInternalIssues(): List<ThirdPartyDependency> { |
| return listOf("issue-127524985").map { |
| ThirdPartyDependency( |
| "internal-$it", |
| Paths.get("third_party", "internal", it).toFile(), |
| testOnly = true, |
| type = DependencyType.X20, |
| ) |
| } |
| } |
| |
| private fun getGmsCoreVersions(): List<ThirdPartyDependency> { |
| return listOf("gmscore_v10", "latest").map { |
| ThirdPartyDependency( |
| "gmscore-version-$it", |
| Paths.get("third_party", "gmscore", it).toFile(), |
| testOnly = true, |
| type = DependencyType.X20, |
| ) |
| } |
| } |
| |
| private fun allDependencies(): List<ThirdPartyDependency> { |
| val allDeps = mutableListOf<ThirdPartyDependency>() |
| ThirdPartyDeps::class.declaredMemberProperties.forEach { |
| val value = it.get(ThirdPartyDeps) |
| if (value is List<*>) { |
| value.forEach { dep -> |
| if (dep is ThirdPartyDependency) { |
| allDeps.add(dep) |
| } else { |
| throw RuntimeException("Cannot handle non ThirdPartyDependency dependency.") |
| } |
| } |
| } else { |
| allDeps.add(value as ThirdPartyDependency) |
| } |
| } |
| return allDeps |
| } |
| |
| public fun allPublicDependencies(): List<ThirdPartyDependency> { |
| return allDependencies().filter { x -> !x.testOnly && x.type == DependencyType.GOOGLE_STORAGE } |
| } |
| |
| public fun allPublicTestDependencies(): List<ThirdPartyDependency> { |
| return allDependencies().filter { x -> x.testOnly && x.type == DependencyType.GOOGLE_STORAGE } |
| } |
| |
| public fun allInternalDependencies(): List<ThirdPartyDependency> { |
| return allDependencies().filter { x -> !x.testOnly && x.type == DependencyType.X20 } |
| } |
| |
| public fun allInternalTestDependencies(): List<ThirdPartyDependency> { |
| return allDependencies().filter { x -> x.testOnly && x.type == DependencyType.X20 } |
| } |
| |
| public fun extractClassesPaths(prefix: String, vararg paths: String): String { |
| val result: MutableList<String> = ArrayList() |
| paths.forEach { it -> |
| result.addAll( |
| it.split(File.pathSeparator).filter { it.contains("${prefix}build${File.separator}classes") } |
| ) |
| } |
| return result.joinToString(File.pathSeparator) |
| } |
