Merge remote-tracking branch 'origin/master' into scoverage_1_4_0

Conflicts:
	src/functionalTest/java/org.scoverage/ScalaSingleModuleTest.java
	src/main/groovy/org/scoverage/ScoveragePlugin.groovy
	src/main/groovy/org/scoverage/ScoverageReport.groovy

Author: maiflai

src/functionalTest/java/org.scoverage/DetectScalaLibraryTest.java

@@ -0,0 +1,47 @@
+package org.scoverage;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+import java.util.Arrays;
+import java.util.Collection;
+
+@RunWith(Parameterized.class)
+public class DetectScalaLibraryTest extends ScoverageFunctionalTest {
+
+    private static final String SCALA_VERSION = "2.12";
+    private static final String SCALA_LIBRARY_PARAMETER = "-PdetectedScalaLibraryVersion=";
+
+    private static final String EXPECTED_OUTPUT_A = "Detected scala library in compilation classpath";
+    private static final String EXPECTED_OUTPUT_B = "Using scoverage scalac plugin version '" + SCALA_VERSION;
+
+    @Parameterized.Parameter(0)
+    public String projectDir;
+
+    @Parameterized.Parameters(name = "{index}: Project {0} ")
+    public static Collection<Object[]> data() {
+        Object[][] data = new Object[][]{{"/compile"}, {"/compileOnly"}, {"/implementation"}, {"/dependency-management"}};
+        return Arrays.asList(data);
+    }
+
+    public DetectScalaLibraryTest() {
+        super(null);
+    }
+
+    @Test
+    public void test() {
+        setProjectName("detect-scala-library" + projectDir);
+        testWithParameter(SCALA_LIBRARY_PARAMETER + SCALA_VERSION + ".0");
+        testWithParameter(SCALA_LIBRARY_PARAMETER + SCALA_VERSION + ".+");
+    }
+
+    private void testWithParameter(String parameter) {
+        AssertableBuildResult result = dryRun("clean", parameter, "--info");
+        String output = result.getResult().getOutput();
+        Assert.assertTrue(output.contains(EXPECTED_OUTPUT_A));
+        Assert.assertTrue(output.contains(EXPECTED_OUTPUT_B));
+    }
+
+}

src/functionalTest/java/org.scoverage/ScalaMultiModuleTest.java

@@ -36,12 +36,38 @@ public void reportScoverageOnlyRoot() {
     @Test
     public void reportScoverageOnlyA() {
 
-        AssertableBuildResult result = dryRun("clean", ":a:" + ScoveragePlugin.getREPORT_NAME());
+        AssertableBuildResult result = run("clean", ":a:" + ScoveragePlugin.getREPORT_NAME());
 
         result.assertTaskDoesntExist(ScoveragePlugin.getREPORT_NAME());
-        result.assertTaskExists("a:" + ScoveragePlugin.getREPORT_NAME());
         result.assertTaskDoesntExist("b:" + ScoveragePlugin.getREPORT_NAME());
         result.assertTaskDoesntExist("common:" + ScoveragePlugin.getREPORT_NAME());
+
+        result.assertTaskSucceeded("a:" + ScoveragePlugin.getCOMPILE_NAME());
+        result.assertTaskSucceeded("a:" + ScoveragePlugin.getREPORT_NAME());
+
+        assertAReportFilesExist();
+    }
+
+    @Test
+    public void reportScoverageOnlyAWithoutNormalCompilation() {
+
+        AssertableBuildResult result = run("clean", ":a:" + ScoveragePlugin.getREPORT_NAME(),
+                "-x", "compileScala");
+
+        result.assertTaskSkipped("compileScala");
+        result.assertTaskSkipped("a:compileScala");
+        result.assertTaskSkipped("common:compileScala");
+        result.assertTaskSucceeded("common:" + ScoveragePlugin.getCOMPILE_NAME());
+        result.assertTaskSucceeded("a:" + ScoveragePlugin.getCOMPILE_NAME());
+        result.assertTaskSucceeded("a:" + ScoveragePlugin.getREPORT_NAME());
+
+        assertAReportFilesExist();
+
+        Assert.assertTrue(resolve(buildDir(resolve(projectDir(), "a")), "classes/scala/main/org/hello/a/WorldA.class").exists());
+        Assert.assertFalse(resolve(buildDir(resolve(projectDir(), "a")), "classes/scala/scoverage/org/hello/a/WorldA.class").exists());
+
+        Assert.assertTrue(resolve(buildDir(resolve(projectDir(), "common")), "classes/scala/main/org/hello/common/WorldCommon.class").exists());
+        Assert.assertFalse(resolve(buildDir(resolve(projectDir(), "common")), "classes/scala/scoverage/org/hello/common/WorldCommon.class").exists());
     }
 
     @Test

src/functionalTest/java/org.scoverage/ScalaSingleModuleTest.java

@@ -133,15 +133,6 @@ public void reportScoverageWithoutNormalCompilationAndWithExcludedClasses() thro
         Assert.assertFalse(resolve(buildDir(), "classes/scala/scoverage/org/hello/World.class").exists());
     }
 
-    @Test
-    public void reportScoverageUnder2_11() throws Exception {
-        run("clean", ScoveragePlugin.getREPORT_NAME(),
-                "-PscalaVersionMinor=11",
-                "-PscalaVersionBuild=8",
-                "-Pscoverage.scoverageScalaVersion=2_11");
-        assertReportFilesExist();
-    }
-
     @Test
     public void reportScoverageUnder2_13() throws Exception {
         run("clean", ScoveragePlugin.getREPORT_NAME(),

src/functionalTest/java/org.scoverage/ScoverageFunctionalTest.java

@@ -23,18 +23,12 @@
 
 public abstract class ScoverageFunctionalTest {
 
-    private final String projectName;
-    private final GradleRunner runner;
+    private String projectName;
+    private GradleRunner runner;
     private final XmlParser parser;
 
     protected ScoverageFunctionalTest(String projectName) {
-
-        this.projectName = projectName;
-        this.runner = GradleRunner.create()
-                .withProjectDir(projectDir())
-                .withPluginClasspath()
-                .forwardOutput();
-
+        setProjectName(projectName);
         try {
             this.parser = new XmlParser();
             parser.setFeature("http://apache.org/xml/features/disallow-doctype-decl", false);
@@ -44,6 +38,16 @@ protected ScoverageFunctionalTest(String projectName) {
         }
     }
 
+    protected void setProjectName(String projectName) {
+        if (projectName != null) {
+            this.projectName = projectName;
+            this.runner = GradleRunner.create()
+                    .withProjectDir(projectDir())
+                    .withPluginClasspath()
+                    .forwardOutput();
+        }
+    }
+
     protected File projectDir() {
 
         return new File("src/functionalTest/resources/projects/" + projectName);

src/functionalTest/resources/projects/detect-scala-library/compile/build.gradle

@@ -0,0 +1,13 @@
+plugins {
+    id 'org.scoverage'
+}
+
+repositories {
+    jcenter()
+}
+
+description = 'defines scala library using the "compile" configuration'
+
+dependencies {
+    compile group: 'org.scala-lang', name: 'scala-library', version: "${detectedScalaLibraryVersion}"
+}

src/functionalTest/resources/projects/detect-scala-library/compile/settings.gradle

@@ -0,0 +1,13 @@
+plugins {
+    id 'org.scoverage'
+}
+
+repositories {
+    jcenter()
+}
+
+description = 'defines scala library using the "compileOnly" configuration'
+
+dependencies {
+    compileOnly group: 'org.scala-lang', name: 'scala-library', version: "${detectedScalaLibraryVersion}"
+}

src/functionalTest/resources/projects/detect-scala-library/compileOnly/build.gradle

@@ -0,0 +1,20 @@
+plugins {
+    id 'io.spring.dependency-management' version "1.0.4.RELEASE"
+    id 'org.scoverage'
+}
+
+repositories {
+    jcenter()
+}
+
+description = 'defines scala library using the "implementation" configuration and the dependency-management plugin'
+
+dependencyManagement {
+    dependencies {
+        dependency group: 'org.scala-lang', name: 'scala-library', version: "${detectedScalaLibraryVersion}"
+    }
+}
+
+dependencies {
+    implementation group: 'org.scala-lang', name: 'scala-library'
+}

src/functionalTest/resources/projects/detect-scala-library/compileOnly/settings.gradle

@@ -0,0 +1,13 @@
+plugins {
+    id 'org.scoverage'
+}
+
+repositories {
+    jcenter()
+}
+
+description = 'defines scala library using the "implementation" configuration'
+
+dependencies {
+    implementation group: 'org.scala-lang', name: 'scala-library', version: "${detectedScalaLibraryVersion}"
+}

src/functionalTest/resources/projects/detect-scala-library/dependency-management/build.gradle

@@ -23,6 +23,9 @@ class ScoverageAggregate extends DefaultTask {
     @Input
     final Property<Boolean> deleteReportsOnAggregation = project.objects.property(Boolean)
 
+    @Input
+    final Property<String> sourceEncoding = project.objects.property(String)
+
     // TODO - consider separate options for `report` and `aggregate` tasks
     @Input
     final Property<Boolean> coverageOutputCobertura = project.objects.property(Boolean)
@@ -50,6 +53,7 @@ class ScoverageAggregate extends DefaultTask {
                         project.projectDir,
                         reportDir.get(),
                         coverage.get(),
+                        sourceEncoding.get(),
                         coverageOutputCobertura.get(),
                         coverageOutputXML.get(),
                         coverageOutputHTML.get(),