build.gradle

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        if (JavaVersion.current() >= JavaVersion.VERSION_11) {
            // Code formatting; defines targets "spotlessApply" and "spotlessCheck".
            // https://github.com/diffplug/spotless/tags ; see tags starting "gradle/"
            // Only works on JDK 11+.
            classpath 'com.diffplug.spotless:spotless-plugin-gradle:6.25.0'
        }
    }
}


plugins {
    id 'net.ltgt.errorprone' version '3.1.0'
}

apply plugin: 'java'

ext {
    jsr308 = System.getenv('JSR308') ?: file(new File("..")).absolutePath
    cfPath = "${jsr308}/checker-framework"
    cfiPath = "${jsr308}/checker-framework-inference"
    afu = "${jsr308}/annotation-tools/annotation-file-utilities"
    ontologyPath = "${jsr308}/ontology"

    isJava8 = JavaVersion.current() == JavaVersion.VERSION_1_8
    isJava11plus = JavaVersion.current() >= JavaVersion.VERSION_11

    // Keep in sync with checker-framework/build.gradle.
    // TODO: find a way to directly use that variable.
    compilerArgsForRunningCF = [
        "--add-exports",
        "jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED",
        "--add-exports",
        "jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED",
        "--add-exports",
        "jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED",
        "--add-exports",
        "jdk.compiler/com.sun.tools.javac.main=ALL-UNNAMED",
        "--add-exports",
        "jdk.compiler/com.sun.tools.javac.model=ALL-UNNAMED",
        "--add-exports",
        "jdk.compiler/com.sun.tools.javac.processing=ALL-UNNAMED",
        "--add-exports",
        "jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED",
        "--add-exports",
        "jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED",
        "--add-opens",
        "jdk.compiler/com.sun.tools.javac.comp=ALL-UNNAMED",
    ]
}

println '==================================='
println '         Ontology Checker          '
println '==================================='
println ''
println '-------------------------------'
println 'Important Environment Variables'
println '-------------------------------'
println 'JSR308: ' + jsr308
println 'CF:     ' + cfPath
println 'CFI:    ' + cfiPath

repositories {
    mavenCentral()
}

dependencies {
    implementation fileTree(dir: "${cfPath}/checker/dist", include: "checker.jar")
    implementation fileTree(dir: "${cfiPath}/dist", include: "checker-framework-inference.jar")
    // sat4j solver dependency
    implementation 'org.ow2.sat4j:org.ow2.sat4j.core:2.3.6'
    implementation 'org.ow2.sat4j:org.ow2.sat4j.maxsat:2.3.6'
    // z3 solver dependency
    implementation fileTree(dir: "${cfiPath}/lib", include: "com.microsoft.z3.jar")

    implementation fileTree(dir: "${cfiPath}/dist", include: "inference-framework-test-lib.jar")

    // CF test lib dependency
    testImplementation fileTree(dir: "${cfPath}/framework-test/build/libs", include: "framework-test-*.jar")
    testImplementation 'junit:junit:4.13.2'

    errorprone 'com.google.errorprone:error_prone_core:2.26.1'
    errorproneJavac 'com.google.errorprone:javac:9+181-r4173-1'
}

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

        resources {
            srcDirs = ["src"]
            include "**/*.astub"
        }
    }

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

tasks.withType(JavaCompile) { compilationTask ->
    options.compilerArgs = [
        '-implicit:class',
        '-Awarns',
        '-Xmaxwarns',
        '10000',
    ]

    // Error Prone must be available in the annotation processor path
    options.annotationProcessorPath = configurations.errorprone
    // Enable Error Prone
    options.errorprone.enabled = !isJava8
    options.errorprone.disableWarningsInGeneratedCode = true
}

afterEvaluate {
    // Create a task for each JUnit test class whose name is the same as the JUnit class name.
    sourceSets.test.allJava.filter { it.path.contains("${ontologyPath}/tests") }.forEach { file ->
        String junitClassName = file.name.replaceAll(".java", "")
        String testName = junitClassName.replaceAll("Test", "")
        tasks.create(name: "${junitClassName}", type: Test) {
            description "Run ${testName} tests."
            include "**/${name}.class"
        }
    }

    // Configure JUnit tests
    tasks.withType(Test) {
        group 'Verification'

        systemProperties = [
            'path.afu.scripts': "${afu}/scripts",
            'path.inference.script': "${cfiPath}/scripts/inference"
        ]

        environment "external_checker_classpath", "${ontologyPath}/build/classes/java/main:${ontologyPath}/build/libs/ontology.jar"

        if (isJava8) {
            jvmArgs "-Xbootclasspath/p:${cfiPath}/dist/javac.jar"
        } else {
            jvmArgs += compilerArgsForRunningCF
        }

        testLogging {
            // Always run the tests
            outputs.upToDateWhen { false }
            // The following prints out each time a test is passed.
            events "passed", "skipped", "failed", "standardOut", "standardError"

            // Show the found unexpected diagnostics and expected diagnostics not found.
            exceptionFormat "full"
            showExceptions true
            showCauses true
            showStackTraces true
            showStandardStreams true
        }

        // 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"
            }
        }
    }
}

tasks.clean {
    delete += "build"
    delete += "dist"
    delete += "testdata"
}

if (isJava11plus) {
    apply plugin: 'com.diffplug.spotless'
    spotless {
        java {
            target '**/*.java'
            googleJavaFormat().aosp()
            formatAnnotations().addTypeAnnotation("Ontology")
        }
        groovyGradle {
            target '**/*.gradle'
            greclipse()  // which formatter Spotless should use to format .gradle files.
            indentWithSpaces(4)
            trimTrailingWhitespace()
            // endWithNewline() // Don't want to end empty files with a newline
        }
    }
}