| sourceSets { |
| main { |
| resources { |
| // Stub files, message.properties, etc. |
| srcDirs += ['src/main/java'] |
| } |
| } |
| testannotations |
| } |
| |
| |
| sourcesJar { |
| // The resources duplicate content from the src directory. |
| duplicatesStrategy = DuplicatesStrategy.EXCLUDE |
| } |
| |
| dependencies { |
| implementation project(':javacutil') |
| implementation project(':dataflow') |
| implementation project(':framework') |
| // AFU is an "includedBuild" imported in checker-framework/settings.gradle, so the version number doesn't matter. |
| // https://docs.gradle.org/current/userguide/composite_builds.html#settings_defined_composite |
| implementation('org.checkerframework:annotation-file-utilities:*') { |
| exclude group: 'com.google.errorprone', module: 'javac' |
| } |
| implementation project(':checker-qual') |
| implementation project(':checker-util') |
| |
| // External dependencies: |
| // If you add an external dependency, you must shadow its packages. |
| // See the comment in ../build.gradle in the shadowJar block. |
| |
| // As of 2019-12-16, the version of reflection-util in the Annotation |
| // File Utilities takes priority over this version, in the fat jar |
| // file. :-( So update it and re-build it locally when updating this. |
| implementation 'org.plumelib:reflection-util:1.0.3' |
| implementation 'org.plumelib:plume-util:1.5.3' |
| |
| // Dependencies added to "shadow" appear as dependencies in Maven Central. |
| shadow project(':checker-qual') |
| shadow project(':checker-util') |
| |
| // Called Methods Checker AutoValue + Lombok support |
| testImplementation "com.google.auto.value:auto-value-annotations:1.7.4" |
| testImplementation "com.google.auto.value:auto-value:1.7.4" |
| testImplementation "com.ryanharter.auto.value:auto-value-parcel:0.2.8" |
| testImplementation "org.projectlombok:lombok:1.18.20" |
| // Called Methods Checker support for detecting misuses of AWS APIs |
| testImplementation "com.amazonaws:aws-java-sdk-ec2" |
| testImplementation "com.amazonaws:aws-java-sdk-kms" |
| // The AWS SDK is used for testing the Called Methods Checker. |
| testImplementation platform("com.amazonaws:aws-java-sdk-bom:1.11.964") |
| |
| testImplementation group: 'junit', name: 'junit', version: '4.13.2' |
| testImplementation project(':framework-test') |
| testImplementation sourceSets.testannotations.output |
| |
| testannotationsImplementation project(':checker-qual') |
| } |
| |
| jar { |
| manifest { |
| attributes("Main-Class": "org.checkerframework.framework.util.CheckerMain") |
| } |
| } |
| |
| task copyJarsToDist(dependsOn: shadowJar, group: 'Build') { |
| description 'Builds or downloads jars required by CheckerMain and puts them in checker/dist.' |
| dependsOn project(':checker-qual').tasks.jar |
| doLast { |
| copy { |
| from file(project(':checker-qual').tasks.getByName("jar").archivePath) |
| into "${projectDir}/dist" |
| rename { String fileName -> |
| // remove version number on checker-qual.jar |
| fileName.replace(fileName, "checker-qual.jar") |
| } |
| } |
| |
| copy { |
| from file(project(':checker-util').tasks.getByName("jar").archivePath) |
| into "${projectDir}/dist" |
| rename { String fileName -> |
| // remove version number on checker-util.jar |
| fileName.replace(fileName, "checker-util.jar") |
| } |
| } |
| |
| copy { |
| from configurations.javacJar |
| into "${projectDir}/dist" |
| rename { String fileName -> |
| fileName.replace(fileName, "javac.jar") |
| } |
| } |
| } |
| } |
| |
| assemble.dependsOn copyJarsToDist |
| |
| task allSourcesJar(type: Jar, group: 'Build') { |
| description 'Creates a sources jar that includes sources for all Checker Framework classes in checker.jar' |
| destinationDirectory = file("${projectDir}/dist") |
| archiveFileName = "checker-source.jar" |
| archiveClassifier = "sources" |
| from (sourceSets.main.java, project(':framework').sourceSets.main.allJava, |
| project(':dataflow').sourceSets.main.allJava, project(':javacutil').sourceSets.main.allJava, |
| project(':checker-qual').sourceSets.main.allJava, project(':checker-util').sourceSets.main.allJava) |
| } |
| |
| task allJavadocJar(type: Jar, group: 'Build') { |
| description 'Creates javadoc jar including Javadoc for all of the Checker Framework' |
| dependsOn rootProject.tasks.allJavadoc |
| destinationDirectory = file("${projectDir}/dist") |
| archiveFileName = "checker-javadoc.jar" |
| archiveClassifier = "javadoc" |
| from rootProject.tasks.allJavadoc.destinationDir |
| } |
| |
| // Shadowing Test Sources and Dependencies |
| import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar |
| |
| task checkerJar(type: ShadowJar, dependsOn: compileJava, group: 'Build') { |
| description "Builds checker-${project.version}.jar with all dependencies except checker-qual and checker-util." |
| includeEmptyDirs = false |
| archivesBaseName = 'checker' |
| archiveClassifier = '' |
| |
| from shadowJar.source |
| configurations = shadowJar.configurations |
| // To see what files are incorporated into the shadow jar file: |
| // doLast { println sourceSets.main.runtimeClasspath.asPath } |
| manifest { |
| attributes("Main-Class": "org.checkerframework.framework.util.CheckerMain") |
| } |
| exclude 'org/checkerframework/**/qual/*' |
| exclude 'org/checkerframework/checker/*/util/*' |
| relocators = shadowJar.getRelocators() |
| } |
| |
| jar { |
| dependsOn(checkerJar) |
| // Never build the skinny jar. |
| onlyIf {false} |
| archiveClassifier = 'skinny' |
| } |
| |
| shadowJar { |
| description 'Creates checker-VERSION-all.jar and copies it to dist/checker.jar.' |
| // To see what files are incorporated into the shadow jar file: |
| // doFirst { println sourceSets.main.runtimeClasspath.asPath } |
| doLast{ |
| copy { |
| from archiveFile.get() |
| into file("${projectDir}/dist") |
| rename 'checker.*', 'checker.jar' |
| } |
| } |
| } |
| |
| artifacts { |
| // Don't add this here or else the Javadoc and the sources jar is built during the assemble task. |
| // archives allJavadocJar |
| // archives allSourcesJar |
| archives shadowJar |
| archives checkerJar |
| } |
| |
| clean { |
| delete "${projectDir}/dist" |
| delete "tests/calledmethods-delomboked" |
| delete("tests/wpi-testchecker/annotated") |
| delete("tests/wpi-testchecker/inference-output") |
| delete("tests/wpi-nullness/annotated") |
| delete("tests/wpi-nullness/inference-output") |
| } |
| |
| // Add non-junit tests |
| createCheckTypeTask(project.name,, "CompilerMessages", |
| 'org.checkerframework.checker.compilermsgs.CompilerMessagesChecker') |
| checkCompilerMessages { |
| doFirst { |
| options.compilerArgs += [ |
| '-Apropfiles=' + sourceSets.main.resources.filter { file -> file.name.equals('messages.properties') }.asPath + ":" |
| + project(':framework').sourceSets.main.resources.filter { file -> file.name.equals('messages.properties') }.asPath |
| ] |
| } |
| } |
| |
| task nullnessExtraTests(type: Exec, dependsOn: copyJarsToDist, group: 'Verification') { |
| description 'Run extra tests for the Nullness Checker.' |
| executable 'make' |
| environment JAVAC: "${projectDir}/bin/javac", JAVAP: 'javap' |
| args = ['-C', 'tests/nullness-extra/'] |
| } |
| |
| task commandLineTests(type: Exec, dependsOn: copyJarsToDist, group: 'Verification') { |
| description 'Run tests that need a special command line.' |
| executable 'make' |
| environment JAVAC: "${projectDir}/bin/javac" |
| args = ['-C', 'tests/command-line/'] |
| } |
| |
| task tutorialTests(dependsOn: copyJarsToDist, group: 'Verification') { |
| description 'Test that the tutorial is working as expected.' |
| doLast { |
| ant.ant(dir: "${rootDir}/docs/tutorial/tests", useNativeBasedir: 'true', inheritAll: 'false') { |
| target(name: 'check-tutorial') |
| } |
| } |
| } |
| |
| task exampleTests(type: Exec, dependsOn: copyJarsToDist, group: 'Verification') { |
| description 'Run tests for the example programs.' |
| executable 'make' |
| environment JAVAC: "${projectDir}/bin/javac" |
| args = ['-C', '../docs/examples'] |
| } |
| |
| task demosTests(dependsOn: copyJarsToDist, group: 'Verification') { |
| description 'Test that the demos are working as expected.' |
| doLast { |
| if (JavaVersion.current() == JavaVersion.VERSION_1_8) { |
| File demosDir = new File(projectDir, '../../checker-framework.demos'); |
| if (!demosDir.exists()) { |
| exec { |
| workingDir file(demosDir.toString() + '/../') |
| executable 'git' |
| args = ['clone', '--depth', '1', 'https://github.com/typetools/checker-framework.demos.git'] |
| } |
| } else { |
| exec { |
| workingDir demosDir |
| executable 'git' |
| args = ['pull', 'https://github.com/typetools/checker-framework.demos.git'] |
| ignoreExitValue = true |
| } |
| } |
| ant.properties.put('checker.lib', file("${projectDir}/dist/checker.jar").absolutePath) |
| ant.ant(dir: demosDir.toString()) |
| } else { |
| println("Skipping demosTests because they only work with Java 8.") |
| } |
| } |
| } |
| |
| task allNullnessTests(type: Test, group: 'Verification') { |
| description 'Run all Junit tests for the Nullness Checker.' |
| include '**/Nullness*.class' |
| } |
| |
| task allCalledMethodsTests(type: Test, group: 'Verification') { |
| description 'Run all Junit tests for the Called Methods Checker.' |
| include '**/CalledMethods*.class' |
| dependsOn 'delombok' |
| } |
| |
| // These are tests that should only be run with JDK 11. |
| task jtregJdk11Tests(dependsOn: ':downloadJtreg', group: 'Verification') { |
| description 'Run the jtreg tests made for JDK 11.' |
| dependsOn('compileJava') |
| dependsOn('compileTestJava') |
| dependsOn('shadowJar') |
| |
| String jtregOutput = "${buildDir}/jtregJdk11" |
| String name = 'all' |
| doLast { |
| if (isJava8) { |
| println "This test is only run with JDK 11." |
| return; |
| } |
| exec { |
| executable "${jtregHome}/bin/jtreg" |
| args = [ |
| "-dir:${projectDir}/jtregJdk11", |
| "-workDir:${jtregOutput}/${name}/work", |
| "-reportDir:${jtregOutput}/${name}/report", |
| "-verbose:summary", |
| "-javacoptions:-g", |
| "-keywords:!ignore", |
| "-samevm", |
| "-javacoptions:-classpath ${tasks.shadowJar.archiveFile.get()}:${sourceSets.test.output.asPath}", |
| "-vmoptions:-classpath ${tasks.shadowJar.archiveFile.get()}:${sourceSets.test.output.asPath}", |
| "-vmoptions:--add-opens=jdk.compiler/com.sun.tools.javac.comp=ALL-UNNAMED", |
| "-javacoptions:-classpath ${sourceSets.testannotations.output.asPath}", |
| // Location of jtreg tests |
| '.' |
| ] |
| } |
| |
| |
| } |
| } |
| |
| // JSpecify tests are excluded by default. To run them: |
| // ./gradlew NullnessJSpecifySamplesTest |
| test { |
| exclude '**/org/checkerframework/checker/test/junit/NullnessJSpecifySamplesTest.class' |
| } |
| |
| task delombok { |
| description 'Delomboks the source code tree in tests/calledmethods-lombok' |
| |
| def srcDelomboked = 'tests/calledmethods-delomboked' |
| def srcJava = 'tests/calledmethods-lombok' |
| |
| inputs.files file(srcJava) |
| outputs.dir file(srcDelomboked) |
| |
| // Because there are Checker Framework annotations in the test source. |
| dependsOn project(':checker-qual').tasks.jar |
| |
| doLast { |
| def collection = files(configurations.testCompileClasspath) |
| ant.taskdef(name: 'delombok', classname: 'lombok.delombok.ant.Tasks$Delombok', |
| classpath: collection.asPath) |
| ant.delombok(from: srcJava, to: srcDelomboked, classpath: collection.asPath) |
| } |
| } |
| |
| tasks.test.dependsOn("delombok") |
| |
| /// |
| /// Whole-program inference tests |
| /// |
| |
| test { |
| useJUnit { |
| // These are run in task wholeProgramInferenceTests. |
| excludeCategories 'org.checkerframework.checker.test.junit.wpirunners.WholeProgramInferenceTestCheckerJaifsTest' |
| excludeCategories 'org.checkerframework.checker.test.junit.wpirunners.WholeProgramInferenceTestCheckerStubsTest' |
| excludeCategories 'org.checkerframework.checker.test.junit.wpirunners.WholeProgramInferenceTestCheckerAjavaTest' |
| excludeCategories 'org.checkerframework.checker.test.junit.wpirunners.WholeProgramInferenceNullnessJaifsTest' |
| } |
| } |
| |
| task testWpiTestCheckerStubs(type: Test) { |
| description 'Internal task. Users should run wholeProgramInferenceTestCheckerStubTests instead. This runs the wpi-testchecker tests with -Ainfer=stubs to generate stub files' |
| |
| dependsOn(compileTestJava) |
| doFirst { |
| delete("tests/wpi-testchecker/annotated") |
| delete("${buildDir}/wpi-testchecker/") |
| } |
| outputs.upToDateWhen { false } |
| include '**/WholeProgramInferenceTestCheckerStubsTest.class' |
| testLogging { |
| // Always run the tests |
| outputs.upToDateWhen { false } |
| |
| // Show the found unexpected diagnostics and the expected diagnostics not found. |
| exceptionFormat "full" |
| events "passed", "skipped", "failed" |
| } |
| |
| doLast { |
| copyNonannotatedToAnnotatedDirectory("wpi-testchecker") |
| // The stub file format doesn't support annotations on anonymous inner classes, so |
| // this test also expects errors on UsesAnonymous.java. |
| delete('tests/wpi-testchecker/annotated/UsesAnonymous.java') |
| copy { |
| from file('tests/wpi-testchecker/non-annotated/UsesAnonymous.java') |
| into file('tests/wpi-testchecker/annotated') |
| } |
| } |
| } |
| |
| task testWpiTestCheckerStubsValidate(type: Test) { |
| description 'Internal task. Users should run wholeProgramInferenceTestCheckerStubTests instead. This re-runs the wpi-testchecker tests using the stub files generated by testWpiTestCheckerStubs' |
| |
| dependsOn(testWpiTestCheckerStubs) |
| outputs.upToDateWhen { false } |
| include '**/WholeProgramInferenceTestCheckerStubsValidationTest.class' |
| testLogging { |
| // Always run the tests |
| outputs.upToDateWhen { false } |
| |
| // Show the found unexpected diagnostics and the expected diagnostics not found. |
| exceptionFormat "full" |
| events "passed", "skipped", "failed" |
| } |
| } |
| |
| task testWpiTestCheckerAjava(type: Test) { |
| description 'Internal task. Users sholud run wholeProgramInferenceTestCheckerAjavaTests instead. This runs the wpi-testchecker tests with -Ainfer=ajava to generate stub files' |
| |
| dependsOn(compileTestJava) |
| doFirst { |
| delete("tests/wpi-testchecker/annotated") |
| delete("${buildDir}/wpi-testchecker/") |
| } |
| outputs.upToDateWhen { false } |
| include '**/WholeProgramInferenceTestCheckerAjavaTest.class' |
| testLogging { |
| // Always run the tests |
| outputs.upToDateWhen { false } |
| |
| // Show the found unexpected diagnostics and the expected diagnostics not found. |
| exceptionFormat "full" |
| events "passed", "skipped", "failed" |
| } |
| |
| doLast { |
| copyNonannotatedToAnnotatedDirectory("wpi-testchecker") |
| } |
| } |
| |
| task testWpiTestCheckerAjavaValidate(type: Test) { |
| description 'Internal task. Users should run wholeProgramInferenceTestCheckerAjavaTests instead. This re-runs the wpi-testchecker tests using the ajava files generated by testWpiTestCheckerAjava' |
| |
| dependsOn(testWpiTestCheckerAjava) |
| outputs.upToDateWhen { false } |
| include '**/WholeProgramInferenceTestCheckerAjavaValidationTest.class' |
| testLogging { |
| // Always run the tests |
| outputs.upToDateWhen { false } |
| |
| // Show the found unexpected diagnostics and the expected diagnostics not found. |
| exceptionFormat "full" |
| events "passed", "skipped", "failed" |
| } |
| } |
| |
| // Copies directories as needed by WPI tests. |
| // Formal parameter testdir is, for example, "wpi-testchecker". |
| // Does work in directory "tests/${testdir}/". |
| // 1. Copies whole-program inference test source code from the non-annotated/ to the annotated/ directory. |
| // 2. Copies WPI output, such as .jaif or .stub files, to the inferference-output/ directory. |
| void copyNonannotatedToAnnotatedDirectory(String testdir) { |
| // Copying all test files to another directory, removing all expected errors that should not |
| // occur after inserting inferred annotations from .jaif files. |
| copy { |
| from files("tests/${testdir}/non-annotated") |
| into file("tests/${testdir}/annotated") |
| filter { String line -> |
| line.contains('// :: error:') || line.contains('// :: warning:') ? null : line |
| } |
| } |
| // The only file for which expected errors are maintained is ExpectedErrors.java, so we copy it over. |
| delete("tests/${testdir}/annotated/ExpectedErrors.java") |
| copy { |
| from file("tests/${testdir}/non-annotated/ExpectedErrors.java") |
| into file("tests/${testdir}/annotated") |
| } |
| |
| delete("tests/${testdir}/inference-output") |
| file("build/whole-program-inference").renameTo(file("tests/${testdir}/inference-output")) |
| } |
| |
| // This task is similar to the wholeProgramInferenceTestCheckerJaifTests task below, but it doesn't |
| // run the insert-annotations-to-source tool. Instead, it tests the -Ainfer=stubs feature |
| // and the -AmergeStubsWithSource feature to do WPI using stub files. |
| task wholeProgramInferenceTestCheckerStubTests(dependsOn: 'shadowJar', group: 'Verification') { |
| description 'Run tests for whole-program inference using stub files' |
| dependsOn(testWpiTestCheckerStubsValidate) |
| outputs.upToDateWhen { false } |
| } |
| |
| // Like wholeProgramInferenceTestCheckerStubTests, but with ajava files instead |
| task wholeProgramInferenceTestCheckerAjavaTests(dependsOn: 'shadowJar', group: 'Verification') { |
| description 'Run tests for whole-program inference using ajava files' |
| dependsOn(testWpiTestCheckerAjavaValidate) |
| outputs.upToDateWhen { false } |
| } |
| |
| task testWpiTestCheckerJaifs(type: Test) { |
| description 'Internal task. Users should run wholeProgramInferenceNullnessJaifTests instead. This runs the wpi-testchecker tests with -Ainfer=jaifs to generate .jaif files' |
| |
| dependsOn(compileTestJava) |
| dependsOn(':checker-qual:jar') // For the Value Checker annotations. |
| doFirst { |
| delete("tests/wpi-testchecker/annotated") |
| } |
| outputs.upToDateWhen { false } |
| include '**/WholeProgramInferenceTestCheckerJaifsTest.class' |
| testLogging { |
| // Always run the tests |
| outputs.upToDateWhen { false } |
| |
| // Show the found unexpected diagnostics and expected diagnostics not found. |
| exceptionFormat "full" |
| events "passed", "skipped", "failed" |
| } |
| |
| doLast { |
| copyNonannotatedToAnnotatedDirectory("wpi-testchecker") |
| |
| // JAIF-based WPI fails these tests, which was added for stub-based WPI. |
| // See issue here: https://github.com/typetools/checker-framework/issues/3009 |
| delete('tests/wpi-testchecker/annotated/ConflictingAnnotationsTest.java') |
| delete('tests/wpi-testchecker/annotated/MultiDimensionalArrays.java') |
| |
| // Inserting annotations from .jaif files in-place. |
| String jaifsDir = "tests/wpi-testchecker/inference-output"; |
| List<File> jaifs = fileTree(jaifsDir).matching { |
| include '*.jaif' |
| }.asList() |
| if (jaifs.isEmpty()) { |
| throw new GradleException("no .jaif files found in ${jaifsDir}") |
| } |
| String javasDir = "tests/wpi-testchecker/annotated/"; |
| List<File> javas = fileTree(javasDir).matching { |
| include '*.java' |
| }.asList() |
| if (javas.isEmpty()) { |
| throw new GradleException("no .java files found in ${javasDir}") |
| } |
| exec { |
| executable "${afu}/scripts/insert-annotations-to-source" |
| // Script argument -cp must precede Java program argument -i. |
| // checker-qual is needed for Constant Value Checker annotations. |
| args = ['-cp', "${sourceSets.test.output.asPath}:${project(':checker-qual').tasks.jar.archivePath}"] |
| args += ['-i'] |
| for (File jaif : jaifs) { |
| args += [jaif.toString()] |
| } |
| for (File javaFile : javas) { |
| args += [javaFile.toString()] |
| } |
| } |
| } |
| } |
| |
| task testWpiTestCheckerJaifsValidate(type: Test) { |
| description 'Internal task. Users should run wholeProgramInferenceNullnessJaifTests instead. This re-runs the wpi-testchecker tests using the .jaif files generated by testWpiTestCheckerJaifs' |
| |
| dependsOn(testWpiTestCheckerJaifs) |
| outputs.upToDateWhen { false } |
| include '**/WholeProgramInferenceTestCheckerJaifsValidationTest.class' |
| testLogging { |
| // Always run the tests |
| outputs.upToDateWhen { false } |
| |
| // Show the found unexpected diagnostics and expected diagnostics not found. |
| exceptionFormat "full" |
| events "passed", "skipped", "failed" |
| } |
| } |
| |
| task wholeProgramInferenceTestCheckerJaifTests(dependsOn: 'shadowJar', group: 'Verification') { |
| description 'Run tests for whole-program inference using .jaif files' |
| dependsOn(testWpiTestCheckerJaifsValidate) |
| outputs.upToDateWhen { false } |
| } |
| |
| |
| task testWpiNullnessJaifs(type: Test) { |
| description 'Internal task. Users should run wholeProgramInferenceNullnessJaifTests instead. This runs the wpi-nullness tests with -Ainfer=jaifs to generate .jaif files' |
| |
| dependsOn(compileTestJava) |
| doFirst { |
| delete("tests/wpi-nullness/annotated") |
| } |
| outputs.upToDateWhen { false } |
| include '**/WholeProgramInferenceNullnessJaifsTest.class' |
| testLogging { |
| // Always run the tests |
| outputs.upToDateWhen { false } |
| |
| // Show the found unexpected diagnostics and expected diagnostics not found. |
| exceptionFormat "full" |
| events "passed", "skipped", "failed" |
| } |
| |
| doLast { |
| copyNonannotatedToAnnotatedDirectory("wpi-nullness") |
| |
| // JAIF-based WPI fails these tests, which was added for stub-based WPI. |
| // See issue here: https://github.com/typetools/checker-framework/issues/3009 |
| delete('tests/wpi-nullness/annotated/ConflictingAnnotationsTest.java') |
| delete('tests/wpi-nullness/annotated/MultiDimensionalArrays.java') |
| |
| // Inserting annotations from .jaif files in-place. |
| String jaifsDir = "tests/wpi-nullness/inference-output"; |
| List<File> jaifs = fileTree(jaifsDir).matching { |
| include '*.jaif' |
| }.asList() |
| if (jaifs.isEmpty()) { |
| throw new GradleException("no .jaif files found in ${jaifsDir}") |
| } |
| String javasDir = "tests/wpi-nullness/annotated/"; |
| List<File> javas = fileTree(javasDir).matching { |
| include '*.java' |
| }.asList() |
| if (javas.isEmpty()) { |
| throw new GradleException("no .java files found in ${javasDir}") |
| } |
| exec { |
| executable "${afu}/scripts/insert-annotations-to-source" |
| // Script argument -cp must precede Java program argument -i. |
| args = ['-cp', "${sourceSets.test.output.asPath}"] |
| args += ['-i'] |
| for (File jaif : jaifs) { |
| args += [jaif.toString()] |
| } |
| for (File javaFile : javas) { |
| args += [javaFile.toString()] |
| } |
| } |
| } |
| } |
| |
| task testWpiNullnessJaifsValidate(type: Test) { |
| description 'Internal task. Users should run wholeProgramInferenceNullnessJaifTests instead. This re-runs the wpi-nullness tests using the .jaif files generated by testWpiNullnessJaifs' |
| |
| dependsOn(testWpiNullnessJaifs) |
| outputs.upToDateWhen { false } |
| include '**/WholeProgramInferenceNullnessJaifsValidationTest.class' |
| testLogging { |
| // Always run the tests |
| outputs.upToDateWhen { false } |
| |
| // Show the found unexpected diagnostics and expected diagnostics not found. |
| exceptionFormat "full" |
| events "passed", "skipped", "failed" |
| } |
| } |
| |
| task wholeProgramInferenceNullnessJaifTests(dependsOn: 'shadowJar', group: 'Verification') { |
| description 'Run tests for whole-program inference using .jaif files' |
| dependsOn(testWpiNullnessJaifsValidate) |
| outputs.upToDateWhen { false } |
| } |
| |
| |
| // Empty task that just runs both the jaif and stub WPI tests. |
| // It is run as part of the inferenceTests task. |
| task wholeProgramInferenceTests(group: 'Verification') { |
| description "Run tests for all whole program inference modes." |
| dependsOn('wholeProgramInferenceTestCheckerJaifTests') |
| dependsOn('wholeProgramInferenceTestCheckerStubTests') |
| dependsOn('wholeProgramInferenceTestCheckerAjavaTests') |
| dependsOn('wholeProgramInferenceNullnessJaifTests') |
| } |
| |
| // This is run as part of the inferenceTests task. |
| task wpiManyTests(group: "Verification") { |
| description 'Tests the wpi-many.sh script (and indirectly the wpi.sh script). Requires an Internet connection.' |
| dependsOn(copyJarsToDist) |
| // This test must always be re-run when requested. |
| outputs.upToDateWhen { false } |
| |
| doFirst { |
| delete("${project.projectDir}/build/wpi-many-tests-results/") |
| // wpi-many.sh is run in skip mode so that logs are preserved, but |
| // we don't actually want to skip previously-failing tests when we |
| // re-run the tests locally. |
| delete fileTree("${project.projectDir}/build/wpi-many-tests") { |
| include '**/.cannot-run-wpi' |
| } |
| } |
| |
| doLast { |
| // Run wpi-many.sh |
| def typecheckFilesDir = "${project.projectDir}/build/wpi-many-tests-results/" |
| try { |
| exec { |
| commandLine 'bin/wpi-many.sh', |
| '-i', "${project.projectDir}/tests/wpi-many/testin.txt", |
| '-o', "${project.projectDir}/build/wpi-many-tests", |
| '-s', |
| '--', '--checker', 'nullness,interning,lock,regex,signature' |
| } |
| } catch (Exception e) { |
| println("Failure: Running wpi-many.sh failed with a non-zero exit code.") |
| File wpiOut = new File("${typecheckFilesDir}/wpi-out") |
| if (wpiOut.exists()) { |
| println("========= Output from last run of wpi.sh (${typecheckFilesDir}/wpi-out): ========") |
| exec { |
| commandLine 'cat', "${typecheckFilesDir}/wpi-out" |
| } |
| println("========= End of output from last run of wpi.sh (${typecheckFilesDir}/wpi-out): ========") |
| throw e |
| } |
| } |
| // collect the logs from running WPI |
| def typecheckFiles = fileTree(typecheckFilesDir).matching { |
| include "**/*-typecheck.out" |
| } |
| if (typecheckFiles.size() == 0) { |
| println("Failure: No *-typecheck.out files in ${typecheckFilesDir}") |
| println("========= Output from last run of wpi.sh (${typecheckFilesDir}/wpi-out): ========") |
| exec { |
| commandLine 'cat', "${typecheckFilesDir}/wpi-out" |
| } |
| println("========= End of output from last run of wpi.sh (${typecheckFilesDir}/wpi-out): ========") |
| def logFiles = fileTree(typecheckFilesDir).matching { |
| include "**/*.log" |
| } |
| logFiles.visit { FileVisitDetails details -> |
| def filename = "${typecheckFilesDir}" + details.getName() |
| println("======== printing contents of ${filename} ========") |
| details.getFile().eachLine { line -> println(line) } |
| println("======== end of contents of ${filename} ========") |
| } |
| throw new GradleException("Failure: No *-typecheck.out files in ${project.projectDir}/build/wpi-many-tests-results/") |
| } |
| |
| // check that WPI causes the expected builds to succeed |
| typecheckFiles.visit { FileVisitDetails details -> |
| def filename = "${project.projectDir}/build/wpi-many-tests-results/" + details.getName() |
| def file = details.getFile() |
| if (file.length() == 0) { |
| throw new GradleException("Failure: WPI produced empty typecheck file " + filename) |
| } |
| file.eachLine { line -> |
| if ( |
| // Ignore the line that WPI echoes with the javac command being run. |
| line.startsWith("Running ") |
| // Warnings about bad path elements aren't related to WPI and are ignored. |
| || line.startsWith("warning: [path]") |
| // Ignore the summary line that reports the total number of warnings. |
| || line.endsWith("warnings")) { |
| return; |
| } |
| if (!line.trim().equals("")) { |
| throw new GradleException("Failure: WPI scripts produced an unexpected output in " + filename + ". " + |
| "Failing line is the following: " + line) |
| } |
| } |
| } |
| } |
| } |
| |
| // This is run as part of the inferenceTests task. |
| task wpiPlumeLibTests(group: "Verification") { |
| description 'Tests whole-program inference on the plume-lib projects. Requires an Internet connection.' |
| dependsOn(copyJarsToDist) |
| |
| // This test must always be re-run when requested. |
| outputs.upToDateWhen { false } |
| |
| doLast { |
| exec { |
| commandLine 'bin-devel/wpi-plumelib/test-wpi-plumelib.sh' |
| ignoreExitValue = false |
| } |
| } |
| } |
| |
| apply from: rootProject.file("gradle-mvn-push.gradle") |
| |
| /** Adds information to the publication for uploading to Maven repositories. */ |
| final checkerPom(publication) { |
| sharedPublicationConfiguration(publication) |
| // Don't use publication.from components.java which would publish the skinny jar as checker.jar. |
| publication.pom { |
| name = 'Checker Framework' |
| description = 'The Checker Framework enhances Java\'s type system to\n' + |
| 'make it more powerful and useful. This lets software developers\n' + |
| 'detect and prevent errors in their Java programs.\n' + |
| 'The Checker Framework includes compiler plug-ins ("checkers")\n' + |
| 'that find bugs or verify their absence. It also permits you to\n' + |
| 'write your own compiler plug-ins.' |
| licenses { |
| license { |
| name = 'GNU General Public License, version 2 (GPL2), with the classpath exception' |
| url = 'http://www.gnu.org/software/classpath/license.html' |
| distribution = 'repo' |
| } |
| } |
| } |
| } |
| publishing { |
| publications { |
| checker(MavenPublication) { |
| project.shadow.component it |
| checkerPom it |
| artifact checkerJar |
| artifact allSourcesJar |
| artifact allJavadocJar |
| } |
| } |
| } |
| signing { |
| sign publishing.publications.checker |
| } |
