build.gradle

/// Why doesn't this work on Travis under Java 7?
/// The same text does in Randoop's build.gradle file.
// plugins {
//   /*
//    * Plugin that applies Google-Java-format to the Java files in the project.
//    * https://github.com/sherter/google-java-format-gradle-plugin
//    */
//   id 'com.github.sherter.google-java-format' version '0.6'
// }
plugins {
    id 'com.github.johnrengelman.shadow' version '2.0.4'
}

apply plugin: 'java'

// Note:  For this setup to work you must follow the instructions outlined in the
//       checker manual Section 25.3 "Building from Source"
// http://types.cs.washington.edu/checker-framework/current/checkers-manual.html#build-source

ext {
    assert JavaVersion.current() == JavaVersion.VERSION_1_8: "Set JAVA_HOME to JDK 8. Current version is ${JavaVersion.current()}"
    jsr308 = System.getenv('JSR308') ?: file(new File("..")).absolutePath
    checkerFrameworkPath = System.getenv('CHECKERFRAMEWORK') ?: "${jsr308}/checker-framework"
    checkerJar = "${checkerFrameworkPath}/checker/dist/checker.jar"
    afu = "${jsr308}/annotation-tools/annotation-file-utilities"
    z3Jar = "${projectDir}/lib/com.microsoft.z3.jar"
    lingelingTar = "${projectDir}/lib/lingeling.tar.gz"
    dljcScript = "${jsr308}/do-like-javac/dljc"
}

println '===================================='
println '    Checker Framework Inference     '
println '===================================='
println ''
println '-------------------------------'
println 'Important Environment Variables'
println '-------------------------------'
println 'JSR308          : ' + jsr308
println 'CHECKERFRAMEWORK: ' + checkerFrameworkPath

repositories {
    jcenter()
    mavenCentral()
}

dependencies {

    compile files("${checkerJar}")
    compile 'org.plumelib:options:0.3.1'
    // Serialize constraints
    compile 'com.googlecode.json-simple:json-simple:1.1'
    // Pretty print serialized constraints
    compile 'com.google.code.gson:gson:1.7.2'

    compile 'org.ow2.sat4j:org.ow2.sat4j.core:2.3.4'
    compile 'org.ow2.sat4j:org.ow2.sat4j.maxsat:2.3.4'
    compile files(z3Jar)

    testCompile fileTree(dir: "${checkerFrameworkPath}/framework-test/build/libs", include: "framework-test-*.jar")
    // Mocking library. Used in a couple tests
    testCompile 'org.mockito:mockito-all:2.0.2-beta'
    testCompile 'junit:junit:4.12'
}

sourceSets {
    main {
        java {
            srcDirs = ["src"]
        }

        resources {
            srcDir "src"
            include "**/*.astub"
        }
    }

    test {
        java {
            srcDirs = ["tests"]
        }
    }
}

task buildZ3(type: Exec) {
    description 'Build Z3 solver'
    onlyIf { !(new File(z3Jar).exists()) }
    workingDir './scripts'
    commandLine './buildZ3'
}

task buildLingeling(type: Exec) {
    description 'Build Lingeling solver'
    onlyIf { !(new File(lingelingTar).exists()) }
    workingDir './scripts'
    commandLine './buildLingeling'
}

task buildDLJC(type: Exec) {
    description 'Build DLJC Tool'
    onlyIf { !(new File(dljcScript).exists()) }
    workingDir './scripts'
    commandLine './buildDLJC'
}

test {
    dependsOn(shadowJar)
}

compileJava {
    dependsOn(buildZ3)
    dependsOn(buildLingeling)
    dependsOn(buildDLJC)
    options.compilerArgs = [
            '-implicit:class',
            '-Awarns',
            '-Xmaxwarns', '10000',
            // Can't use this because JSON library contains raw types:
            // '-Xlint:unchecked',
            '-Xlint:deprecation',
            '-Werror',
    ]
}

// Exclude parts of the build directory that don't include classes from being packaged in
// the jar file.
// IMPORTANT: If "libs" is packaged in the JAR file you end up with an infinitely
// recursive jar task that will fill up your hard drive (eventually)
jar {
    description = 'Makes a jar with ONLY the classes compiled for checker ' +
            'framework inference and NONE of its dependencies'
    archiveName = "checker-framework-inference.jar"
    manifest.attributes("Main-Class": "checkers.inference.InferenceLauncher")
    exclude("dependency-cache", "libs", "tmp")
}

shadowJar {
    description 'Creates the "fat" checker.jar in dist'
    destinationDir = file("${projectDir}/dist")
    archiveName = "checker-framework-inference.jar"
}

task dist(dependsOn: shadowJar, type: Copy) {
    description = "If your Checker Framework project is fully built, this task " +
            "will build checker-framework-inference.jar, copy all the relevant runtime jars into " +
            "the dist directory."
    from files(
            "${checkerFrameworkPath}/checker/dist/jdk8.jar",
            "${checkerFrameworkPath}/checker/dist/checker.jar",
            "${checkerFrameworkPath}/checker/dist/checker-qual.jar",
            "${checkerFrameworkPath}/checker/dist/javac.jar",
    )
    into file('dist')
}

task dependenciesJar(dependsOn: dist, type: Jar) {
    description 'Create a jar file with all the dependencies.'
    from {
        configurations.compile.collect { it.isDirectory() ? it : zipTree(it) }
        configurations.testCompile.collect { it.isDirectory() ? it : zipTree(it) }
    }
    archiveName 'dependencies.jar'
    destinationDir file("${projectDir}/dist/")
}

task testLibJar(dependsOn: dist, type: Jar) {
    from sourceSets.test.output.classesDirs
    include ('checkers/inference/test/**')
    archiveName 'inference-framework-test-lib.jar'
    destinationDir file("${projectDir}/dist/")
}

tasks.clean {
    delete += "build/libs/checker-framework-inference.zip"
    delete += "jdk8.jar"
    delete += "javac.jar"
    delete += fileTree('dist') {
        include '**/*.jar'
    }
}


task release(type: Zip) {
    from('src') {
        into('release/src')
    }

    from('dist') {
        into('release/dist')
    }
    from('scripts') {
        into('release/scripts')
        include '*.py'
    }

    baseName = 'release'
}

task cloneAndBuildDependencies(type: Exec) {
    description 'Clones (or updates) and builds all dependencies'
    executable './.travis-build-without-test.sh'
}

task testCheckerInferenceScript(type: Exec, dependsOn: dist) {
    description 'Basic sanity check of scripts/inference'
    executable './scripts/inference'
    args = ['--mode', 'TYPECHECK',
            '--checker', 'ostrusted.OsTrustedChecker',
            '--solver', 'checkers.inference.solver.PropagationSolver',
            'testdata/ostrusted/Test.java']
}

task testCheckerInferenceDevScript(type: Exec, dependsOn: [dist, dependenciesJar]) {
    description 'Basic sanity check of scripts/inference-dev'
    executable './scripts/inference-dev'
    args = ['--mode', 'INFER',
            '--checker', 'interning.InterningChecker',
            '--solver', 'checkers.inference.solver.MaxSat2TypeSolver',
            'testdata/interning/MapAssignment.java']
}

task testDataflowExternalSolvers(type: Exec, dependsOn: [dist, dependenciesJar]) {
    description 'Test Dataflow type system on its external solvers Lingeling and LogicBlox'
    executable './testing/dataflowexample/travis-test.sh'
}

afterEvaluate {
    // Create a task for each test class whose name is the same as the class name.
    sourceSets.test.java.filter {
            it.path.contains('tests/checkers') &&
            it.path.endsWith('Test.java') &&
            !it.path.contains('CFInferenceTest')
        }.forEach { file ->
        String junitClassName = file.name.replaceAll(".java", "")
        tasks.create(name: "${junitClassName}", type: Test, group: 'Verification') {
            description "Run ${junitClassName} tests."
            include "**/${name}.class"
        }
    }

    // Configure Tests
    tasks.withType(Test) {
        dependsOn(shadowJar)

        systemProperties 'path.afu.scripts': "${afu}/scripts",
                'path.inference.script': "${projectDir}/scripts/inference",
                'use.hacks': true,
                JDK_JAR: "${checkerFrameworkPath}/checker/dist/jdk8.jar"

        if (project.hasProperty('emit.test.debug')) {
            systemProperties += ["emit.test.debug": 'true']
        }

        testLogging {
            // Always run the tests
            outputs.upToDateWhen { false }
            // The following prints out each time a test is passed.
            // events "passed", "skipped", "failed", "standardOut", "standardError"
            events "failed"
            // Show the found unexpected diagnostics and expected diagnostics not found.
            exceptionFormat "full"
        }

        // After each test, print a summary.
        afterSuite { desc, result ->
            if (desc.getClassName() != null) {
                long mils = result.getEndTime() - result.getStartTime()
                double seconds = mils / 1000.0

                println "Testsuite: ${desc.getClassName()}\n" +
                        "Tests run: ${result.testCount}, " +
                        "Failures: ${result.failedTestCount}, " +
                        "Skipped: ${result.skippedTestCount}, " +
                        "Time elapsed: ${seconds} sec\n"
            }
        }
    }
}

/// Commented out because plugins section is commented out
// /* Configuration for formatting */
// googleJavaFormat {
//   // toolVersion '1.3'
//   options style: 'AOSP'
// }
// tasks.googleJavaFormat {
//   group 'Formatting'
//   description = "Reformat Java source code with Google-Java-format"
//   exclude 'testing'
//   exclude 'testinputs'
// }
// tasks.verifyGoogleJavaFormat {
//   group 'Formatting'
//   description = "Check Java source code is in Google-Java-format"
//   exclude 'testing'
//   exclude 'testinputs'
// }

task etags {
    doLast {
        def sources = (sourceSets.main.java).getFiles().collect({ src -> src.getPath() }).sort()
        def sourcesStr = sources.inject(null, { acc, source -> acc ? acc + " " + source : source })

        def proc = "etags ${sourcesStr} ".execute()
        proc.in.eachLine { line -> println line }
        proc.err.eachLine { line -> println 'ERROR: ' + line }
        proc.waitFor()
    }
}

task tags(dependsOn: etags)

task countHacks(type: Exec) {
    commandLine "bash", "-c", "grep -r 'InferenceMain.isHackMode(' src/ | wc -l"
}