build.gradle

// 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 net.ltgt.gradle.errorprone.ErrorProneToolChain
import org.gradle.internal.os.OperatingSystem
import tasks.GetJarsFromConfiguration
import utils.Utils

apply plugin: 'java'
apply plugin: 'idea'
apply plugin: 'com.google.protobuf'
apply plugin: 'com.cookpad.android.licensetools'
apply plugin: 'net.ltgt.errorprone-base'
apply plugin: "net.ltgt.apt"

// 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 {
    module {
        outputDir file('build/classes/main')
        testOutputDir file('build/classes/test')
    }
}

ext {
    androidSupportVersion = '25.4.0'
    apacheCommonsVersion = '1.12'
    asmVersion = '6.0'
    autoValueVersion = '1.5'
    espressoVersion = '3.0.0'
    fastutilVersion = '7.2.0'
    guavaVersion = '23.0'
    joptSimpleVersion = '4.6'
    jsonSimpleVersion = '1.1'
    junitVersion = '4.12'
    kotlinVersion = '1.2.30'
    protobufVersion = '3.0.0'
    smaliVersion = '2.2b4'
}

def errorProneConfiguration = [
    '-XepDisableAllChecks',
    // D8 want to use reference equality, thus disable the checker explicitly
    '-Xep:ReferenceEquality:OFF',
    '-Xep:ClassCanBeStatic:ERROR',
    '-Xep:OperatorPrecedence:ERROR',
    '-Xep:RemoveUnusedImports:ERROR',
    '-Xep:MissingOverride:ERROR',
    '-Xep:IntLongMath:ERROR',
    '-Xep:EqualsHashCode:ERROR',
    '-Xep:InconsistentOverloads:ERROR',
    '-Xep:ArrayHashCode:ERROR',
    '-Xep:EqualsIncompatibleType:ERROR',
    '-Xep:NonOverridingEquals:ERROR',
    '-Xep:FallThrough:ERROR',
    '-Xep:MissingCasesInEnumSwitch:ERROR',
    '-Xep:MissingDefault:ERROR',
    '-Xep:MultipleTopLevelClasses:ERROR',
    '-Xep:NarrowingCompoundAssignment:ERROR',
    '-Xep:BoxedPrimitiveConstructor:ERROR']

apply from: 'copyAdditionalJctfCommonFiles.gradle'


if (project.hasProperty('with_code_coverage')) {
    apply plugin: 'jacoco'
}

repositories {
    maven { url 'https://maven.google.com' }
    mavenCentral()
}

buildscript {
    repositories {
        mavenCentral()
        jcenter()
        maven {
            url "https://plugins.gradle.org/m2/"
        }
    }
    dependencies {
        classpath 'com.google.protobuf:protobuf-gradle-plugin:0.8.1'
        classpath 'com.cookpad.android.licensetools:license-tools-plugin:0.23.0'
        classpath 'com.github.jengelman.gradle.plugins:shadow:2.0.3'
        classpath "net.ltgt.gradle:gradle-errorprone-plugin:0.0.13"
        classpath "net.ltgt.gradle:gradle-apt-plugin:0.12"
    }
}

// Custom source set for example tests and generated tests.
sourceSets {
    test {
        java {
            srcDirs = [
                'src/test/java',
                'build/generated/test/java',
            ]
        }
    }
    bsPatch {
        java {
            srcDirs = [
                'src/bspatch/java',
                'src/main/java'
            ]
        }
    }
    apiUsageSample {
        java {
            srcDirs = ['src/test/apiUsageSample']
        }
        output.resourcesDir = 'build/classes/apiUsageSample'
    }
    debugTestResources {
        java {
            srcDirs = ['src/test/debugTestResources']
        }
        output.resourcesDir = 'build/classes/debugTestResources'
    }
    debugTestResourcesJava8 {
        java {
            srcDirs = ['src/test/debugTestResourcesJava8']
        }
        output.resourcesDir = 'build/classes/debugTestResourcesJava8'
    }
    debugTestResourcesKotlin {
        java {
            srcDirs = ['src/test/debugTestResourcesKotlin']
        }
        output.resourcesDir = 'build/classes/debugTestResourcesKotlin'
    }
    examples {
        java {
            srcDirs = ['src/test/examples', 'build/generated/source/proto/examples/javalite/' ]
        }
        proto {
            srcDirs = [
                    'src/test/examples',
            ]
        }
        output.resourcesDir = 'build/classes/examples'
    }
    examplesKotlin {
        java {
            srcDirs = ['src/test/examplesKotlin']
        }
        output.resourcesDir = 'build/classes/examplesKotlin'
    }
    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'
    }
    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'
    }
}

configurations {
    supportLibs
}

dependencies {
    compile "net.sf.jopt-simple:jopt-simple:$joptSimpleVersion"
    compile "com.googlecode.json-simple:json-simple:$jsonSimpleVersion"
    // 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")
    compile("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'
    })
    compile group: 'it.unimi.dsi', name: 'fastutil', version: fastutilVersion
    compile group: 'org.ow2.asm', name: 'asm', version: asmVersion
    compile group: 'org.ow2.asm', name: 'asm-commons', version: asmVersion
    compile group: 'org.ow2.asm', name: 'asm-tree', version: asmVersion
    compile group: 'org.ow2.asm', name: 'asm-analysis', version: asmVersion
    compile group: 'org.ow2.asm', name: 'asm-util', version: asmVersion
    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')
    bsPatchCompile "org.apache.commons:commons-compress:$apacheCommonsVersion"
    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 "com.google.protobuf:protobuf-lite:$protobufVersion"
    examplesCompileOnly "com.google.auto.value:auto-value:$autoValueVersion"
    examplesRuntime "com.google.protobuf:protobuf-lite:$protobufVersion"
    supportLibs "com.android.support:support-v4:$androidSupportVersion"
    supportLibs "junit:junit:$junitVersion"
    supportLibs "com.android.support.test.espresso:espresso-core:$espressoVersion"
    apiUsageSampleCompile sourceSets.main.output
    debugTestResourcesKotlinCompileOnly "org.jetbrains.kotlin:kotlin-stdlib:$kotlinVersion"
    examplesKotlinCompileOnly "org.jetbrains.kotlin:kotlin-stdlib:$kotlinVersion"
    kotlinR8TestResourcesCompileOnly "org.jetbrains.kotlin:kotlin-stdlib:$kotlinVersion"
    apt "com.google.auto.value:auto-value:$autoValueVersion"
}

configurations.bsPatchCompile.extendsFrom configurations.compile

licenseTools {
    licensesYaml = file('LIBRARY-LICENSE')
}

protobuf {
    protoc {
        // Download from repositories
        artifact = "com.google.protobuf:protoc:$protobufVersion"
    }
    plugins {
        javalite {
            artifact = "com.google.protobuf:protoc-gen-javalite:$protobufVersion"
        }
    }
    generateProtoTasks {
        all().each { task ->
            task.builtins {
                // Disable the java code generator, as we want javalite only.
                remove java
            }
            task.plugins {
                javalite {}
            }
        }
    }
}

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_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",
                "proguard/proguard5.2.1",
                "proguard/proguard6.0.1",
                "gradle/gradle",
                "jdwp-tests",
                "jasmin",
                "jctf",
                "kotlin",
                "android_cts_baseline",
                "ddmlib",
                "core-lambda-stubs",
                "openjdk/openjdk-rt-1.8",
                "r8",
        ],
        // 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/dalvik",
                "linux/dalvik-4.0.4",
                "${osString}/dx",
        ]
]

cloudDependencies.each { entry ->
    entry.value.each { entryFile ->
        task "download_deps_${entry.key}/${entryFile}"(type: Exec) {
            def outputDir = "${entry.key}/${entryFile}"
            def gzFile = "${outputDir}.tar.gz"
            def sha1File = "${gzFile}.sha1"
            inputs.file sha1File
            outputs.file gzFile
            outputs.dir outputDir
            List<String> dlFromStorageArgs = ["-n", "-b", "r8-deps", "-u", "-s", "${sha1File}"]
            if (OperatingSystem.current().isWindows()) {
                executable "download_from_google_storage.bat"
                args dlFromStorageArgs
            } else {
                executable "bash"
                args "-c", "download_from_google_storage " + String.join(" ", dlFromStorageArgs)
            }
        }
    }
}

def x20Dependencies = [
    "third_party": [
        "gmail/gmail_android_170604.16",
        "gmscore/v4",
        "gmscore/v5",
        "gmscore/v6",
        "gmscore/v7",
        "gmscore/v8",
        "gmscore/gmscore_v9",
        "gmscore/gmscore_v10",
        "gmscore/latest",
        "photos/2017-06-06",
        "youtube/youtube.android_12.10",
        "youtube/youtube.android_12.17",
        "youtube/youtube.android_12.22",
        "proguardsettings",
        "proguard/proguard_internal_159423826",
        "framework",
        "goyt",
        "desugar/desugar_20180308"
    ],
]

x20Dependencies.each { entry ->
    entry.value.each { entryFile ->
        task "download_deps_${entry.key}/${entryFile}"(type: Exec) {
            def outputDir = "${entry.key}/${entryFile}"
            def gzFile = "${outputDir}.tar.gz"
            def sha1File = "${gzFile}.sha1"
            inputs.file sha1File
            outputs.file gzFile
            outputs.dir outputDir
            executable "bash"
            args "-c", "tools/download_from_x20.py ${sha1File}"
        }
    }
}

task downloadProguard {
    cloudDependencies.each { entry ->
        entry.value.each { entryFile ->
            if (entryFile.contains("proguard")) {
                dependsOn "download_deps_${entry.key}/${entryFile}"
            }
        }
    }
}

task downloadDx {
    cloudDependencies.each { entry ->
        entry.value.each { entryFile ->
            if (entryFile.endsWith("/dx")) {
                dependsOn "download_deps_${entry.key}/${entryFile}"
            }
        }
    }
}

task downloadAndroidCts {
    cloudDependencies.each { entry ->
        entry.value.each { entryFile ->
            if (entryFile.contains("android_cts_baseline")) {
                dependsOn "download_deps_${entry.key}/${entryFile}"
            }
        }
    }
}

task downloadDeps {
    cloudDependencies.each { entry ->
        entry.value.each { entryFile ->
            dependsOn "download_deps_${entry.key}/${entryFile}"
        }
    }
    if (!project.hasProperty('no_internal')) {
        x20Dependencies.each { entry ->
            entry.value.each { entryFile ->
                dependsOn "download_deps_${entry.key}/${entryFile}"
            }
        }
    }
}

allprojects {
    sourceCompatibility = JavaVersion.VERSION_1_8
    targetCompatibility = JavaVersion.VERSION_1_8
}

tasks.withType(JavaCompile) {
    options.compilerArgs << '-Xlint:unchecked'
}

if (!project.hasProperty('without_error_prone')) {
    compileJava {
        // Enable error prone for D8/R8 sources.
        toolChain ErrorProneToolChain.create(project)
        options.compilerArgs += errorProneConfiguration
    }
}

compileJctfCommonJava {
    dependsOn 'copyAdditionalJctfCommonFiles'
    options.compilerArgs = ['-Xlint:none']
}

compileJctfTestsJava {
    dependsOn 'jctfCommonClasses'
    options.compilerArgs = ['-Xlint:none']
}

task consolidatedLicense {
    // checkLicenses verifies that the list of libraries referenced in 'LIBRARY-LICENSE' is
    // corresponding to the effective list of embedded libraries.
    dependsOn 'checkLicenses'
    def license = new File(new File(buildDir, 'generatedLicense'), 'LICENSE')
    inputs.files files('LICENSE', 'LIBRARY-LICENSE') + fileTree(dir: 'library-licensing')
    outputs.files license
    doLast {
        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 += file('LIBRARY-LICENSE').text
        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 configureRelocations(ShadowJar task) {
    task.relocate('com.google.common', 'com.android.tools.r8.com.google.common')
    task.relocate('com.google.thirdparty', 'com.android.tools.r8.com.google.thirdparty')
    task.relocate('joptsimple', 'com.android.tools.r8.joptsimple')
    task.relocate('org.apache.commons', 'com.android.tools.r8.org.apache.commons')
    task.relocate('org.objectweb.asm', 'com.android.tools.r8.org.objectweb.asm')
    task.relocate('org.json.simple', 'com.android.tools.r8.org.json.simple')
    task.relocate('it.unimi.dsi.fastutil', 'com.android.tools.r8.it.unimi.dsi.fastutil')
}

task repackageDeps(type: ShadowJar) {
    configurations = [project.configurations.compile]
    configureRelocations(it)
    baseName 'deps'
}

task repackageSources(type: ShadowJar) {
    from sourceSets.main.output
    configureRelocations(it)
    baseName 'sources'
}

task R8(type: ShadowJar) {
    from consolidatedLicense.outputs.files
    exclude { path ->
      path.getRelativePath().getPathString().startsWith("META-INF")
    }
    baseName 'r8'
    classifier = null
    version = null
    manifest {
        attributes 'Main-Class': 'com.android.tools.r8.R8'
    }
    // In order to build without dependencies, pass the exclude_deps property using:
    // gradle -Pexclude_deps R8
    if (!project.hasProperty('exclude_deps')) {
        from repackageSources.outputs.files
        from repackageDeps.outputs.files
    } else {
        from sourceSets.main.output
    }
}

task D8(type: ShadowJar) {
    from consolidatedLicense.outputs.files
    exclude { path ->
      path.getRelativePath().getPathString().startsWith("META-INF")
    }
    baseName 'd8'
    classifier = null
    version = null
    manifest {
        attributes 'Main-Class': 'com.android.tools.r8.D8'
    }
    // In order to build without dependencies, pass the exclude_deps property using:
    // gradle -Pexclude_deps D8
    if (!project.hasProperty('exclude_deps')) {
        from repackageSources.outputs.files
        from repackageDeps.outputs.files
    } else {
        from sourceSets.main.output
    }
}

task CompatDx(type: Jar) {
    from sourceSets.main.output
    baseName 'compatdx'
    manifest {
      attributes 'Main-Class': 'com.android.tools.r8.compatdx.CompatDx'
    }
    // In order to build without dependencies, pass the exclude_deps property using:
    // gradle -Pexclude_deps CompatDx
    if (!project.hasProperty('exclude_deps')) {
        // Also include dependencies
        from { configurations.compile.collect { it.isDirectory() ? it : zipTree(it) } }
    }
}

task DexFileMerger(type: Jar) {
    from sourceSets.main.output
    baseName 'dexfilemerger'
    manifest {
      attributes 'Main-Class': 'com.android.tools.r8.dexfilemerger.DexFileMerger'
    }
    // In order to build without dependencies, pass the exclude_deps property using:
    // gradle -Pexclude_deps CompatDx
    if (!project.hasProperty('exclude_deps')) {
        // Also include dependencies
        from { configurations.compile.collect { it.isDirectory() ? it : zipTree(it) } }
    }
}

task DexSplitter(type: Jar) {
    from sourceSets.main.output
    baseName 'dexsplitter'
    manifest {
      attributes 'Main-Class': 'com.android.tools.r8.dexsplitter.DexSplitter'
    }
    // In order to build without dependencies, pass the exclude_deps property using:
    // gradle -Pexclude_deps CompatDx
    if (!project.hasProperty('exclude_deps')) {
        // Also include dependencies
        from { configurations.compile.collect { it.isDirectory() ? it : zipTree(it) } }
    }
}

task CompatProguard(type: Jar) {
    from sourceSets.main.output
    baseName 'compatproguard'
    manifest {
        attributes 'Main-Class': 'com.android.tools.r8.compatproguard.CompatProguard'
    }
    // In order to build without dependencies, pass the exclude_deps property using:
    // gradle -Pexclude_deps CompatProguard
    if (!project.hasProperty('exclude_deps')) {
        // Also include dependencies
        from { configurations.compile.collect { it.isDirectory() ? it : zipTree(it) } }
    }
}

task D8Logger(type: Jar) {
    from sourceSets.main.output
    baseName 'd8logger'
    manifest {
      attributes 'Main-Class': 'com.android.tools.r8.D8Logger'
    }
    // In order to build without dependencies, pass the exclude_deps property using:
    // gradle -Pexclude_deps D8Logger
    if (!project.hasProperty('exclude_deps')) {
        // Also include dependencies
        from { configurations.compile.collect { it.isDirectory() ? it : zipTree(it) } }
    }
}

task disasm(type: Jar) {
    from sourceSets.main.output
    baseName 'disasm'
    manifest {
        attributes 'Main-Class': 'com.android.tools.r8.Disassemble'
    }
    // In order to build without dependencies, pass the exclude_deps property using:
    // gradle -Pexclude_deps D8
    if (!project.hasProperty('exclude_deps')) {
        // Also include dependencies
        from { configurations.compile.collect { it.isDirectory() ? it : zipTree(it) } }
    }
}

task bisect(type: Jar) {
    from sourceSets.main.output
    baseName 'bisect'
    manifest {
      attributes 'Main-Class': 'com.android.tools.r8.bisect.Bisect'
    }
    // In order to build without dependencies, pass the exclude_deps property using:
    // gradle -Pexclude_deps R8
    if (!project.hasProperty('exclude_deps')) {
        // Also include dependencies
        from { configurations.compile.collect { it.isDirectory() ? it : zipTree(it) } }
    }
}

task DexSegments(type: Jar) {
    from sourceSets.main.output
    baseName 'dexsegments'
    manifest {
      attributes 'Main-Class': 'com.android.tools.r8.DexSegments'
    }
    // In order to build without dependencies, pass the exclude_deps property using:
    // gradle -Pexclude_deps DexSegments
    if (!project.hasProperty('exclude_deps')) {
        // Also include dependencies
        from { configurations.compile.collect { it.isDirectory() ? it : zipTree(it) } }
    }
}

task maindex(type: Jar) {
    from sourceSets.main.output
    baseName 'maindex'
    manifest {
      attributes 'Main-Class': 'com.android.tools.r8.GenerateMainDexList'
    }
    // In order to build without dependencies, pass the exclude_deps property using:
    // gradle -Pexclude_deps maindex
    if (!project.hasProperty('exclude_deps')) {
        // Also include dependencies
        from { configurations.compile.collect { it.isDirectory() ? it : zipTree(it) } }
    }
}

task ExtractMarker(type: Jar) {
    from sourceSets.main.output
    baseName 'extractmarker'
    manifest {
      attributes 'Main-Class': 'com.android.tools.r8.ExtractMarker'
    }
    // In order to build without dependencies, pass the exclude_deps property using:
    // gradle -Pexclude_deps ExtractMarker
    if (!project.hasProperty('exclude_deps')) {
        // Also include dependencies
        from { configurations.compile.collect { it.isDirectory() ? it : zipTree(it) } }
    }
}

task bspatch(type: Jar) {
    from sourceSets.bsPatch.output
    baseName 'bspatch'
    manifest {
        attributes 'Main-Class': 'com.android.tools.r8.dex.BSPatch'
    }
    // In order to build without dependencies, pass the exclude_deps property using:
    // gradle -Pexclude_deps maindex
    if (!project.hasProperty('exclude_deps')) {
        // Also include dependencies
        from {
            configurations.bsPatchCompile.collect { it.isDirectory() ? it : zipTree(it) }
        }
    }
}

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.file "tests/2017-10-04/art.tar.gz"
    inputs.file 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 buildD8ApiUsageSample(type: Jar) {
    from sourceSets.apiUsageSample.output
    baseName 'd8_api_usage_sample'
    destinationDir file('tests')
}

task buildR8ApiUsageSample(type: Jar) {
    from sourceSets.apiUsageSample.output
    baseName 'r8_api_usage_sample'
    destinationDir file('tests')
}

task buildApiSampleJars {
    dependsOn buildD8ApiUsageSample
    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.file file("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"
    }
    def kotlinResourcesDir = file("src/test/debugTestResourcesKotlin")
    def kotlinHostJar = "debug_test_resources_kotlin.jar"
    task "jar_debugTestResourcesKotlin"(type: kotlin.Kotlinc) {
        source = fileTree(dir: kotlinResourcesDir, include: '**/*.kt')
        destination = file("build/test/${kotlinHostJar}")
    }
    dependsOn downloadDeps
    dependsOn jar_debugTestResources
    dependsOn jar_debugTestResourcesJava8
    dependsOn jar_debugTestResourcesKotlin
}

// 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 buildExampleKotlinJars {
    def kotlinSrcDir = file("src/test/examplesKotlin")
    kotlinSrcDir.eachDir { dir ->
        def name = dir.getName();
        dependsOn "compile_example_kotlin_${name}"
        task "compile_example_kotlin_${name}"(type: kotlin.Kotlinc) {
            source = fileTree(dir: file("src/test/examplesKotlin/${name}"), include: '**/*.kt')
            destination = file("build/test/examplesKotlin/${name}.jar")
        }
    }
}

// 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 protoSourceDir = file("build/generated/source/proto/examples/javalite")
    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 "compile_examples"(type: JavaCompile, dependsOn: "generateExamplesProto") {
        source examplesDir, protoSourceDir
        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, dependsOn: "generateExamplesProto") {
        source examplesDir, protoSourceDir
        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, dependsOn: "generateExamplesProto") {
        source examplesDir, protoSourceDir
        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 { }
        if (!fileTree(dir: dir, include: '**/*.proto').empty) {
            // If we have any proto use, we have to include those classes and the runtime.
            runtimeDependencies = copySpec {
                from "$buildDir/runtime/examples/"
                include "com/google/protobuf/**/*.class"
            }
        }
        // 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 tasks.getByPath("pre_proguard_example_${name}")
                inputs.file  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 + "/**/*.class"
                with runtimeDependencies
                includeEmptyDirs false
            }
            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*"
        }
    }
}

task buildExampleJava9Jars {
    def examplesDir = file("src/test/examplesJava9")
    examplesDir.eachDir { dir ->
        def name = dir.getName();
        def exampleOutputDir = file("build/test/examplesJava9");
        def jarName = "${name}.jar"
        dependsOn "jar_examplesJava9_${name}"
        task "jar_examplesJava9_${name}"(type: Jar) {
            archiveName = jarName
            destinationDir = exampleOutputDir
            from "src/test/examplesJava9"  // Java 1.9 classes
            include "**/" + name + "/**/*.class"
        }
    }
}

task buildExamplesKotlin {
    if (OperatingSystem.current().isMacOsX() || OperatingSystem.current().isWindows()) {
        logger.lifecycle("WARNING: Testing (including building kotlin examples) is only partially" +
                " supported on your platform (" + OperatingSystem.current().getName() + ").")
    } else if (!OperatingSystem.current().isLinux()) {
        logger.lifecycle("WARNING: Testing (including building kotlin examples) is not supported " +
                "on your platform. It is fully supported on Linux and partially supported on " +
                "Mac OS and Windows")
        return;
    }
    def examplesDir = file("src/test/examplesKotlin")
    examplesDir.eachDir { dir ->
        def name = dir.getName();
        dependsOn "dex_example_kotlin_${name}"
        def exampleOutputDir = file("build/test/examplesKotlin/" + name);
        def dexPath = file("${exampleOutputDir}")
        task "dex_example_kotlin_${name}"(type: dx.Dx,
                dependsOn: "compile_example_kotlin_${name}") {
            doFirst {
                if (!dexPath.exists()) {
                    dexPath.mkdirs()
                }
            }
            source = files(tasks.getByPath("compile_example_kotlin_${name}")).asFileTree
            destination = dexPath
            debug = false
        }
    }
}

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 outputFile = "build/test/kotlinR8TestResources/${kotlinTargetVersion}/${name}.jar"
            def javaOutput = "build/test/kotlinR8TestResources/${kotlinTargetVersion}/${name}/java"
            def javaOutputJarName = "${name}.java.jar"
            def javaOutputJarDir = "build/test/kotlinR8TestResources/${kotlinTargetVersion}"
            task "${taskName}Kotlin"(type: kotlin.Kotlinc) {
                source = fileTree(dir: file("${examplesDir}/${name}"),
                        include: ['**/*.kt', '**/*.java'])
                destination = file(outputFile)
                targetVersion = 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}Kotlin", "${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 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: dx.Dx, 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('/', '_')}"
        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: smali.Smali) {
                    source = smaliFiles
                    destination = destFile
                }
            }
        } else {
            dependsOn "${taskName}_dexmerger"
            task "${taskName}_smali"(type: smali.Smali) {
                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: dx.Dx, dependsOn: "${taskName}_jar") {
                source = fileTree(dir: destDir, include: 'Test.jar')
                destination = destDir
            }
            task "${taskName}_dexmerger"(
                    type: dx.DexMerger, dependsOn: ["${taskName}_dx", "${taskName}_smali"]) {
                source = fileTree(dir: destDir, include: ["classes.dex", intermediateFileName])
                destination = destFile
            }
        }
    }
}

tasks.withType(Test) {
    def userDefinedCoresPerFork = System.getenv('R8_GRADLE_CORES_PER_FORK')
    def coresPerFork = userDefinedCoresPerFork ? userDefinedCoresPerFork.toInteger() : 3
    // See https://docs.gradle.org/current/dsl/org.gradle.api.tasks.testing.Test.html.
    maxParallelForks = Runtime.runtime.availableProcessors().intdiv(coresPerFork) ?: 1
    forkEvery = 0
    // Use the Concurrent Mark Sweep GC (CMS) to keep memory usage at a resonable level.
    jvmArgs = ["-XX:+UseConcMarkSweepGC"]
    if (project.hasProperty('disable_assertions')) {
        enableAssertions = false
    }
}

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.file 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 AospJarTest(type: Exec) {
    dependsOn CompatDx, downloadDeps
    def script = "tools/test_aosp_jar.py"
    inputs.file script
    commandLine "python", script, "--no-build"
    workingDir = projectDir
}

test {
    dependsOn getJarsFromSupportLibs
    testLogging.exceptionFormat = 'full'
    if (project.hasProperty('print_test_stdout')) {
        testLogging.showStandardStreams = true
    }
    if (project.hasProperty('dex_vm') && project.property('dex_vm') != 'default') {
        println "Running with non default vm: " + project.property('dex_vm')
        systemProperty 'dex_vm', project.property('dex_vm')
        if (project.property('dex_vm').startsWith('4.4.4') ||
            project.property('dex_vm').startsWith('5.1.1') ||
            project.property('dex_vm').startsWith('6.0.1')) {
            // R8 and D8 compute the dex file version number based on the input.
            // Jack generates dex files with version 37 which art 5.1.1 and 6.0.1 will not run.
            // Therefore we skip the jack generated art tests with those art versions.
            exclude "com/android/tools/r8/art/jack/**"
        }
    }

    if (project.hasProperty('one_line_per_test')) {
        beforeTest { desc ->
            println "Start executing test ${desc.name} [${desc.className}]"
        }
        afterTest { desc, result ->
            println "Done executing test ${desc.name} [${desc.className}] with result: ${result.resultType}"
        }
    }
    if (project.hasProperty('no_internal')) {
        exclude "com/android/tools/r8/internal/**"
    }
    if (project.hasProperty('only_internal')) {
        include "com/android/tools/r8/internal/**"
    }
    if (project.hasProperty('tool')) {
        if (project.property('tool') == 'r8') {
            exclude "com/android/tools/r8/art/*/d8/**"
            exclude "com/android/tools/r8/jctf/d8/**"
        } else {
            assert(project.property('tool') == 'd8')
            exclude "com/android/tools/r8/art/*/r8/**"
            exclude "com/android/tools/r8/jctf/r8/**"
        }
    }
    if (!project.hasProperty('all_tests')) {
        exclude "com/android/tools/r8/art/dx/**"
        exclude "com/android/tools/r8/art/jack/**"
    }
    // TODO(tamaskenez) enable jctf on all_tests when consolidated
    if (!project.hasProperty('jctf') && !project.hasProperty('only_jctf')) {
        exclude "com/android/tools/r8/jctf/**"
    }
    if (project.hasProperty('only_jctf')) {
        include "com/android/tools/r8/jctf/**"
    }
    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('aosp_jar')) {
        dependsOn AospJarTest
    }

    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 buildExamplesKotlin
        dependsOn buildKotlinR8TestResources
        dependsOn buildSmali
        dependsOn jctfCommonJar
        dependsOn jctfTestsClasses
        dependsOn buildDebugInfoExamplesDex
        dependsOn buildPreNJdwpTestsJar
        dependsOn buildPreNJdwpTestsDex
    } 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

enum DexTool {
    JACK,
    DX
}

def androidCheckoutDir = file("${System.env.HOME}/android/master")
def androidCheckoutJack = file("${androidCheckoutDir}/out/host/linux-x86/bin/jack");
def androidCheckoutJackServer = file("${androidCheckoutDir}/out/host/linux-x86/bin/jack-admin");

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()
            // Ensure Jack server is running.
            "${androidCheckoutJackServer} start-server".execute()
            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, DexTool.DX);
                    }
                    // After Android O, Jack is no longer alive
                    //dependsOn buildArtTest(androidCheckoutDir, artTestBuildDir, dir, DexTool.JACK);
                }
            }
        }
        doFirst {
            if (!androidCheckoutDir.exists()) {
                throw new InvalidUserDataException(
                        "This task requires an Android checkout in ${androidCheckoutDir}");
            } else if (!androidCheckoutJack.exists() ||
                    !androidCheckoutJackServer.exists()) {
                throw new InvalidUserDataException(
                        "This task requires that tools for host testing have been build in the " +
                                "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, dexTool) {
    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 dexToolName = dexTool == DexTool.DX ? "dx" : "jack"

    def name = dir.getName()
    def buildTask = "build_art_test_${dexToolName}_${name}"
    def sanitizeTask = "sanitize_art_test_${dexToolName}_${name}"
    def copyCheckTask = "copy_check_art_test_${dexToolName}_${name}"
    def smaliToDexTask = "smali_to_dex_${dexToolName}_${name}"

    def buildInputs = fileTree(dir: dir, include: '**/*')
    def testDir = file("${artTestBuildDir}/${dexToolName}/${name}")
    def outputJar = testDir.toPath().resolve("${name}.jar").toFile()
    testDir.mkdirs()
    if (dexTool == DexTool.DX) {
        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
        }
    } else {
        assert dexTool == DexTool.JACK
        def javaLibs = "${androidCheckoutDir}/out/host/common/obj/JAVA_LIBRARIES"
        def jackClasspath = "${javaLibs}/core-libart-hostdex_intermediates/classes.jack:" +
                "${javaLibs}/core-oj-hostdex_intermediates/classes.jack"
        task "$buildTask"(type: Exec) {
            outputs.upToDateWhen { false }
            inputs.file buildInputs
            executable "${artRunTestScript}"
            args "--host"
            args "--build-only"
            args "--output-path", "${testDir}"
            args "${name}"
            environment JACK: "${androidCheckoutDir}/out/host/linux-x86/bin/jack"
            environment JACK_CLASSPATH: jackClasspath
            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() && dexTool == DexTool.DX) {
            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.testCompile into "$buildDir/deps"
}

// This task allows to build class files from Java 9 source in order to use them as inputs of
// D8/R8 tests. Class files are generated in the same place than source files and must be commited
// to the D8 repository because there is no way to generate them on all computers due to the need of
// Java 9.
// Use the following command to rebuild class files of tests:
// ./tools/gradle.py -Pjava9Home=<java 9 home> buildJava9Tests
task buildJava9Tests {
    def javacOutputFolder = getTemporaryDir();
    def examplesDir = file("src/test/examplesJava9")

    task "compile_Java9examples"(type: JavaCompile) {
        doFirst {
            if (!project.hasProperty('java9Home') || project.property('java9Home').isEmpty()) {
                throw new GradleException("Set java9Home property.")
            }
        }

        source = fileTree(dir: examplesDir, include: '**/*.java')
        destinationDir = javacOutputFolder
        classpath = sourceSets.main.compileClasspath
        options.compilerArgs += ["-Xlint:-options"]
        sourceCompatibility = JavaVersion.VERSION_1_9
        targetCompatibility = JavaVersion.VERSION_1_9
        options.fork = true

        if (project.hasProperty('java9Home')) {
            options.forkOptions.javaHome = file(getProperty('java9Home'))
        }

        doLast {
            def classfileFrom = copySpec {
                from javacOutputFolder
                include "**/*.class"
            }
            copy {
                into examplesDir
                with classfileFrom
            }
            delete javacOutputFolder
        }
    }

    dependsOn compile_Java9examples
}