Google Git
Sign in
r8 / r8 / 6324e892067e0e3cafab697d6961e04a60ccf4ce / . / build.gradle
blob: 9032bc4e6fc8312b4b2cb2bef13f5aa5763b3378 [file] [log] [blame]
// Copyright (c) 2016, 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 com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
import dx.DexMergerTask
import dx.DxTask
import net.ltgt.gradle.errorprone.CheckSeverity
import org.gradle.internal.os.OperatingSystem
import smali.SmaliTask
import tasks.DownloadDependency
import tasks.GetJarsFromConfiguration
import utils.Utils
import org.gradle.api.tasks.testing.logging.TestExceptionFormat
import org.gradle.api.tasks.testing.logging.TestLogEvent
import org.gradle.api.tasks.testing.TestOutputEvent
import java.nio.charset.StandardCharsets
import java.nio.file.Files
import java.nio.file.StandardOpenOption
buildscript {
repositories {
maven {
url 'https://storage.googleapis.com/r8-deps/maven_mirror/'
}
mavenCentral()
gradlePluginPortal()
jcenter()
}
dependencies {
classpath 'com.github.jengelman.gradle.plugins:shadow:5.2.0'
}
}
plugins {
id "net.ltgt.errorprone" version "0.7"
}
apply plugin: 'java'
apply plugin: 'idea'
ext {
androidSupportVersion = '25.4.0'
asmVersion = '9.0' // When updating update tools/asmifier.py and Toolhelper as well.
espressoVersion = '3.0.0'
fastutilVersion = '7.2.0'
guavaVersion = '23.0'
joptSimpleVersion = '4.6'
gsonVersion = '2.7'
junitVersion = '4.13-beta-2'
mockitoVersion = '2.10.0'
// The kotlin version is only here to specify the kotlin language level,
// all kotlin compilations are done in tests.
kotlinVersion = '1.3.72'
kotlinExtMetadataJVMVersion = '0.2.0'
smaliVersion = '2.2b4'
errorproneVersion = '2.3.2'
testngVersion = '6.10'
}
apply from: 'copyAdditionalJctfCommonFiles.gradle'
repositories {
maven {
url 'https://storage.googleapis.com/r8-deps/maven_mirror/'
}
google()
mavenCentral()
}
if (project.hasProperty('with_code_coverage')) {
apply plugin: 'jacoco'
}
// Custom source set for example tests and generated tests.
sourceSets {
test {
java {
srcDirs = [
'src/test/java',
'build/generated/test/java',
]
}
}
apiUsageSample {
java {
srcDirs = ['src/test/apiUsageSample', 'src/main/java']
include 'com/android/tools/apiusagesample/*.java'
include 'com/android/tools/r8/BaseCompilerCommandParser.java'
include 'com/android/tools/r8/D8CommandParser.java'
include 'com/android/tools/r8/R8CommandParser.java'
include 'com/android/tools/r8/utils/FlagFile.java'
}
}
cfSegments {
java {
srcDirs = ['third_party/classlib/java', 'src/cf_segments/java']
}
output.resourcesDir = 'build/classes/cfSegments'
}
libraryDesugarConversions {
java {
srcDirs = ['src/library_desugar/java']
}
output.resourcesDir = 'build/classes/library_desugar_conversions'
}
debugTestResources {
java {
srcDirs = ['src/test/debugTestResources']
}
output.resourcesDir = 'build/classes/debugTestResources'
}
debugTestResourcesJava8 {
java {
srcDirs = ['src/test/debugTestResourcesJava8']
}
output.resourcesDir = 'build/classes/debugTestResourcesJava8'
}
examples {
java {
srcDirs = ['src/test/examples']
}
output.resourcesDir = 'build/classes/examples'
}
examplesJava9 {
java {
srcDirs = ['src/test/examplesJava9']
}
}
examplesJava10 {
java {
srcDirs = ['src/test/examplesJava10']
}
}
examplesJava11 {
java {
srcDirs = ['src/test/examplesJava11']
}
}
examplesJava15 {
java {
srcDirs = ['src/test/examplesJava15']
}
}
jdk11TimeTests {
java {
srcDirs = [
'third_party/openjdk/jdk-11-test/java/time/tck',
'third_party/openjdk/jdk-11-test/java/time/test'
]
exclude '**/TestZoneTextPrinterParser.java'
}
}
examplesTestNGRunner {
java {
srcDirs = ['src/test/testngrunner']
}
}
examplesAndroidN {
java {
srcDirs = ['src/test/examplesAndroidN']
}
output.resourcesDir = 'build/classes/examplesAndroidN'
}
examplesAndroidO {
java {
srcDirs = ['src/test/examplesAndroidO']
}
output.resourcesDir = 'build/classes/examplesAndroidO'
}
examplesAndroidP {
java {
srcDirs = ['src/test/examplesAndroidP']
}
output.resourcesDir = 'build/classes/examplesAndroidP'
}
examplesProto {
java {
srcDirs = ['src/test/examplesProto']
}
compileClasspath = files("third_party/protobuf-lite/libprotobuf_lite.jar")
compileClasspath += fileTree(dir: "build/generated/test/proto", include: "*.jar")
output.resourcesDir = 'build/classes/examplesProto'
}
jctfCommon {
java {
srcDirs = [
'third_party/jctf/Harness/src',
'third_party/jctf/LibTests/src/com/google/jctf/test/categories',
'third_party/jctf/LibTests/src/com/google/jctf/test/helper',
'third_party/jctf/LibTests/src/com/google/jctf/testHelpers',
'third_party/jctf/LibTests/src/org',
'build/additionalJctfCommonFiles'
]
}
resources {
srcDirs = ['third_party/jctf/LibTests/resources']
}
}
jctfTests {
java {
srcDirs = [
'third_party/jctf/LibTests/src/com/google/jctf/test/lib',
// 'third_party/jctf/VMTests/src',
]
}
}
kotlinR8TestResources {
java {
srcDirs = ['src/test/kotlinR8TestResources']
}
output.resourcesDir = 'build/classes/kotlinR8TestResources'
}
}
// Ensure importing into IntelliJ IDEA use the same output directories as Gradle. In tests we
// use the output path for tests (ultimately through ToolHelper.getClassPathForTests()) and
// therefore these paths need to be the same. See https://youtrack.jetbrains.com/issue/IDEA-175172
// for context.
idea {
sourceSets.all { SourceSet sources ->
module {
if (sources.name == "main") {
sourceDirs += sources.java.srcDirs
outputDir sources.output.classesDirs[0]
} else {
testSourceDirs += sources.java.srcDirs
testOutputDir sources.output.classesDirs[0]
}
}
}
}
configurations {
supportLibs
}
dependencies {
implementation "net.sf.jopt-simple:jopt-simple:$joptSimpleVersion"
implementation "com.google.code.gson:gson:$gsonVersion"
// Include all of guava when compiling the code, but exclude annotations that we don't
// need from the packaging.
compileOnly("com.google.guava:guava:$guavaVersion")
implementation("com.google.guava:guava:$guavaVersion", {
exclude group: 'com.google.errorprone'
exclude group: 'com.google.code.findbugs'
exclude group: 'com.google.j2objc'
exclude group: 'org.codehaus.mojo'
})
implementation group: 'it.unimi.dsi', name: 'fastutil', version: fastutilVersion
implementation "org.jetbrains.kotlinx:kotlinx-metadata-jvm:$kotlinExtMetadataJVMVersion"
implementation group: 'org.ow2.asm', name: 'asm', version: asmVersion
implementation group: 'org.ow2.asm', name: 'asm-commons', version: asmVersion
implementation group: 'org.ow2.asm', name: 'asm-tree', version: asmVersion
implementation group: 'org.ow2.asm', name: 'asm-analysis', version: asmVersion
implementation group: 'org.ow2.asm', name: 'asm-util', version: asmVersion
jdk11TimeTestsCompile group: 'org.testng', name: 'testng', version: testngVersion
examplesTestNGRunnerCompile group: 'org.testng', name: 'testng', version: testngVersion
testCompile sourceSets.examples.output
testCompile "junit:junit:$junitVersion"
testCompile group: 'org.smali', name: 'smali', version: smaliVersion
testCompile files('third_party/jasmin/jasmin-2.4.jar')
testCompile files('third_party/jdwp-tests/apache-harmony-jdwp-tests-host.jar')
testCompile files('third_party/ddmlib/ddmlib.jar')
jctfCommonCompile "junit:junit:$junitVersion"
jctfTestsCompile "junit:junit:$junitVersion"
jctfTestsCompile sourceSets.jctfCommon.output
examplesAndroidOCompile group: 'org.ow2.asm', name: 'asm', version: asmVersion
examplesAndroidPCompile group: 'org.ow2.asm', name: 'asm', version: asmVersion
// Import Guava for @Nullable annotation
examplesCompile "com.google.guava:guava:$guavaVersion"
examplesCompile "junit:junit:$junitVersion"
examplesCompile "org.mockito:mockito-core:$mockitoVersion"
supportLibs "com.android.support:support-v4:$androidSupportVersion"
supportLibs "junit:junit:$junitVersion"
supportLibs "com.android.support.test.espresso:espresso-core:$espressoVersion"
apiUsageSampleCompile sourceSets.main.output
apiUsageSampleCompile "com.google.guava:guava:$guavaVersion"
kotlinR8TestResourcesCompileOnly "org.jetbrains.kotlin:kotlin-stdlib:$kotlinVersion"
errorprone("com.google.errorprone:error_prone_core:$errorproneVersion")
testImplementation "org.jetbrains.kotlin:kotlin-reflect:1.3.31"
}
def r8LibPath = "$buildDir/libs/r8lib.jar"
def r8LibExludeDepsPath = "$buildDir/libs/r8lib-exclude-deps.jar"
def r8DesugaredPath = "$buildDir/libs/r8desugared.jar"
def r8LibGeneratedKeepRulesPath = "$buildDir/generated/keep.txt"
def r8LibTestPath = "$buildDir/classes/r8libtest"
def java11ClassFiles = "$buildDir/classes/java/mainJava11"
def r8RetracePath = "$buildDir/libs/r8retrace.jar"
def r8RetraceExludeDepsPath = "$buildDir/libs/r8retrace-exclude-deps.jar"
def osString = OperatingSystem.current().isLinux() ? "linux" :
OperatingSystem.current().isMacOsX() ? "mac" : "windows"
def cloudDependencies = [
"tests" : [
"2017-10-04/art",
"2016-12-19/art"
],
"third_party": [
"android_cts_baseline",
"android_jar/lib-v14",
"android_jar/lib-v15",
"android_jar/lib-v19",
"android_jar/lib-v21",
"android_jar/lib-v22",
"android_jar/lib-v23",
"android_jar/lib-v24",
"android_jar/lib-v25",
"android_jar/lib-v26",
"android_jar/lib-v27",
"android_jar/lib-v28",
"android_jar/lib-v29",
"android_jar/lib-v30",
"android_jar/lib-v31",
"android_jar/api-versions",
"api-outlining/simple-app-dump",
"core-lambda-stubs",
"dart-sdk",
"ddmlib",
"gradle/gradle",
"google-java-format",
"iosched_2019",
"jacoco/0.8.2",
"jacoco/0.8.6",
"jasmin",
"jctf",
"junit",
"jdwp-tests",
"jsr223-api-1.0",
"rhino-1.7.10",
"rhino-android-1.1.1",
"kotlin/kotlin-compiler-1.3.11",
"kotlin/kotlin-compiler-1.3.41",
"kotlin/kotlin-compiler-1.3.72",
"kotlin/kotlin-compiler-1.4.20",
"kotlin/kotlin-compiler-1.5.0-M2",
"kotlinx-coroutines-1.3.6",
"openjdk/openjdk-rt-1.8",
"openjdk/desugar_jdk_libs",
"openjdk/desugar_jdk_libs_11",
"openjdk/jdk-11-test",
"proguard/proguard5.2.1",
"proguard/proguard6.0.1",
"proguard/proguard-7.0.0",
"r8",
"r8-releases/2.0.74",
"r8mappings",
"tachiyomi"
],
// All dex-vms have a fixed OS of Linux, as they are only supported on Linux, and will be run in a Docker
// container on other platforms where supported.
"tools" : [
"linux/art",
"linux/art-5.1.1",
"linux/art-6.0.1",
"linux/art-7.0.0",
"linux/art-8.1.0",
"linux/art-9.0.0",
"linux/art-10.0.0",
"linux/dalvik",
"linux/dalvik-4.0.4",
"${osString}/dx",
]
]
def cloudSystemDependencies = [
linux: [
"third_party": ["openjdk/openjdk-9.0.4/linux",
"openjdk/jdk8/linux-x86",
"openjdk/jdk-11/linux",
"openjdk/jdk-15/linux"],
],
osx: [
"third_party": ["openjdk/openjdk-9.0.4/osx",
"openjdk/jdk8/darwin-x86",
"openjdk/jdk-11/osx",
"openjdk/jdk-15/osx"],
],
windows: [
"third_party": ["openjdk/openjdk-9.0.4/windows",
"openjdk/jdk-11/windows",
"openjdk/jdk-15/windows"],
],
]
if (OperatingSystem.current().isWindows()) {
cloudSystemDependencies.windows.each { entry ->
cloudDependencies.get(entry.key).addAll(entry.value)
}
} else if (OperatingSystem.current().isLinux()) {
cloudSystemDependencies.linux.each { entry ->
cloudDependencies.get(entry.key).addAll(entry.value)
}
} else if (OperatingSystem.current().isMacOsX()) {
cloudSystemDependencies.osx.each { entry ->
cloudDependencies.get(entry.key).addAll(entry.value)
}
} else {
println "WARNING: Unsupported system: " + OperatingSystem.current()
}
def getDownloadDepsTaskName(entryKey, entryFile) {
return "download_deps_${entryKey}_${entryFile.replace('/', '_').replace('\\', '_')}"
}
cloudDependencies.each { entry ->
entry.value.each { entryFile ->
task "${getDownloadDepsTaskName(entry.key, entryFile)}"(type: DownloadDependency) {
type DownloadDependency.Type.GOOGLE_STORAGE
dependency "${entry.key}/${entryFile}"
}
}
}
def x20Dependencies = [
"third_party": [
"benchmarks/kotlin-benches",
"chrome/chrome_180917_ffbaa8",
"chrome/chrome_200430",
"chrome/monochrome_public_minimal_apks/chrome_200520",
"chrome/clank_google3_prebuilt",
"classlib",
"cf_segments",
"desugar/desugar_20180308",
"internal/issue-127524985",
"framework",
"gmail/gmail_android_170604.16",
"gmail/gmail_android_180826.15",
"gmscore/gmscore_v10",
"gmscore/latest",
"nest/nest_20180926_7c6cfb",
"proguard/proguard_internal_159423826",
"proguardsettings",
"proto",
"protobuf-lite",
"retrace_internal",
"youtube/youtube.android_15.33",
"youtube/youtube.android_16.12",
"youtube/youtube.android_16.20"
],
]
x20Dependencies.each { entry ->
entry.value.each { entryFile ->
task "${getDownloadDepsTaskName(entry.key, entryFile)}"(type: DownloadDependency) {
type DownloadDependency.Type.X20
dependency "${entry.key}/${entryFile}"
}
}
}
task downloadProguard {
cloudDependencies.each { entry ->
entry.value.each { entryFile ->
if (entryFile.contains("proguard")) {
dependsOn "${getDownloadDepsTaskName(entry.key, entryFile)}"
}
}
}
}
task downloadOpenJDKrt {
cloudDependencies.each { entry ->
entry.value.each { entryFile ->
if (entryFile.contains("openjdk-rt")) {
dependsOn "${getDownloadDepsTaskName(entry.key, entryFile)}"
}
}
}
}
task downloadDx {
cloudDependencies.each { entry ->
entry.value.each { entryFile ->
if (entryFile.endsWith("/dx")) {
dependsOn "${getDownloadDepsTaskName(entry.key, entryFile)}"
}
}
}
}
task downloadAndroidCts {
cloudDependencies.each { entry ->
entry.value.each { entryFile ->
if (entryFile.contains("android_cts_baseline")) {
dependsOn "${getDownloadDepsTaskName(entry.key, entryFile)}"
}
}
}
}
task downloadDeps {
cloudDependencies.each { entry ->
entry.value.each { entryFile ->
dependsOn "${getDownloadDepsTaskName(entry.key, entryFile)}"
}
}
if (!project.hasProperty('no_internal')) {
x20Dependencies.each { entry ->
entry.value.each { entryFile ->
dependsOn "${getDownloadDepsTaskName(entry.key, entryFile)}"
}
}
}
}
allprojects {
sourceCompatibility = JavaVersion.VERSION_1_8
targetCompatibility = JavaVersion.VERSION_1_8
}
// TODO(ricow): Remove debug prints
println("NOTE: Current operating system: " + OperatingSystem.current())
println("NOTE: Current operating system isWindows: " + OperatingSystem.current().isWindows())
// Check if running with the JDK location from tools/jdk.py.
if (OperatingSystem.current().isWindows()) {
println "NOTE: Running with JDK: " + org.gradle.internal.jvm.Jvm.current().javaHome
compileJava.options.encoding = "UTF-8"
compileTestJava.options.encoding = "UTF-8"
} else {
def javaHomeOut = new StringBuilder()
def javaHomeErr = new StringBuilder()
def javaHomeProc = './tools/jdk.py'.execute([], projectDir)
javaHomeProc.waitForProcessOutput(javaHomeOut, javaHomeErr)
def jdkHome = new File(javaHomeOut.toString().trim())
if (!jdkHome.exists()) {
println "WARNING: Failed to find the ./tools/jdk.py specified JDK: " + jdkHome
} else if (jdkHome != org.gradle.internal.jvm.Jvm.current().javaHome) {
println("WARNING: Gradle is running in a non-pinned Java"
+ ". Gradle Java Home: " + org.gradle.internal.jvm.Jvm.current().javaHome
+ ". Expected: " + jdkHome)
} else {
println("NOTE: Running with jdk from tools/jdk.py: " + jdkHome)
}
}
sourceSets.configureEach { sourceSet ->
tasks.named(sourceSet.compileJavaTaskName).configure {
// Default disable errorprone (enabled and setup below).
options.errorprone.enabled = false
options.compilerArgs << '-Xlint:unchecked'
// Run all compilation tasks in a forked subprocess.
options.fork = true
// Javac often runs out of stack space when compiling the tests.
// Increase the stack size for the javac process.
options.forkOptions.jvmArgs << "-Xss256m"
// Test compilation is sometimes hitting the default limit at 1g, increase it.
options.forkOptions.jvmArgs << "-Xmx3g"
// Set the bootclass path so compilation is consistent with 1.8 target compatibility.
options.forkOptions.jvmArgs << "-Xbootclasspath/a:third_party/openjdk/openjdk-rt-1.8/rt.jar"
}
}
def setJdkCompilationWithCompatibility(String sourceSet, String javaHome, JavaVersion compatibility, boolean enablePreview) {
tasks.named(sourceSet).get().configure {
def jdkDir = "third_party/openjdk/${javaHome}/"
options.fork = true
options.forkOptions.jvmArgs = []
if (enablePreview) {
options.compilerArgs.add('--enable-preview')
}
if (OperatingSystem.current().isLinux()) {
options.forkOptions.javaHome = file(jdkDir + 'linux')
} else if (OperatingSystem.current().isMacOsX()) {
options.forkOptions.javaHome = compatibility > JavaVersion.VERSION_1_9
? file(jdkDir + 'osx/Contents/Home')
: file(jdkDir + 'osx')
} else {
options.forkOptions.javaHome = file(jdkDir + 'windows')
}
sourceCompatibility = compatibility
targetCompatibility = compatibility
}
}
setJdkCompilationWithCompatibility(
sourceSets.examplesJava9.compileJavaTaskName,
'openjdk-9.0.4',
JavaVersion.VERSION_1_9,
false)
setJdkCompilationWithCompatibility(
sourceSets.examplesJava11.compileJavaTaskName,
'jdk-11',
JavaVersion.VERSION_11,
false)
setJdkCompilationWithCompatibility(
sourceSets.examplesJava10.compileJavaTaskName,
'jdk-11',
JavaVersion.VERSION_1_10,
false)
setJdkCompilationWithCompatibility(
sourceSets.examplesJava11.compileJavaTaskName,
'jdk-11',
JavaVersion.VERSION_11,
false)
setJdkCompilationWithCompatibility(
sourceSets.examplesTestNGRunner.compileJavaTaskName,
'jdk-11',
JavaVersion.VERSION_11,
false)
setJdkCompilationWithCompatibility(
sourceSets.jdk11TimeTests.compileJavaTaskName,
'jdk-11',
JavaVersion.VERSION_11,
false)
setJdkCompilationWithCompatibility(
sourceSets.examplesJava15.compileJavaTaskName,
'jdk-15',
JavaVersion.VERSION_15,
true)
task compileMainWithJava11 (type: JavaCompile) {
dependsOn downloadDeps
def jdkDir = 'third_party/openjdk/jdk-11/'
options.fork = true
options.forkOptions.jvmArgs = []
if (OperatingSystem.current().isLinux()) {
options.forkOptions.javaHome = file(jdkDir + 'linux')
} else if (OperatingSystem.current().isMacOsX()) {
options.forkOptions.javaHome = file(jdkDir + 'osx/Contents/Home')
} else {
options.forkOptions.javaHome = file(jdkDir + 'windows')
}
source = sourceSets.main.allSource
destinationDir = file(java11ClassFiles)
sourceCompatibility = JavaVersion.VERSION_11
targetCompatibility = JavaVersion.VERSION_11
classpath = sourceSets.main.compileClasspath
}
if (!project.hasProperty('without_error_prone') &&
// Don't enable error prone on Java 8 as the plugin setup does not support it.
!org.gradle.internal.jvm.Jvm.current().javaVersion.java8) {
compileJava {
// Enable error prone for D8/R8 sources.
options.errorprone.enabled = true
options.errorprone.disableAllChecks = true
options.errorprone.check('ClassCanBeStatic', CheckSeverity.ERROR)
options.errorprone.check('CollectionIncompatibleType', CheckSeverity.ERROR)
options.errorprone.check('OperatorPrecedence', CheckSeverity.ERROR)
options.errorprone.check('RemoveUnusedImports', CheckSeverity.ERROR)
options.errorprone.check('MissingOverride', CheckSeverity.ERROR)
options.errorprone.check('IntLongMath', CheckSeverity.ERROR)
options.errorprone.check('EqualsHashCode', CheckSeverity.ERROR)
options.errorprone.check('InconsistentOverloads', CheckSeverity.ERROR)
options.errorprone.check('ArrayHashCode', CheckSeverity.ERROR)
options.errorprone.check('EqualsIncompatibleType', CheckSeverity.ERROR)
options.errorprone.check('NonOverridingEquals', CheckSeverity.ERROR)
options.errorprone.check('FallThrough', CheckSeverity.ERROR)
options.errorprone.check('MissingCasesInEnumSwitch', CheckSeverity.ERROR)
options.errorprone.check('MissingDefault', CheckSeverity.ERROR)
options.errorprone.check('MultipleTopLevelClasses', CheckSeverity.ERROR)
options.errorprone.check('NarrowingCompoundAssignment', CheckSeverity.ERROR)
options.errorprone.check('BoxedPrimitiveConstructor', CheckSeverity.ERROR)
options.errorprone.check('LogicalAssignment', CheckSeverity.ERROR)
options.errorprone.check('FloatCast', CheckSeverity.ERROR)
options.errorprone.check('ReturnValueIgnored', CheckSeverity.ERROR)
}
}
compileJctfCommonJava {
dependsOn 'copyAdditionalJctfCommonFiles'
options.compilerArgs = ['-Xlint:none']
}
compileJctfTestsJava {
dependsOn 'jctfCommonClasses'
options.compilerArgs = ['-Xlint:none']
}
task consolidatedLicense {
def license = new File(new File(buildDir, 'generatedLicense'), 'LICENSE')
inputs.files files('LICENSE', 'LIBRARY-LICENSE') + fileTree(dir: 'library-licensing')
def runtimeClasspath = configurations.findByName("runtimeClasspath")
inputs.files { runtimeClasspath.getResolvedConfiguration().files }
outputs.files license
doLast {
def dependencies = []
runtimeClasspath.resolvedConfiguration.resolvedArtifacts.each {
def identifier = (ModuleComponentIdentifier) it.id.componentIdentifier
dependencies.add("${identifier.group}:${identifier.module}")
}
def libraryLicenses = file('LIBRARY-LICENSE').text
dependencies.each {
if (!libraryLicenses.contains("- artifact: $it")) {
throw new GradleException("No license for $it in LIBRARY_LICENSE")
}
}
license.getParentFile().mkdirs()
license.createNewFile()
license.text = "This file lists all licenses for code distributed.\n"
license.text += "All non-library code has the following 3-Clause BSD license.\n"
license.text += "\n"
license.text += "\n"
license.text += file('LICENSE').text
license.text += "\n"
license.text += "\n"
license.text += "Summary of distributed libraries:\n"
license.text += "\n"
license.text += libraryLicenses
license.text += "\n"
license.text += "\n"
license.text += "Licenses details:\n"
fileTree(dir: 'library-licensing').getFiles().stream().sorted().forEach { file ->
license.text += "\n"
license.text += "\n"
license.text += file.text
}
}
}
static mergeServiceFiles(ShadowJar task) {
// Everything under META-INF is not included by default.
// Should include before 'relocate' so that the service file path and its content
// are properly relocated as well.
task.mergeServiceFiles {
include 'META-INF/services/*'
}
}
task repackageDepsNew(type: ShadowJar) {
configurations = [project.configurations.runtimeClasspath]
mergeServiceFiles(it)
exclude { it.getRelativePath().getPathString().endsWith("module-info.class") }
exclude { it.getRelativePath().getPathString().startsWith("META-INF/maven/") }
baseName 'deps_all'
}
task repackageSourcesNew(type: ShadowJar) {
// If this fails then remove all generated folders from
// build/classes/java/test that is not {com,dalvik}
from sourceSets.main.output
mergeServiceFiles(it)
baseName 'sources_main'
}
task repackageSources11New(type: ShadowJar) {
dependsOn compileMainWithJava11
from file(java11ClassFiles)
mergeServiceFiles(it)
baseName 'sources_main_11'
}
def r8CreateTask(name, baseNameName, sources, includeSwissArmyKnife) {
return tasks.create("r8Create${name}", ShadowJar) {
from consolidatedLicense.outputs.files
from sources
exclude "$buildDir/classes/**"
baseName baseNameName
classifier = null
version = null
if (includeSwissArmyKnife) {
manifest {
attributes 'Main-Class': 'com.android.tools.r8.SwissArmyKnife'
}
}
exclude "META-INF/*.kotlin_module"
exclude "**/*.kotlin_metadata"
}
}
def r8RelocateTask(r8Task, output) {
return tasks.create("r8Relocate_${r8Task.name}", Exec) {
dependsOn r8WithDeps
dependsOn r8Task
outputs.file output
workingDir = projectDir
inputs.files r8Task.outputs.files + r8WithDeps.outputs.files
commandLine baseCompilerCommandLine([
"relocator",
"--input",
r8Task.outputs.files[0],
"--output",
output,
"--map",
"com.google.common->com.android.tools.r8.com.google.common",
"--map",
"com.google.gson->com.android.tools.r8.com.google.gson",
"--map",
"com.google.thirdparty->com.android.tools.r8.com.google.thirdparty",
"--map",
"joptsimple->com.android.tools.r8.joptsimple",
"--map",
"org.objectweb.asm->com.android.tools.r8.org.objectweb.asm",
"--map",
"it.unimi.dsi.fastutil->com.android.tools.r8.it.unimi.dsi.fastutil",
"--map",
"kotlin->com.android.tools.r8.jetbrains.kotlin",
"--map",
"kotlinx->com.android.tools.r8.jetbrains.kotlinx",
"--map",
"org.jetbrains->com.android.tools.r8.org.jetbrains",
"--map",
"org.intellij->com.android.tools.r8.org.intellij"
])
}
}
task r8WithDeps {
dependsOn repackageSourcesNew
dependsOn repackageDepsNew
inputs.files ([repackageSourcesNew.outputs, repackageDepsNew.outputs])
def r8Task = r8CreateTask(
'WithDeps',
'r8_with_deps',
repackageSourcesNew.outputs.files + repackageDepsNew.outputs.files,
true)
dependsOn r8Task
outputs.files r8Task.outputs.files
}
task r8WithDeps11 {
dependsOn repackageSources11New
dependsOn repackageDepsNew
inputs.files ([repackageSources11New.outputs, repackageDepsNew.outputs])
def r8Task = r8CreateTask(
'WithDeps11',
'r8_with_deps_11',
repackageSources11New.outputs.files + repackageDepsNew.outputs.files,
true)
dependsOn r8Task
outputs.files r8Task.outputs.files
}
task r8WithRelocatedDeps {
def output = "${buildDir}/libs/r8_with_relocated_deps.jar"
dependsOn r8RelocateTask(r8WithDeps, output)
inputs.files r8WithDeps.outputs.files
outputs.file output
}
task r8WithRelocatedDeps11 {
def output = "${buildDir}/libs/r8_with_relocated_deps_11.jar"
dependsOn r8RelocateTask(r8WithDeps11, output)
inputs.files r8WithDeps11.outputs.files
outputs.file output
}
task r8WithoutDeps {
dependsOn repackageSourcesNew
inputs.files repackageSourcesNew.outputs
def r8Task = r8CreateTask(
'WithoutDeps',
'r8_without_deps',
repackageSourcesNew.outputs.files,
true)
dependsOn r8Task
outputs.files r8Task.outputs.files
}
task r8(type: Copy) {
def r8Task = project.hasProperty("exclude_deps")
? r8WithoutDeps : r8WithRelocatedDeps
dependsOn r8Task
from r8Task.outputs.files[0]
into file("${buildDir}/libs")
rename { String fileName -> "r8.jar" }
outputs.file "${buildDir}/libs/r8.jar"
}
task r8NoManifestWithoutDeps {
dependsOn repackageSourcesNew
inputs.files repackageSourcesNew.outputs
def r8Task = r8CreateTask(
'NoManifestWithoutDeps',
'r8_no_manifest_without_deps',
repackageSourcesNew.outputs.files,
false)
dependsOn r8Task
outputs.files r8Task.outputs.files
}
task r8NoManifestWithDeps {
dependsOn repackageSourcesNew
inputs.files ([repackageSourcesNew.outputs, repackageDepsNew.outputs])
def r8Task = r8CreateTask(
'NoManifestWithDeps',
'r8_no_manifest_with_deps',
repackageSourcesNew.outputs.files + repackageDepsNew.outputs.files,
false)
dependsOn r8Task
outputs.files r8Task.outputs.files
}
task r8NoManifestWithRelocatedDeps {
def output = "${buildDir}/libs/r8_no_manifest_with_relocated_deps.jar"
dependsOn r8RelocateTask(r8NoManifestWithDeps, output)
inputs.files r8NoManifestWithDeps.outputs.files
outputs.file output
}
task r8NoManifest(type: Copy) {
def r8Task = project.hasProperty("exclude_deps")
? r8NoManifestWithoutDeps : r8NoManifestWithRelocatedDeps
dependsOn r8Task
from r8Task.outputs.files[0]
into file("${buildDir}/libs")
rename { String fileName -> "r8_no_manifest.jar" }
outputs.file "${buildDir}/libs/r8_no_manifest.jar"
}
task D8(type: ShadowJar) {
dependsOn r8
from r8.outputs.files[0]
baseName 'd8'
manifest {
attributes 'Main-Class': 'com.android.tools.r8.D8'
}
}
def baseCompilerCommandLine(compiler, args = []) {
// Execute r8 commands against a stable r8 with dependencies.
// TODO(b/139725780): See if we can remove or lower the heap size (-Xmx8g).
return [org.gradle.internal.jvm.Jvm.current().getJavaExecutable(),
"-Xmx8g", "-ea", "-jar", r8WithDeps.outputs.files[0]] + compiler + args
}
def baseR8CommandLine(args = []) {
// Execute r8 commands against a stable r8 with dependencies.
return baseCompilerCommandLine("r8", args)
}
def baseD8CommandLine(args = []) {
// Execute r8 commands against a stable r8 with dependencies.
return baseCompilerCommandLine("d8", args)
}
def r8CfCommandLine(input, output, pgConfs = [], args = ["--release"], libs = []) {
def allArgs = [
"--classfile",
input,
"--output", output,
"--pg-map-output", output + ".map",
"--lib", "third_party/openjdk/openjdk-rt-1.8/rt.jar"
] + args + libs.collectMany { ["--lib", it] } + pgConfs.collectMany { ["--pg-conf", it] }
return baseR8CommandLine(allArgs)
}
def d8CfCommandLine(input, output, args = ["--release"], libs = []) {
def allArgs = [
"--classfile",
input,
"--output", output,
"--lib", "third_party/openjdk/openjdk-rt-1.8/rt.jar"
] + args + libs.collectMany { ["--lib", it] }
return baseD8CommandLine(allArgs)
}
def r8LibCreateTask(name, pgConfs = [], r8Task, output, args = ["--release"], libs = []) {
return tasks.create("r8Lib${name}", Exec) {
inputs.files ([pgConfs, r8WithRelocatedDeps.outputs, r8Task.outputs, libs])
outputs.file output
dependsOn downloadOpenJDKrt
dependsOn r8WithRelocatedDeps
dependsOn r8Task
commandLine r8CfCommandLine(r8Task.outputs.files[0], output, pgConfs, args, libs)
workingDir = projectDir
}
}
task buildLibraryDesugarConversions(type: Zip, dependsOn: downloadDeps) {
from sourceSets.libraryDesugarConversions.output
include "java/**/*.class"
baseName 'library_desugar_conversions'
destinationDir file('build/libs')
}
task testJarSources(type: ShadowJar, dependsOn: [testClasses, buildLibraryDesugarConversions]) {
baseName = "r8testsbase"
from sourceSets.test.output
// We only want to include tests that use R8 when generating keep rules for applymapping.
include "com/android/tools/r8/**"
include "dalvik/**"
}
task testJar(type: Exec) {
dependsOn r8WithDeps
dependsOn testJarSources
def output = "$buildDir/libs/r8tests.jar"
outputs.file output
workingDir = projectDir
inputs.files (testJarSources.outputs.files + r8WithDeps.outputs.files)
commandLine baseCompilerCommandLine([
"relocator",
"--input",
testJarSources.outputs.files[0],
"--output",
output,
"--map",
"kotlinx.metadata->com.android.tools.r8.jetbrains.kotlinx.metadata"
])
}
task buildDesugaredLibrary(type: Exec) {
def outputDir = "build/libs"
def script = "tools/create_jctf_tests.py"
inputs.file script
outputs.dir outputDir
dependsOn downloadDeps
commandLine "python", script
workingDir = projectDir
}
task generateR8LibKeepRules(type: Exec) {
doFirst {
// TODO(b/154785341): We should remove this.
standardOutput new FileOutputStream(r8LibGeneratedKeepRulesPath)
}
// Depend on r8WithDeps for running baseCompilerCommandLine.
dependsOn r8WithDeps
dependsOn r8NoManifestWithRelocatedDeps
dependsOn testJar
dependsOn downloadOpenJDKrt
inputs.files ([
r8WithDeps.outputs,
r8NoManifestWithRelocatedDeps.outputs,
testJar.outputs])
outputs.file r8LibGeneratedKeepRulesPath
commandLine baseCompilerCommandLine([
"printuses",
"--keeprules-allowobfuscation",
"third_party/openjdk/openjdk-rt-1.8/rt.jar",
r8NoManifestWithRelocatedDeps.outputs.files[0],
testJar.outputs.files[0]])
workingDir = projectDir
}
task R8LibApiOnly {
dependsOn r8LibCreateTask("Api", ["src/main/keep.txt"], r8NoManifest, r8LibPath)
outputs.file r8LibPath
}
task R8Lib {
dependsOn r8LibCreateTask(
"Main",
["src/main/keep.txt", generateR8LibKeepRules.outputs.files[0]],
r8NoManifestWithRelocatedDeps,
r8LibPath,
).dependsOn(generateR8LibKeepRules)
inputs.files r8NoManifestWithRelocatedDeps.outputs.files
outputs.file r8LibPath
}
task R8LibNoDeps {
dependsOn r8LibCreateTask(
"NoDeps",
["src/main/keep.txt"],
r8NoManifestWithoutDeps,
r8LibExludeDepsPath,
"--release",
repackageDepsNew.outputs.files
).dependsOn(repackageDepsNew)
inputs.files ([r8NoManifestWithoutDeps.outputs, repackageDepsNew.outputs])
outputs.file r8LibExludeDepsPath
}
task R8Desugared(type: Exec) {
dependsOn downloadOpenJDKrt
dependsOn r8NoManifestWithRelocatedDeps
inputs.files r8NoManifestWithRelocatedDeps.outputs.files
commandLine d8CfCommandLine(
r8NoManifestWithRelocatedDeps.outputs.files[0],
r8DesugaredPath,
["--release"])
workingDir = projectDir
outputs.file r8DesugaredPath
}
task R8Retrace {
dependsOn R8Lib
dependsOn r8LibCreateTask(
"Retrace",
["src/main/keep_retrace.txt"],
R8Lib,
r8RetracePath,
).dependsOn(R8Lib)
outputs.file r8RetracePath
}
task R8RetraceNoDeps {
dependsOn R8LibNoDeps
dependsOn r8LibCreateTask(
"RetraceNoDeps",
["src/main/keep_retrace.txt"],
R8LibNoDeps,
r8RetraceExludeDepsPath,
"--release",
repackageDepsNew.outputs.files
).dependsOn(R8LibNoDeps)
outputs.file r8RetraceExludeDepsPath
}
task sourceJar(type: Jar, dependsOn: classes) {
classifier = 'src'
from sourceSets.main.allSource
}
task jctfCommonJar(type: Jar) {
from sourceSets.jctfCommon.output
baseName 'jctfCommon'
}
artifacts {
archives sourceJar
}
task createArtTests(type: Exec) {
def outputDir = "build/generated/test/java/com/android/tools/r8/art"
def createArtTestsScript = "tools/create_art_tests.py"
inputs.files files("tests/2017-10-04/art.tar.gz", createArtTestsScript)
outputs.dir outputDir
dependsOn downloadDeps
commandLine "python", createArtTestsScript
workingDir = projectDir
}
task createJctfTests(type: Exec) {
def outputDir = "build/generated/test/java/com/android/tools/r8/jctf"
def script = "tools/create_jctf_tests.py"
inputs.file script
outputs.dir outputDir
dependsOn downloadDeps
commandLine "python", script
workingDir = projectDir
}
compileTestJava {
dependsOn createArtTests
dependsOn createJctfTests
}
task buildCfSegments(type: Jar, dependsOn: downloadDeps) {
from sourceSets.cfSegments.output
baseName 'cf_segments'
destinationDir file('build/libs')
}
task buildR8ApiUsageSample(type: Jar) {
from sourceSets.apiUsageSample.output
baseName 'r8_api_usage_sample'
destinationDir file('tests')
}
task buildApiSampleJars {
dependsOn buildR8ApiUsageSample
}
task buildDebugInfoExamplesDex {
def examplesDir = file("src/test/java")
def hostJar = "debuginfo_examples.jar"
def hostDexJar = "debuginfo_examples_dex.jar"
task "compile_debuginfo_examples"(type: JavaCompile) {
source = fileTree(dir: examplesDir, include: "com/android/tools/r8/debuginfo/*Test.java")
destinationDir = file("build/test/debuginfo_examples/classes")
classpath = sourceSets.main.compileClasspath
sourceCompatibility = JavaVersion.VERSION_1_7
targetCompatibility = JavaVersion.VERSION_1_7
options.compilerArgs += ["-Xlint:-options"]
}
task "jar_debuginfo_examples"(type: Jar, dependsOn: "compile_debuginfo_examples") {
archiveName = hostJar
destinationDir = file("build/test/")
from "build/test/debuginfo_examples/classes"
include "**/*.class"
}
task "dex_debuginfo_examples"(type: Exec,
dependsOn: ["jar_debuginfo_examples", "downloadDeps"]) {
if (OperatingSystem.current().isWindows()) {
executable file("tools/windows/dx/bin/dx.bat")
} else if (OperatingSystem.current().isMacOsX()) {
executable file("tools/mac/dx/bin/dx");
} else {
executable file("tools/linux/dx/bin/dx");
}
args "--dex"
args "--output=build/test/${hostDexJar}"
args "build/test/${hostJar}"
inputs.files files("build/test/${hostJar}")
outputs.file file("build/test/${hostDexJar}")
}
dependsOn dex_debuginfo_examples
}
task buildDebugTestResourcesJars {
def resourcesDir = file("src/test/debugTestResources")
def hostJar = "debug_test_resources.jar"
task "compile_debugTestResources"(type: JavaCompile) {
source = fileTree(dir: resourcesDir, include: '**/*.java')
destinationDir = file("build/test/debugTestResources/classes")
classpath = sourceSets.main.compileClasspath
sourceCompatibility = JavaVersion.VERSION_1_7
targetCompatibility = JavaVersion.VERSION_1_7
options.compilerArgs += ["-g", "-Xlint:-options"]
}
task "jar_debugTestResources"(type: Jar, dependsOn: "compile_debugTestResources") {
archiveName = hostJar
destinationDir = file("build/test/")
from "build/test/debugTestResources/classes"
include "**/*.class"
}
def java8ResourcesDir = file("src/test/debugTestResourcesJava8")
def java8HostJar = "debug_test_resources_java8.jar"
task "compile_debugTestResourcesJava8"(type: JavaCompile) {
source = fileTree(dir: java8ResourcesDir, include: '**/*.java')
destinationDir = file("build/test/debugTestResourcesJava8/classes")
classpath = sourceSets.main.compileClasspath
sourceCompatibility = JavaVersion.VERSION_1_8
targetCompatibility = JavaVersion.VERSION_1_8
options.compilerArgs += ["-g", "-Xlint:-options"]
}
task "jar_debugTestResourcesJava8"(type: Jar, dependsOn: "compile_debugTestResourcesJava8") {
archiveName = java8HostJar
destinationDir = file("build/test/")
from "build/test/debugTestResourcesJava8/classes"
include "**/*.class"
}
dependsOn downloadDeps
dependsOn jar_debugTestResources
dependsOn jar_debugTestResourcesJava8
}
// Examples used by tests, where Android specific APIs are used.
task buildExampleAndroidApi(type: JavaCompile) {
source = fileTree(dir: file("src/test/examplesAndroidApi"), include: "**/*.java")
destinationDir = file("build/test/examplesAndroidApi/classes")
classpath = files("third_party/android_jar/lib-v26/android.jar")
sourceCompatibility = JavaVersion.VERSION_1_8
targetCompatibility = JavaVersion.VERSION_1_8
}
task buildProtoGeneratedSources {
def examplesProtoDir = file("src/test/examplesProto")
examplesProtoDir.eachDir { dir ->
def name = dir.getName()
task "compile_proto_generated_source_${name}"(type: JavaCompile) {
source = {
file('third_party/proto').listFiles()
.findAll { it.name.startsWith(name) && it.name.endsWith('-src.jar') }
.collect { zipTree(it) }
}
destinationDir = file("build/generated/test/proto/${name}_classes")
classpath = files("third_party/protobuf-lite/libprotobuf_lite.jar")
sourceCompatibility = JavaVersion.VERSION_1_8
targetCompatibility = JavaVersion.VERSION_1_8
}
task "jar_proto_generated_source_${name}"(type: Jar, dependsOn: "compile_proto_generated_source_${name}") {
archiveName = "${name}.jar"
destinationDir = file("build/generated/test/proto")
from "build/generated/test/proto/${name}_classes"
include "/**/*.class"
}
dependsOn "jar_proto_generated_source_${name}"
}
}
task buildExamplesProto {
def examplesProtoDir = file("src/test/examplesProto")
def examplesProtoOutputDir = file("build/test/examplesProto");
dependsOn buildProtoGeneratedSources
task "compile_examples_proto"(type: JavaCompile) {
source = fileTree(dir: examplesProtoDir, include: "**/*.java")
destinationDir = file("build/test/examplesProto/classes")
classpath = files("third_party/protobuf-lite/libprotobuf_lite.jar")
classpath += fileTree(dir: "build/generated/test/proto", include: "*.jar")
sourceCompatibility = JavaVersion.VERSION_1_8
targetCompatibility = JavaVersion.VERSION_1_8
}
examplesProtoDir.eachDir { dir ->
def name = dir.getName()
task "jar_examples_proto_${name}"(type: Jar, dependsOn: "compile_examples_proto") {
archiveName = "${name}.jar"
destinationDir = examplesProtoOutputDir
from "build/test/examplesProto/classes"
include name + "/**/*.class"
}
dependsOn "jar_examples_proto_${name}"
}
}
// Proto lite generated code yields warnings when compiling with javac.
// We change the options passed to javac to ignore it.
compileExamplesJava.options.compilerArgs = ["-Xlint:none"]
task buildExampleJars {
dependsOn downloadProguard
def examplesDir = file("src/test/examples")
def proguardScript
if (OperatingSystem.current().isWindows()) {
proguardScript = "third_party/proguard/proguard5.2.1/bin/proguard.bat"
} else {
proguardScript = "third_party/proguard/proguard5.2.1/bin/proguard.sh"
}
task extractExamplesRuntime(type: Sync) {
dependsOn configurations.examplesRuntime
from { configurations.examplesRuntime.collect { zipTree(it) } }
include "**/*.class"
includeEmptyDirs false
into "$buildDir/runtime/examples/"
}
task "copy_examples_resources"(type: org.gradle.api.tasks.Copy) {
from examplesDir
exclude "**/*.java"
exclude "**/keep-rules*.txt"
into file("build/test/examples/classes")
}
task "compile_examples"(type: JavaCompile) {
dependsOn "copy_examples_resources"
source examplesDir
include "**/*.java"
destinationDir = file("build/test/examples/classes")
classpath = sourceSets.examples.compileClasspath
sourceCompatibility = JavaVersion.VERSION_1_7
targetCompatibility = JavaVersion.VERSION_1_7
options.compilerArgs = ["-g:source,lines", "-Xlint:none"]
}
task "compile_examples_debuginfo_all"(type: JavaCompile) {
source examplesDir
include "**/*.java"
destinationDir = file("build/test/examples/classes_debuginfo_all")
classpath = sourceSets.examples.compileClasspath
sourceCompatibility = JavaVersion.VERSION_1_7
targetCompatibility = JavaVersion.VERSION_1_7
options.compilerArgs = ["-g", "-Xlint:none"]
}
task "compile_examples_debuginfo_none"(type: JavaCompile) {
source examplesDir
include "**/*.java"
destinationDir = file("build/test/examples/classes_debuginfo_none")
classpath = sourceSets.examples.compileClasspath
sourceCompatibility = JavaVersion.VERSION_1_7
targetCompatibility = JavaVersion.VERSION_1_7
options.compilerArgs = ["-g:none", "-Xlint:none"]
}
examplesDir.eachDir { dir ->
def name = dir.getName();
def exampleOutputDir = file("build/test/examples");
def jarName = "${name}.jar"
dependsOn "jar_example_${name}"
dependsOn "jar_example_${name}_debuginfo_all"
dependsOn "jar_example_${name}_debuginfo_none"
dependsOn "extractExamplesRuntime"
def runtimeDependencies = copySpec { }
// The "throwing" test verifies debugging/stack info on the post-proguarded output.
def proguardConfigPath = "${dir}/proguard.cfg"
if (new File(proguardConfigPath).exists()) {
task "pre_proguard_example_${name}"(type: Jar, dependsOn: "compile_examples") {
archiveName = "${name}_pre_proguard.jar"
destinationDir = exampleOutputDir
from "build/test/examples/classes"
include name + "/**/*.class"
with runtimeDependencies
includeEmptyDirs false
}
def jarPath = files(tasks.getByPath("pre_proguard_example_${name}")).files.first();
def proguardJarPath = "${exampleOutputDir}/${jarName}"
def proguardMapPath = "${exampleOutputDir}/${name}/${name}.map"
task "jar_example_${name}"(type: Exec, dependsOn: "pre_proguard_example_${name}") {
inputs.files files(
tasks.getByPath("pre_proguard_example_${name}"),
proguardConfigPath)
// Enable these to get stdout and stderr redirected to files...
// standardOutput = new FileOutputStream('proguard.stdout')
// errorOutput = new FileOutputStream('proguard.stderr')
def proguardArguments = "-verbose -dontwarn java.** -injars ${jarPath}" +
" -outjars ${proguardJarPath}" +
" -include ${proguardConfigPath}" +
" -printmapping ${proguardMapPath}"
if (OperatingSystem.current().isWindows()) {
executable "${proguardScript}"
args "${proguardArguments}"
} else {
executable "bash"
args "-c", "${proguardScript} '${proguardArguments}'"
}
outputs.file proguardJarPath
}
// TODO: Consider performing distinct proguard compilations.
task "jar_example_${name}_debuginfo_all"(type: Copy, dependsOn: "jar_example_${name}") {
from "${exampleOutputDir}/${name}.jar"
into "${exampleOutputDir}"
rename(".*", "${name}_debuginfo_all.jar")
}
task "jar_example_${name}_debuginfo_none"(type: Copy, dependsOn: "jar_example_${name}") {
from "${exampleOutputDir}/${name}.jar"
into "${exampleOutputDir}"
rename(".*", "${name}_debuginfo_none.jar")
}
} else {
task "jar_example_${name}"(type: Jar, dependsOn: "compile_examples") {
archiveName = "${name}.jar"
destinationDir = exampleOutputDir
from "build/test/examples/classes"
include name + "/**/*"
with runtimeDependencies
includeEmptyDirs true
}
task "jar_example_${name}_debuginfo_all"(type: Jar, dependsOn: "compile_examples_debuginfo_all") {
archiveName = "${name}_debuginfo_all.jar"
destinationDir = exampleOutputDir
from "build/test/examples/classes_debuginfo_all"
include name + "/**/*.class"
with runtimeDependencies
includeEmptyDirs false
}
task "jar_example_${name}_debuginfo_none"(type: Jar, dependsOn: "compile_examples_debuginfo_none") {
archiveName = "${name}_debuginfo_none.jar"
destinationDir = exampleOutputDir
from "build/test/examples/classes_debuginfo_none"
include name + "/**/*.class"
with runtimeDependencies
includeEmptyDirs false
}
}
}
}
task buildExampleAndroidNJars {
dependsOn downloadDeps
def examplesDir = file("src/test/examplesAndroidN")
task "compile_examplesAndroidN"(type: JavaCompile) {
source = fileTree(dir: examplesDir, include: '**/*.java')
destinationDir = file("build/test/examplesAndroidN/classes")
classpath = sourceSets.main.compileClasspath
sourceCompatibility = JavaVersion.VERSION_1_8
targetCompatibility = JavaVersion.VERSION_1_8
options.compilerArgs += ["-Xlint:-options"]
}
examplesDir.eachDir { dir ->
def name = dir.getName();
def exampleOutputDir = file("build/test/examplesAndroidN");
def jarName = "${name}.jar"
dependsOn "jar_examplesAndroidN_${name}"
task "jar_examplesAndroidN_${name}"(type: Jar, dependsOn: "compile_examplesAndroidN") {
archiveName = jarName
destinationDir = exampleOutputDir
from "build/test/examplesAndroidN/classes"
include "**/" + name + "/**/*.class"
}
}
}
task buildExampleAndroidOJars {
dependsOn downloadDeps
def examplesDir = file("src/test/examplesAndroidO")
// NOTE: we want to enable a scenario when test needs to reference some
// classes generated by legacy (1.6) Java compiler to test some specific
// behaviour. To do so we compile all the java files located in sub-directory
// called 'legacy' with Java 1.6, then compile the rest of the files with
// Java 1.8 and a reference to previously generated 1.6 classes.
// Compiling all classes in dirs 'legacy' with old Java version.
task "compile_examplesAndroidO_Legacy"(type: JavaCompile) {
source = fileTree(dir: examplesDir, include: '**/legacy/**/*.java')
destinationDir = file("build/test/examplesAndroidOLegacy/classes")
classpath = sourceSets.main.compileClasspath
sourceCompatibility = JavaVersion.VERSION_1_6
targetCompatibility = JavaVersion.VERSION_1_6
options.compilerArgs += ["-Xlint:-options", "-parameters"]
}
// Compiling the rest of the files as Java 1.8 code.
task "compile_examplesAndroidO"(type: JavaCompile) {
dependsOn "compile_examplesAndroidO_Legacy"
source = fileTree(dir: examplesDir, include: '**/*.java', exclude: '**/legacy/**/*.java')
destinationDir = file("build/test/examplesAndroidO/classes")
classpath = sourceSets.main.compileClasspath
classpath += files("build/test/examplesAndroidOLegacy/classes")
sourceCompatibility = JavaVersion.VERSION_1_8
targetCompatibility = JavaVersion.VERSION_1_8
options.compilerArgs += ["-Xlint:-options", "-parameters"]
}
examplesDir.eachDir { dir ->
def name = dir.getName();
def destinationDir = file("build/test/examplesAndroidO/classes");
if (file("src/test/examplesAndroidO/" + name + "/TestGenerator.java").isFile()) {
task "generate_examplesAndroidO_${name}"(type: JavaExec,
dependsOn: "compile_examplesAndroidO") {
main = name + ".TestGenerator"
classpath = files(destinationDir, sourceSets.main.compileClasspath)
args destinationDir
}
} else {
task "generate_examplesAndroidO_${name}" () {}
}
}
examplesDir.eachDir { dir ->
def name = dir.getName();
def exampleOutputDir = file("build/test/examplesAndroidO");
def jarName = "${name}.jar"
dependsOn "jar_examplesAndroidO_${name}"
task "jar_examplesAndroidO_${name}"(type: Jar, dependsOn: ["compile_examplesAndroidO",
"generate_examplesAndroidO_${name}"]) {
archiveName = jarName
destinationDir = exampleOutputDir
from "build/test/examplesAndroidO/classes" // Java 1.8 classes
from "build/test/examplesAndroidOLegacy/classes" // Java 1.6 classes
include "**/" + name + "/**/*.class"
// Do not include generator into the test runtime jar, it is not useful.
// Otherwise, shrinking will need ASM jars.
exclude "**/TestGenerator*"
}
}
}
task buildExampleAndroidPJars {
dependsOn downloadDeps
def examplesDir = file("src/test/examplesAndroidP")
task "compile_examplesAndroidP"(type: JavaCompile) {
source = fileTree(dir: examplesDir, include: '**/*.java')
destinationDir = file("build/test/examplesAndroidP/classes")
classpath = sourceSets.main.compileClasspath
sourceCompatibility = JavaVersion.VERSION_1_8
targetCompatibility = JavaVersion.VERSION_1_8
options.compilerArgs += ["-Xlint:-options"]
}
examplesDir.eachDir { dir ->
def name = dir.getName();
def destinationDir = file("build/test/examplesAndroidP/classes");
if (file("src/test/examplesAndroidP/" + name + "/TestGenerator.java").isFile()) {
task "generate_examplesAndroidP_${name}"(type: JavaExec,
dependsOn: "compile_examplesAndroidP") {
main = name + ".TestGenerator"
classpath = files(destinationDir, sourceSets.main.compileClasspath)
args destinationDir
}
} else {
task "generate_examplesAndroidP_${name}" () {}
}
}
examplesDir.eachDir { dir ->
def name = dir.getName();
def exampleOutputDir = file("build/test/examplesAndroidP");
def jarName = "${name}.jar"
dependsOn "jar_examplesAndroidP_${name}"
task "jar_examplesAndroidP_${name}"(type: Jar,
dependsOn: ["compile_examplesAndroidP",
"generate_examplesAndroidP_${name}"]) {
archiveName = jarName
destinationDir = exampleOutputDir
from "build/test/examplesAndroidP/classes" // Java 1.8 classes
include "**/" + name + "/**/*.class"
// Do not include generator into the test runtime jar, it is not useful.
// Otherwise, shrinking will need ASM jars.
exclude "**/TestGenerator*"
}
}
}
def buildExampleJarsCreateTask(javaVersion, sourceSet) {
return tasks.create("buildExample${javaVersion}Jars") {
def examplesDir = file("src/test/examples${javaVersion}")
examplesDir.eachDir { dir ->
def name = dir.getName();
def exampleOutputDir = file("build/test/examples${javaVersion}");
def jarName = "${name}.jar"
dependsOn "jar_examples${javaVersion}_${name}"
task "jar_examples${javaVersion}_${name}"(type: Jar) {
archiveName = jarName
destinationDir = exampleOutputDir
from sourceSet.output
include "**/" + name + "/**/*.class"
}
}
}
}
buildExampleJarsCreateTask("Java9", sourceSets.examplesJava9)
buildExampleJarsCreateTask("Java10", sourceSets.examplesJava10)
buildExampleJarsCreateTask("Java11", sourceSets.examplesJava11)
buildExampleJarsCreateTask("Java15", sourceSets.examplesJava15)
task provideArtFrameworksDependencies {
cloudDependencies.tools.forEach({ art ->
if (art.contains("art")) {
def taskName = art.replace('/','_')
dependsOn "patch_${taskName}"
task "patch_${taskName}"(type: org.gradle.api.tasks.Copy){
from "tools/${art}/framework"
include "**.jar"
into file("tools/${art}/out/host/linux-x86/framework")
}
}
})
}
task provideJdk11TestsDependencies(type: org.gradle.api.tasks.Copy) {
from sourceSets.jdk11TimeTests.compileClasspath
include "**/**.jar"
into file("build/test/jdk11Tests")
}
task buildJdk11TimeTestsJar {
def exampleOutputDir = file("build/test/jdk11Tests");
def jarName = "jdk11TimeTests.jar"
dependsOn "jar_jdk11TimeTests"
dependsOn provideJdk11TestsDependencies
task "jar_jdk11TimeTests"(type: Jar) {
archiveName = jarName
destinationDir = exampleOutputDir
from sourceSets.examplesTestNGRunner.output
include "**.class"
from sourceSets.jdk11TimeTests.output
include "**.class"
include "**/**.class"
}
}
task buildKotlinR8TestResources {
def examplesDir = file("src/test/kotlinR8TestResources")
examplesDir.eachDir { dir ->
kotlin.Kotlinc.KotlinTargetVersion.values().each { kotlinTargetVersion ->
def name = dir.getName()
def taskName = "jar_kotlinR8TestResources_${name}_${kotlinTargetVersion}"
def javaOutput = "build/test/kotlinR8TestResources/${kotlinTargetVersion}/${name}/java"
def javaOutputJarName = "${name}.java.jar"
def javaOutputJarDir = "build/test/kotlinR8TestResources/${kotlinTargetVersion}"
task "${taskName}Java"(type: JavaCompile) {
source = fileTree(dir: file("${examplesDir}/${name}"), include: '**/*.java')
destinationDir = file(javaOutput)
classpath = sourceSets.main.compileClasspath
sourceCompatibility = JavaVersion.VERSION_1_6
targetCompatibility = JavaVersion.VERSION_1_6
options.compilerArgs += ["-g", "-Xlint:-options"]
}
task "${taskName}JavaJar"(type: Jar, dependsOn: "${taskName}Java") {
archiveName = javaOutputJarName
destinationDir = file(javaOutputJarDir)
from javaOutput
include "**/*.class"
}
dependsOn "${taskName}JavaJar"
}
}
}
task buildExamples {
if (OperatingSystem.current().isMacOsX() || OperatingSystem.current().isWindows()) {
logger.lifecycle("WARNING: Testing (including building examples) is only partially supported on your " +
"platform (" + OperatingSystem.current().getName() + ").")
} else if (!OperatingSystem.current().isLinux()) {
logger.lifecycle("WARNING: Testing (including building examples) is not supported on your platform. " +
"It is fully supported on Linux and partially supported on Mac OS and Windows")
return;
}
dependsOn buildDebugTestResourcesJars
dependsOn buildExampleJars
dependsOn buildExampleAndroidNJars
dependsOn buildExampleAndroidOJars
dependsOn buildExampleAndroidPJars
dependsOn buildExampleJava9Jars
dependsOn buildExampleJava10Jars
dependsOn buildExampleJava11Jars
dependsOn buildExampleJava15Jars
dependsOn buildExampleAndroidApi
def examplesDir = file("src/test/examples")
def noDexTests = [
"multidex",
"multidex002",
"multidex004",
]
examplesDir.eachDir { dir ->
def name = dir.getName();
if (!(name in noDexTests)) {
dependsOn "dex_example_${name}"
def exampleOutputDir = file("build/test/examples/" + name);
def dexPath = file("${exampleOutputDir}")
def debug = (name == "throwing")
if (!dexPath.exists()) {
dexPath.mkdirs()
}
task "dex_example_${name}"(type: DxTask, dependsOn: "jar_example_${name}") {
source = files(tasks.getByPath("jar_example_${name}")).asFileTree
destination = dexPath
debug = debug
}
}
}
}
task buildSmali {
def smaliDir = file("src/test/smali")
smaliDir.eachDirRecurse() { dir ->
def name = dir.getName();
def relativeDir = smaliDir.toPath().relativize(dir.toPath());
def smaliOutputDir = file("build/test/smali/" + relativeDir);
smaliOutputDir.mkdirs()
outputs.dir smaliOutputDir
def taskName = "smali_build_${relativeDir.toString().replace('/', '_').replace('\\', '_')}"
def smaliFiles = fileTree(dir: dir, include: '*.smali')
def javaFiles = fileTree(dir: dir, include: '*.java')
def destDir = smaliOutputDir;
def destFile = destDir.toPath().resolve("${name}.dex").toFile()
def intermediateFileName = "${name}-intermediate.dex";
def intermediateFile = destDir.toPath().resolve(intermediateFileName).toFile()
if (javaFiles.empty) {
if (!smaliFiles.empty) {
dependsOn "${taskName}_smali"
task "${taskName}_smali"(type: SmaliTask) {
source = smaliFiles
destination = destFile
}
}
} else {
dependsOn "${taskName}_dexmerger"
task "${taskName}_smali"(type: SmaliTask) {
source = smaliFiles
destination = intermediateFile
}
task "${taskName}_java"(type: JavaCompile) {
source = javaFiles
destinationDir destDir
classpath = sourceSets.main.compileClasspath
sourceCompatibility = JavaVersion.VERSION_1_7
targetCompatibility = JavaVersion.VERSION_1_7
options.compilerArgs += ["-Xlint:-options"]
}
task "${taskName}_jar"(type: Jar, dependsOn: "${taskName}_java") {
archiveName = "Test.jar"
destinationDir = destDir
from fileTree(dir: destDir, include: 'Test.class')
}
task "${taskName}_dx"(type: DxTask, dependsOn: "${taskName}_jar") {
source = fileTree(dir: destDir, include: 'Test.jar')
destination = destDir
}
task "${taskName}_dexmerger"(
type: DexMergerTask, dependsOn: ["${taskName}_dx", "${taskName}_smali"]) {
source = fileTree(dir: destDir, include: ["classes.dex", intermediateFileName])
destination = destFile
}
}
}
}
tasks.withType(Test) {
println("NOTE: Number of processors " + Runtime.runtime.availableProcessors())
def userDefinedCoresPerFork = System.getenv('R8_GRADLE_CORES_PER_FORK')
def processors = Runtime.runtime.availableProcessors()
// See https://docs.gradle.org/current/dsl/org.gradle.api.tasks.testing.Test.html.
if (userDefinedCoresPerFork) {
maxParallelForks = processors.intdiv(userDefinedCoresPerFork.toInteger()) ?: 1
} else {
// On normal work machines this seems to give the best test execution time (without freezing)
maxParallelForks = processors.intdiv(3) ?: 1
}
println("NOTE: Max parallel forks " + maxParallelForks)
forkEvery = 0
if (project.hasProperty('disable_assertions')) {
enableAssertions = false
}
// TODO(b/124091860): Increase the max heap size to avoid OOM when running tests.
if (project.hasProperty('test_xmx')) {
maxHeapSize = project.property('test_xmx')
} else {
maxHeapSize = "4G"
}
}
task buildPreNJdwpTestsJar(type: Jar) {
baseName = 'jdwp-tests-preN'
from zipTree('third_party/jdwp-tests/apache-harmony-jdwp-tests-host.jar')
// Exclude the classes containing java8
exclude 'org/apache/harmony/jpda/tests/jdwp/InterfaceType/*.class'
exclude 'org/apache/harmony/jpda/tests/jdwp/ObjectReference/InvokeMethodDefault*.class'
includeEmptyDirs = false
}
task buildPreNJdwpTestsDex(type: Exec, dependsOn: "buildPreNJdwpTestsJar") {
def inFile = buildPreNJdwpTestsJar.archivePath
def outFile = new File(buildPreNJdwpTestsJar.destinationDir, buildPreNJdwpTestsJar.baseName + '-dex.jar')
inputs.files files(inFile)
outputs.file outFile
if (OperatingSystem.current().isWindows()) {
executable file("tools/windows/dx/bin/dx.bat")
} else if (OperatingSystem.current().isMacOsX()) {
executable file("tools/mac/dx/bin/dx");
} else {
executable file("tools/linux/dx/bin/dx");
}
args "--dex"
args "--output=${outFile}"
args inFile
}
task getJarsFromSupportLibs(type: GetJarsFromConfiguration) {
setConfiguration(configurations.supportLibs)
}
task generateR8TestKeepRules {
def path = "build/generated/r8tests-keep.txt"
outputs.file path
dependsOn R8Lib
doLast {
file(path).write """-keep class ** { *; }
-dontshrink
-dontoptimize
-keepattributes *
-applymapping ${R8Lib.outputs.files[0]}.map
"""
}
}
task buildR8LibCfTestDeps(type: Exec) {
def outputPath = "build/libs/r8libtestdeps-cf.jar"
dependsOn downloadDeps
dependsOn r8NoManifest
dependsOn R8Lib
dependsOn generateR8TestKeepRules
dependsOn testJar
// Take all .jar files as libraries and append the generated test classes in classes/java/test.
def addedLibraries = sourceSets.test.runtimeClasspath.findAll { pkg ->
return pkg.toString().endsWith(".jar")
} + ["${buildDir}/classes/java/test"]
inputs.files testJar.outputs.files +
generateR8TestKeepRules.outputs.files +
R8Lib.outputs
commandLine = r8CfCommandLine(
testJar.outputs.files[0],
outputPath,
[generateR8TestKeepRules.outputs.files[0]],
["--debug", "--classpath", r8NoManifest.outputs.files[0]],
r8NoManifest.outputs.files + addedLibraries)
workingDir = projectDir
outputs.file outputPath
}
task configureTestForR8Lib(type: Copy) {
dependsOn testJar
inputs.files buildR8LibCfTestDeps.outputs
dependsOn R8Lib
delete r8LibTestPath
from zipTree(buildR8LibCfTestDeps.outputs.files[0])
def examplesDir = file("build/test")
examplesDir.eachDir { dir ->
from ("${buildDir}/test/${dir.getName()}/classes")
}
from ("${buildDir}/runtime/examples")
into r8LibTestPath
outputs.dir r8LibTestPath
}
def shouldRetrace() {
return project.hasProperty('r8lib') || project.hasProperty('r8lib_no_deps')
}
def retrace(Throwable exception) {
def out = new StringBuffer()
def err = new StringBuffer()
def command = "python tools/retrace.py --quiet"
def header = "RETRACED STACKTRACE";
if (System.getenv('BUILDBOT_BUILDERNAME') != null
&& !System.getenv('BUILDBOT_BUILDERNAME').endsWith("_release")) {
header += ": (${command} --commit_hash ${System.getenv('BUILDBOT_REVISION')})";
}
out.append("\n--------------------------------------\n")
out.append("${header}\n")
out.append("--------------------------------------\n")
Process process = command.execute()
def processIn = new PrintStream(process.getOut())
process.consumeProcessOutput(out, err)
exception.printStackTrace(processIn)
processIn.flush()
processIn.close()
def errorDuringRetracing = process.waitFor() != 0
if (errorDuringRetracing) {
out.append("ERROR DURING RETRACING\n")
out.append(err.toString())
}
if (project.hasProperty('print_obfuscated_stacktraces') || errorDuringRetracing) {
out.append("\n\n--------------------------------------\n")
out.append("OBFUSCATED STACKTRACE\n")
out.append("--------------------------------------\n")
}
return out.toString()
}
def printStackTrace(TestResult result) {
filterStackTraces(result)
if (shouldRetrace()) {
def exception = new Exception(retrace(result.exception))
exception.setStackTrace([] as StackTraceElement[])
result.exceptions.add(0, exception)
}
}
def filterStackTraces(TestResult result) {
for (Throwable throwable : result.getExceptions()) {
filterStackTrace(throwable)
}
}
// It would be nice to do this in a non-destructive way...
def filterStackTrace(Throwable exception) {
if (!project.hasProperty('print_full_stacktraces')) {
def elements = []
def skipped = []
for (StackTraceElement element : exception.getStackTrace()) {
if (element.toString().contains("com.android.tools.r8")) {
elements.addAll(skipped)
elements.add(element)
skipped.clear()
} else {
skipped.add(element)
}
}
exception.setStackTrace(elements as StackTraceElement[])
}
}
def printAllStackTracesToFile(List<Throwable> exceptions, File out) {
new PrintStream(new FileOutputStream(out)).withCloseable {printer ->
exceptions.forEach { it.printStackTrace(printer) }
}
}
static def escapeHtml(String string) {
return string.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
}
static def urlEncode(String string) {
// Not sure why, but the + also needs to be converted to have working links.
return URLEncoder.encode(string, "UTF-8").replace("+","%20")
}
def ensureDir(File dir) {
dir.mkdirs()
return dir
}
// Some of our test parameters have new lines :-( We really don't want test names to span lines.
static def sanitizedTestName(testDesc) {
if (testDesc.getName().contains("\n")) {
throw new RuntimeException("Unsupported use of newline in test name: '${testDesc.getName()}'")
}
return testDesc.getName()
}
static def desanitizedTestName(testName) {
return testName
}
def getTestReportEntryDir(reportDir, testDesc) {
return ensureDir(reportDir.toPath()
.resolve(testDesc.getClassName())
.resolve(sanitizedTestName(testDesc))
.toFile())
}
def getTestReportEntryURL(reportDir, testDesc) {
def classDir = urlEncode(testDesc.getClassName())
def testDir = urlEncode(sanitizedTestName(testDesc))
return "file://${reportDir}/${classDir}/${testDir}"
}
def getTestResultEntryOutputFile(reportDir, testDesc, fileName) {
def dir = getTestReportEntryDir(reportDir, testDesc).toPath()
return dir.resolve(fileName).toFile()
}
def withTestResultEntryWriter(reportDir, testDesc, fileName, append, fn) {
def file = getTestResultEntryOutputFile(reportDir, testDesc, fileName)
new FileWriter(file, append).withCloseable fn
}
static def getGitBranchName() {
def out = new StringBuilder()
def err = new StringBuilder()
def proc = "git rev-parse --abbrev-ref HEAD".execute()
proc.waitForProcessOutput(out, err)
return out.toString().trim()
}
static def getFreshTestReportIndex(File reportDir) {
def number = 0
while (true) {
def freshIndex = reportDir.toPath().resolve("index.${number++}.html").toFile()
if (!freshIndex.exists()) {
return freshIndex
}
}
}
def forEachTestReportAlreadyX(File reportDir, fileName, onTest) {
def out = new StringBuilder()
def err = new StringBuilder()
def proc = "find . -name ${fileName}".execute([], reportDir)
proc.waitForProcessOutput(out, err)
def outString = out.toString()
outString.eachLine {
// Lines are of the form: ./<class>/<name>/FAILURE
def clazz = null
def name = null
try {
def trimmed = it.trim()
def line = trimmed.substring(2)
def sep = line.indexOf("/")
clazz = line.substring(0, sep)
name = line.substring(sep + 1, line.length() - fileName.length() - 1)
} catch (Exception e) {
logger.lifecycle("WARNING: failed attempt to read test description from: '${it}'")
return
}
onTest(clazz, desanitizedTestName(name))
}
return !outString.trim().isEmpty()
}
def forEachTestReportAlreadyFailing(File reportDir, onFailureTest) {
return forEachTestReportAlreadyX(reportDir, TestResult.ResultType.FAILURE.name(), onFailureTest)
}
def forEachTestReportAlreadyPassing(File reportDir, onSucceededTest) {
return forEachTestReportAlreadyX(reportDir, TestResult.ResultType.SUCCESS.name(), onSucceededTest)
}
def forEachTestReportAlreadySkipped(File reportDir, onSucceededTest) {
return forEachTestReportAlreadyX(reportDir, TestResult.ResultType.SKIPPED.name(), onSucceededTest)
}
def setUpTestingState(Test task) {
// Hide all test events from the console, they are written to the report.
task.testLogging { events = [] }
def branch = getGitBranchName()
def reportDir = file("${buildDir}/test-state/${branch}")
def index = reportDir.toPath().resolve("index.html").toFile()
def resetState = project.hasProperty('reset-testing-state')
def reportDirExists = reportDir.exists()
def resuming = !resetState && reportDirExists
def hasFailingTests = false;
if (resuming) {
// Test filtering happens before the test execution is initiated so compute it here.
// If there are still failing tests in the report, include only those.
hasFailingTests = forEachTestReportAlreadyFailing(reportDir, {
clazz, name -> task.filter.includeTestsMatching("$clazz.$name")
})
// Otherwise exclude all of the test already marked as succeeding.
if (!hasFailingTests) {
// Also allow the test to overall succeed if there are no remaining tests that match,
// which is natural if the state already succeeded in full.
task.filter.failOnNoMatchingTests = false
forEachTestReportAlreadyPassing(reportDir, {
clazz, name -> task.filter.excludeTestsMatching("$clazz.$name")
})
forEachTestReportAlreadySkipped(reportDir, {
clazz, name -> task.filter.excludeTestsMatching("$clazz.$name")
})
}
}
task.beforeSuite { desc ->
if (!desc.parent) {
def parentReport = null
if (resetState && reportDirExists) {
delete reportDir
}
if (resuming) {
if (index.exists()) {
parentReport = getFreshTestReportIndex(reportDir)
index.renameTo(parentReport)
}
} else {
reportDir.mkdirs()
}
def runPrefix = resuming ? "Resuming" : "Starting"
def title = "${runPrefix} @ ${branch}"
// Print a console link to the test report for easy access.
println "${runPrefix} test, report written to:"
println " file://${index}"
// Print the new index content.
index << "<html><head><title>${title}</title>"
index << "<style> * { font-family: monospace; }</style>"
index << "</head><body><h1>${title}</h1>"
index << "<p>Run on: ${new Date()}</p>"
index << "<p>Git branch: ${branch}</p>"
if (parentReport != null) {
index << "<p><a href=\"file://${parentReport}\">Previous result index</a></p>"
}
index << "<p><a href=\"file://${index}\">Most recent result index</a></p>"
index << "<p><a href=\"file://${reportDir}\">Test directories</a></p>"
index << "<h2>Failing tests (reload to refresh)</h2><ul>"
}
}
task.afterSuite { desc, result ->
if (!desc.parent) {
// Update the final test results in the index.
index << "</ul>"
if (result.resultType == TestResult.ResultType.SUCCESS) {
if (hasFailingTests) {
index << "<h2>Rerun of failed tests now pass!</h2>"
index << "<h2>Rerun again to continue with outstanding tests!</h2>"
} else {
index << "<h2 style=\"background-color:#62D856\">GREEN BAR == YOU ROCK!</h2>"
}
} else if (result.resultType == TestResult.ResultType.FAILURE) {
index << "<h2 style=\"background-color:#6D130A\">Some tests failed: ${result.resultType.name()}</h2><ul>"
} else {
index << "<h2>Tests finished: ${result.resultType.name()}</h2><ul>"
}
index << "<li>Number of tests: ${result.testCount}"
index << "<li>Failing tests: ${result.failedTestCount}"
index << "<li>Successful tests: ${result.successfulTestCount}"
index << "<li>Skipped tests: ${result.skippedTestCount}"
index << "</ul></body></html>"
}
}
// Events to stdout/err are appended to the files in the test directories.
task.onOutput { desc, event ->
withTestResultEntryWriter(reportDir, desc, event.getDestination().name(), true, {
it.append(event.getMessage())
})
}
task.beforeTest { desc ->
// Remove any stale output files before running the test.
for (def destType : TestOutputEvent.Destination.values()) {
def destFile = getTestResultEntryOutputFile(reportDir, desc, destType.name())
if (destFile.exists()) {
delete destFile
}
}
}
task.afterTest { desc, result ->
if (result.getTestCount() != 1) {
throw new IllegalStateException("Unexpected test with more than one result: ${desc}")
}
// Clear any previous result files.
for (def resultType : TestResult.ResultType.values()) {
delete getTestResultEntryOutputFile(reportDir, desc, resultType.name())
}
// Emit the result type status in a file of the same name: SUCCESS, FAILURE or SKIPPED.
withTestResultEntryWriter(reportDir, desc, result.getResultType().name(), false, {
it.append(result.getResultType().name())
})
// Emit the test time.
withTestResultEntryWriter(reportDir, desc, "time", false, {
it.append("${result.getEndTime() - result.getStartTime()}")
})
// For failed tests, update the index and emit stack trace information.
if (result.resultType == TestResult.ResultType.FAILURE) {
def title = escapeHtml("${desc.className}.${desc.name}")
def link = getTestReportEntryURL(reportDir, desc)
index << "<li><a href=\"${link}\">${title}</a></li>"
if (!result.exceptions.isEmpty()) {
printAllStackTracesToFile(
result.exceptions,
getTestResultEntryOutputFile(
reportDir,
desc,
"exceptions-raw.txt"))
filterStackTraces(result)
printAllStackTracesToFile(
result.exceptions,
getTestResultEntryOutputFile(
reportDir,
desc,
"exceptions-filtered.txt"))
if (shouldRetrace()) {
withTestResultEntryWriter(reportDir, desc, "exceptions-retraced.txt", false, { writer ->
result.exceptions.forEach { writer.append(retrace(it)) }
})
}
}
}
}
}
def testTimes = [:]
def numberOfTestTimesToPrint = 100
test { task ->
dependsOn buildLibraryDesugarConversions
dependsOn getJarsFromSupportLibs
// R8.jar is required for running bootstrap tests.
dependsOn r8
def useTestingState = project.hasProperty('testing-state')
if (useTestingState) {
setUpTestingState(task)
}
if (project.hasProperty('generate_golden_files_to')) {
systemProperty 'generate_golden_files_to', project.property('generate_golden_files_to')
assert project.hasProperty('HEAD_sha1')
systemProperty 'test_git_HEAD_sha1', project.property('HEAD_sha1')
}
if (project.hasProperty('use_golden_files_in')) {
systemProperty 'use_golden_files_in', project.property('use_golden_files_in')
assert project.hasProperty('HEAD_sha1')
systemProperty 'test_git_HEAD_sha1', project.property('HEAD_sha1')
}
if (!useTestingState) {
testLogging.exceptionFormat = 'full'
if (project.hasProperty('print_test_stdout')) {
testLogging.showStandardStreams = true
}
}
if (project.hasProperty('dex_vm') && project.property('dex_vm') != 'default') {
println "NOTE: Running with non default vm: " + project.property('dex_vm')
systemProperty 'dex_vm', project.property('dex_vm')
}
// Forward runtime configurations for test parameters.
if (project.hasProperty('runtimes')) {
println "NOTE: Running with runtimes: " + project.property('runtimes')
systemProperty 'runtimes', project.property('runtimes')
}
if (project.hasProperty('slow_tests')) {
systemProperty 'slow_tests', project.property('slow_tests')
}
if (project.hasProperty('desugar_jdk_json_dir')) {
systemProperty 'desugar_jdk_json_dir', project.property('desugar_jdk_json_dir')
}
if (project.hasProperty('desugar_jdk_libs')) {
systemProperty 'desugar_jdk_libs', project.property('desugar_jdk_libs')
}
if (!useTestingState) {
if (project.hasProperty('print_times') || project.hasProperty('one_line_per_test')) {
afterTest { desc, result ->
def executionTime = (result.endTime - result.startTime) / 1000
testTimes["${desc.name} [${desc.className}]"] = executionTime
}
afterSuite { desc, result ->
// parent is null if all tests are done.
if (desc.parent == null) {
def sortedTimes = testTimes.sort({ e1, e2 -> e2.value <=> e1.value })
sortedTimes.eachWithIndex { key, value, i ->
if (i < numberOfTestTimesToPrint) println "$key: $value"
}
}
}
}
if (project.hasProperty('one_line_per_test')) {
beforeTest { desc ->
println "Start executing test ${desc.name} [${desc.className}]"
}
afterTest { desc, result ->
if (result.resultType == TestResult.ResultType.FAILURE) {
printStackTrace(result)
}
if (project.hasProperty('update_test_timestamp')) {
file(project.getProperty('update_test_timestamp')).text = new Date().getTime()
}
println "Done executing test ${desc.name} [${desc.className}] with result: ${result.resultType}"
}
} else {
afterTest { desc, result ->
if (result.resultType == TestResult.ResultType.FAILURE) {
printStackTrace(result)
}
}
}
}
if (project.hasProperty('no_internal')) {
exclude "com/android/tools/r8/internal/**"
} else {
dependsOn buildExamplesProto
}
if (project.hasProperty('only_internal')) {
include "com/android/tools/r8/internal/**"
}
if (project.hasProperty('test_namespace')) {
include "com/android/tools/r8/" + project.getProperty('test_namespace') + "/**"
}
if (project.hasProperty('tool')) {
if (project.property('tool') == 'r8') {
exclude "com/android/tools/r8/jctf/**"
} else if (project.property('tool') == 'd8') {
if (project.hasProperty('only_jctf')) {
include "com/android/tools/r8/jctf/d8/**"
} else {
// Don't run anything, deprecated
println "Running with deprecated tool d8, not running any tests"
include ""
}
} else {
assert(project.property('tool') == 'r8cf')
assert(project.hasProperty('only_jctf'))
include "com/android/tools/r8/jctf/r8cf/**"
}
}
if (!project.hasProperty('all_tests')) {
exclude "com/android/tools/r8/art/dx/**"
}
if (!project.hasProperty('jctf') && !project.hasProperty('only_jctf')) {
exclude "com/android/tools/r8/jctf/**"
}
if (project.hasProperty('shard_count') ) {
assert project.hasProperty('shard_number')
int shard_count = project.getProperty('shard_count') as Integer
int shard_number = project.getProperty('shard_number') as Integer
assert shard_count < 65536
assert shard_number < shard_count
exclude {
entry ->
// Don't leave out directories. Leaving out a directory means all entries below.
if (entry.file.isDirectory()) {
return false
}
def first4 = entry.getRelativePath().toString().md5().substring(0, 4)
int hash = Integer.parseInt(first4, 16)
return hash % shard_count != shard_number
}
}
if (project.hasProperty('jctf_compile_only')) {
println "JCTF: compiling only"
systemProperty 'jctf_compile_only', '1'
}
if (project.hasProperty('test_dir')) {
systemProperty 'test_dir', project.property('test_dir')
}
if (project.hasProperty('r8lib')) {
dependsOn configureTestForR8Lib
// R8lib should be used instead of the main output and all the tests in
// r8 should be mapped and exists in r8LibTestPath.
classpath = sourceSets.test.runtimeClasspath.filter {
!it.getAbsolutePath().contains("/build/")
}
classpath += files([r8LibPath, r8LibTestPath])
testClassesDirs = files(r8LibTestPath)
}
if (OperatingSystem.current().isLinux()
|| OperatingSystem.current().isMacOsX()
|| OperatingSystem.current().isWindows()) {
if (OperatingSystem.current().isMacOsX()) {
logger.lifecycle("WARNING: Testing in only partially supported on Mac OS. " +
"Art only runs on Linux and tests requiring Art runs in a Docker container, which must be present. " +
"See tools/docker/README.md for details.")
}
if (OperatingSystem.current().isWindows()) {
logger.lifecycle("WARNING: Testing in only partially supported on Windows. " +
"Art only runs on Linux and tests requiring Art will be skipped")
}
dependsOn downloadDeps
dependsOn buildExamples
dependsOn buildKotlinR8TestResources
dependsOn buildSmali
dependsOn jctfCommonJar
dependsOn jctfTestsClasses
dependsOn buildDebugInfoExamplesDex
dependsOn buildPreNJdwpTestsJar
dependsOn buildPreNJdwpTestsDex
dependsOn buildJdk11TimeTestsJar
dependsOn provideArtFrameworksDependencies
} else {
logger.lifecycle("WARNING: Testing in not supported on your platform. Testing is only fully supported on " +
"Linux and partially supported on Mac OS and Windows. Art does not run on other platforms.")
}
}
// The Art tests we use for R8 are pre-build and downloaded from Google Cloud Storage.
//
// To build and upload a new set of the Art tests for use with R8 follow these steps:
//
// First of all an Android checkout is required. Currently it must be located
// in $HOME/android/master.
//
// TODO(ricow): simplify this
//
// Before: update the checked in art, see scripts/update-host-art.sh
//
// 1. Get an android checkout in $HOME/android/master and apply the patch from
// https://android-review.googlesource.com/#/c/294187/
//
// 2. run the following commands in the Android checkout directory:
//
// source build/envsetup.sh
// lunch aosp_angler-userdebug # or lunch aosp_angler-eng
// m desugar
// m -j30 test-art-host
// DESUGAR=false ANDROID_COMPILE_WITH_JACK=false art/test.py --host -t 001-HelloWorld
//
// Without running the test.py command the classes.jar file used by desugar in
// $HOME/android/master/out/host/common/obj/JAVA_LIBRARIES/core-oj-hostdex_intermediates/
// seems to be missing - there is probably also a make target to build it more directly
//
// 3. In the R8 project root directory, make sure we have a clean state before starting:
// tools/gradle.py downloadDeps
// tools/gradle.py clean
// rm -rf tests/art
//
// 4. Now build in the R8 checkout (-P hack to not generate dirs when not running this target)
// Make sure you have smali on your path, please use the build binary in the
// out/host/linux-x86/bin directory of the android checkout. Currently this is version pre 2.2.1,
// if that is updated the call to smali in "task "${smaliToDexTask}"(type: Exec)" below might
// need to change as smali got a completely new command line interface in version 2.2.1.
// After Android O, Jack is no longer alive, do not forget to uncomment call to buildArtTest for
// Jack if you build an android version using Jack.
//
// PATH=$HOME/android/master/out/host/linux-x86/bin:$PATH tools/gradle.py -Pandroid_source buildArtTests
//
// 4a. If any failures are produced in step 4, figure out what went wrong and add an entry in
// skippedTests with an explanation. Rerun from step 3.
//
// 5. Run the tests:
// tools/gradle.py clean
// tools/test.py
//
// 5a. If any more tests fail, either fix the issue or add them to the failuresToTriage list (note
// that you need to change "_" to "-" from stdout). Rerun from step 5 if anything was added to
// failuresToTriage.
//
// 6. To upload a new version to Google Cloud Storage:
// cd tests
// upload_to_google_storage.py -a --bucket r8-deps art
//
// 7. Update the manifest file describing the Android repo used:
// repo manifest -o <r8-checkout-root>/tools/linux/aosp_master_manifest.xml -r
def androidCheckoutDir = file("${System.env.HOME}/android/master")
def artTestDir = file("${androidCheckoutDir}/art/test")
if (project.hasProperty('android_source')) {
task buildArtTests {
outputs.upToDateWhen { false }
def toBeTriaged = [
"903-hello-tagging",
"904-object-allocation",
"905-object-free",
"906-iterate-heap",
"907-get-loaded-classes",
"908-gc-start-finish",
"954-invoke-polymorphic-verifier",
"955-methodhandles-smali",
"596-monitor-inflation",
]
def skippedTests = toBeTriaged + [
// This test produces no jar.
"000-nop",
// This does not build, as it tests the error when the application exceeds more
// than 65536 methods
"089-many-methods",
// Requires some jack beta jar
"956-methodhandles",
]
def skippedTestsDx = [
// Tests with custom build scripts, where javac is not passed the options
// -source 1.7 -target 1.7.
"462-checker-inlining-across-dex-files",
"556-invoke-super",
"569-checker-pattern-replacement",
// These tests use jack even when --build-with-javac-dx is specified.
"004-JniTest",
"048-reflect-v8",
"146-bad-interface",
"563-checker-invoke-super",
"580-checker-string-fact-intrinsics", // java.lang.StringFactory
"604-hot-static-interface",
"957-methodhandle-transforms",
"958-methodhandle-emulated-stackframe",
"959-invoke-polymorphic-accessors",
"961-default-iface-resolution-gen",
"962-iface-static",
"963-default-range-smali",
"964-default-iface-init-gen",
"965-default-verify",
"966-default-conflict",
"967-default-ame",
"968-default-partial-compile-gen",
"969-iface-super",
"970-iface-super-resolution-gen",
"971-iface-super",
// These tests does not build with --build-with-javac-dx
"004-NativeAllocations", // Javac error
"031-class-attributes",
"138-duplicate-classes-check",
"157-void-class", // Javac error
"580-checker-string-factory-intrinsics",
"612-jit-dex-cache",
"613-inlining-dex-cache",
"900-hello-plugin", // --experimental agents
"901-hello-ti-agent", // --experimental agents
"902-hello-transformation", // --experimental agents
"909-attach-agent", // --experimental agents
"946-obsolete-throw", // -source 1.7 -target 1.7, but use lambda
"950-redefine-intrinsic", // -source 1.7 -target 1.7, but use method references
"951-threaded-obsolete", // -source 1.7 -target 1.7, but use lambda
"960-default-smali", // --experimental default-methods
// These tests force the build to use jack
"953-invoke-polymorphic-compiler",
"958-methodhandle-stackframe",
]
def artTestBuildDir = file("${projectDir}/tests/art")
if (androidCheckoutDir.exists()) {
dependsOn downloadDeps
artTestBuildDir.mkdirs()
artTestDir.eachDir { dir ->
def name = dir.getName();
def markerFile = dir.toPath().resolve("info.txt").toFile();
if (markerFile.exists() && !(name in skippedTests)) {
if (!(name in skippedTestsDx)) {
dependsOn buildArtTest(androidCheckoutDir, artTestBuildDir, dir);
}
}
}
}
doFirst {
if (!androidCheckoutDir.exists()) {
throw new InvalidUserDataException(
"This task requires an Android checkout in ${androidCheckoutDir}");
}
}
doLast {
copy {
from file("${androidCheckoutDir}/out/host/linux-x86/nativetest64")
into file("${artTestBuildDir}/lib64")
include 'lib*.so'
}
copy {
from file("${androidCheckoutDir}/out/host/linux-x86/lib64")
into file("${artTestBuildDir}/lib64")
include 'libart.so'
include 'libbacktrace.so'
include 'libbase.so'
include 'libc++.so'
include 'libcutils.so'
include 'liblz4.so'
include 'liblzma.so'
include 'libnativebridge.so'
include 'libnativeloader.so'
include 'libsigchain.so'
include 'libunwind.so'
include 'libziparchive.so'
}
copy {
from file("${androidCheckoutDir}/out/host/linux-x86/nativetest")
into file("${artTestBuildDir}/lib")
include 'lib*.so'
}
copy {
from file("${androidCheckoutDir}/out/host/linux-x86/lib")
into file("${artTestBuildDir}/lib")
include 'libart.so'
include 'libbacktrace.so'
include 'libbase.so'
include 'libc++.so'
include 'libcutils.so'
include 'liblz4.so'
include 'liblzma.so'
include 'libnativebridge.so'
include 'libnativeloader.so'
include 'libsigchain.so'
include 'libunwind.so'
include 'libziparchive.so'
}
}
}
}
def buildArtTest(androidCheckoutDir, artTestBuildDir, dir) {
def artTestDir = file("${androidCheckoutDir}/art/test")
def artRunTestScript = file("${artTestDir}/run-test")
def dxExecutable = new File("tools/linux/dx/bin/dx");
def dexMergerExecutable = Utils.dexMergerExecutable()
def name = dir.getName()
def buildTask = "build_art_test_dx_${name}"
def sanitizeTask = "sanitize_art_test_dx_${name}"
def copyCheckTask = "copy_check_art_test_dx_${name}"
def smaliToDexTask = "smali_to_dex_dx_${name}"
def buildInputs = fileTree(dir: dir, include: '**/*')
def testDir = file("${artTestBuildDir}/dx/${name}")
def outputJar = testDir.toPath().resolve("${name}.jar").toFile()
testDir.mkdirs()
task "$buildTask"(type: Exec) {
outputs.upToDateWhen { false }
inputs.file buildInputs
executable "${artRunTestScript}"
args "--host"
args "--build-only"
args "--build-with-javac-dx"
args "--output-path", "${testDir}"
args "${name}"
environment DX: "${dxExecutable.absolutePath}"
environment DXMERGER: "${dexMergerExecutable.absolutePath}"
environment ANDROID_BUILD_TOP: "${androidCheckoutDir}"
outputs.file outputJar
}
task "${sanitizeTask}"(type: Exec, dependsOn: buildTask) {
outputs.upToDateWhen { false }
executable "/bin/bash"
args "-c"
args "rm -rf ${testDir}/smali_*.dex ${testDir}/*-ex.dex ${testDir}/*-ex.jar" +
" ${testDir}/classes-ex ${testDir}/check"
}
task "${smaliToDexTask}"(type: Exec) {
// Directory that contains smali files is either smali, or smali/art
def smali_dir = file("${dir}/smali/art")
if (smali_dir.exists()) {
workingDir "${testDir}/smali/art"
} else {
workingDir "${testDir}/smali"
}
executable "/bin/bash"
// This is the command line options for smali prior to 2.2.1, where smali got a new
// command line interface.
args "-c", "smali a *.smali"
// This is the command line options for smali 2.2.1 and later.
// args "-c", "smali -o out.dex *.smali"
}
task "${copyCheckTask}"(type: Copy, dependsOn: sanitizeTask) {
def smali_dir = file("${dir}/smali")
outputs.upToDateWhen { false }
if (smali_dir.exists()) {
dependsOn smaliToDexTask
}
from("${artTestDir}/${name}") {
include 'check'
}
into testDir
}
return copyCheckTask
}
task javadocD8(type: Javadoc) {
title "D8 API"
classpath = sourceSets.main.compileClasspath
source = sourceSets.main.allJava
include '**/com/android/tools/r8/ArchiveClassFileProvider.java'
include '**/com/android/tools/r8/ArchiveProgramResourceProvider.java'
include '**/com/android/tools/r8/BaseCommand.java'
include '**/com/android/tools/r8/BaseCompilerCommand.java'
include '**/com/android/tools/r8/ClassFileResourceProvider.java'
include '**/com/android/tools/r8/CompilationFailedException.java'
include '**/com/android/tools/r8/CompilationMode.java'
include '**/com/android/tools/r8/D8.java'
include '**/com/android/tools/r8/D8Command.java'
include '**/com/android/tools/r8/DexIndexedConsumer.java'
include '**/com/android/tools/r8/DexFilePerClassFileConsumer.java'
include '**/com/android/tools/r8/Diagnostic.java'
include '**/com/android/tools/r8/DiagnosticsHandler.java'
include '**/com/android/tools/r8/DirectoryClassFileProvider.java'
include '**/com/android/tools/r8/OutputMode.java'
include '**/com/android/tools/r8/ProgramConsumer.java'
include '**/com/android/tools/r8/ProgramResource.java'
include '**/com/android/tools/r8/ProgramResourceProvider.java'
include '**/com/android/tools/r8/Resource.java'
include '**/com/android/tools/r8/ResourceException.java'
include '**/com/android/tools/r8/StringConsumer.java'
include '**/com/android/tools/r8/StringResource.java'
include '**/com/android/tools/r8/Version.java'
include '**/com/android/tools/r8/origin/*.java'
}
task javadocR8(type: Javadoc) {
title "R8 API"
classpath = sourceSets.main.compileClasspath
source = sourceSets.main.allJava
include '**/com/android/tools/r8/ArchiveClassFileProvider.java'
include '**/com/android/tools/r8/ArchiveProgramResourceProvider.java'
include '**/com/android/tools/r8/BaseCommand.java'
include '**/com/android/tools/r8/BaseCompilerCommand.java'
include '**/com/android/tools/r8/ClassFileConsumer.java'
include '**/com/android/tools/r8/ClassFileResourceProvider.java'
include '**/com/android/tools/r8/CompilationFailedException.java'
include '**/com/android/tools/r8/CompilationMode.java'
include '**/com/android/tools/r8/R8.java'
include '**/com/android/tools/r8/R8Command.java'
include '**/com/android/tools/r8/DexIndexedConsumer.java'
include '**/com/android/tools/r8/Diagnostic.java'
include '**/com/android/tools/r8/DiagnosticsHandler.java'
include '**/com/android/tools/r8/DirectoryClassFileProvider.java'
include '**/com/android/tools/r8/OutputMode.java'
include '**/com/android/tools/r8/ProgramConsumer.java'
include '**/com/android/tools/r8/ProgramResource.java'
include '**/com/android/tools/r8/ProgramResourceProvider.java'
include '**/com/android/tools/r8/Resource.java'
include '**/com/android/tools/r8/ResourceException.java'
include '**/com/android/tools/r8/StringConsumer.java'
include '**/com/android/tools/r8/StringResource.java'
include '**/com/android/tools/r8/Version.java'
include '**/com/android/tools/r8/origin/*.java'
}
task copyMavenDeps(type: Copy) {
from configurations.compile into "$buildDir/deps"
from configurations.compileClasspath into "$buildDir/deps"
from configurations.testCompile into "$buildDir/deps"
}
task printMavenDeps {
// Only actually print to stdout when we are updating.
if (project.hasProperty('updatemavendeps')) {
for (Configuration config : configurations) {
if (!config.isCanBeResolved()) {
continue
}
def componentIds = config.incoming.resolutionResult.allDependencies.collect {
it.selected.id
}
def result = dependencies.createArtifactResolutionQuery()
.forComponents(componentIds)
.withArtifacts(MavenModule, MavenPomArtifact)
.execute()
for (component in result.resolvedComponents) {
component.getArtifacts(MavenPomArtifact).each {
println "POM: ${it.file} ${component.id}"
}
}
config.each {
println "JAR: ${it}"
}
}
}
}
allprojects {
tasks.withType(Exec) {
doFirst {
println commandLine.join(' ')
}
}
}