No deps

.gitignore

@@ -1,17 +1,20 @@
-*.class
 *.log
 
-# sbt specific
-.cache
-.history
-.lib/
-dist/*
+# SBT specific
 target/
-lib_managed/
-src_managed/
 project/boot/
 project/plugins/project/
 
+# Eclipse specific
+.classpath
+.project
+.settings/
+
 # Scala-IDE specific
-.scala_dependencies
-.worksheet
+.cache-main
+.cache-tests
+
+# IntelliJ IDEA specific
+.idea
+.idea_modules
+*.iml

.travis.yml

@@ -0,0 +1,22 @@
+language: scala
+
+script:
+  - sbt ++$TRAVIS_SCALA_VERSION test
+
+matrix:
+  include:
+    - jdk: oraclejdk7
+      scala: 2.10.6
+    - jdk: oraclejdk7
+      scala: 2.11.8
+    - jdk: oraclejdk8
+      scala: 2.12.0-RC1
+
+before_cache:
+  - find "$HOME/.sbt/" -name '*.lock' -print0 | xargs -0 rm
+  - find "$HOME/.ivy2/" -name 'ivydata-*.properties' -print0 | xargs -0 rm
+
+cache:
+  directories:
+    - $HOME/.ivy2/cache
+    - $HOME/.sbt

build.sbt

@@ -0,0 +1,137 @@
+import sbt._
+import sbt.Keys._
+import sbtrelease.ReleasePlugin.autoImport._
+import com.typesafe.sbt.pgp.PgpKeys
+
+
+val Org = "org.scoverage"
+val MockitoVersion = "1.10.19"
+val JUnitInterfaceVersion = "0.9"
+val JUnitVersion = "4.11"
+
+lazy val fullCrossSettings = Seq(
+  crossVersion := CrossVersion.full // because compiler api is not binary compatible
+) ++ allCrossSettings
+
+lazy val binaryCrossSettings = Seq(
+  crossScalaVersions := Seq("2.10.6", "2.11.8", "2.12.0-RC2")
+)
+
+lazy val allCrossSettings = Seq(
+  crossScalaVersions := Seq(
+    "2.10.6",
+    "2.11.8",
+    "2.12.0-M3",
+    "2.12.0-M4",
+    "2.12.0-M5",
+    "2.12.0-RC1-ceaf419",
+    "2.12.0-RC1",
+    "2.12.0-RC1-1e81a09",
+    "2.12.0-RC2")
+)
+
+val appSettings = Seq(
+  organization := Org,
+  scalaVersion := "2.11.8",
+  fork in Test := false,
+  publishMavenStyle := true,
+  publishArtifact in Test := false,
+  parallelExecution in Test := false,
+  scalacOptions := Seq("-unchecked", "-deprecation", "-feature", "-encoding", "utf8"),
+  javacOptions := {
+    CrossVersion.partialVersion(scalaVersion.value) match {
+      case Some((2, scalaMajor)) if scalaMajor < 12 => Seq("-source", "1.7", "-target", "1.7")
+      case _ => Seq()
+    }
+  },
+  libraryDependencies +=
+    "org.scala-lang" % "scala-compiler" % scalaVersion.value % "provided",
+
+  concurrentRestrictions in Global += Tags.limit(Tags.Test, 1),
+  publishTo := {
+    val nexus = "https://oss.sonatype.org/"
+
+    if (isSnapshot.value)
+      Some("snapshots" at nexus + "content/repositories/snapshots")
+    else
+      Some("releases" at nexus + "service/local/staging/deploy/maven2")
+  },
+  pomExtra := {
+    <url>https://github.com/scoverage/scalac-scoverage-plugin-core</url>
+      <licenses>
+        <license>
+          <name>Apache 2</name>
+          <url>http://www.apache.org/licenses/LICENSE-2.0</url>
+          <distribution>repo</distribution>
+        </license>
+      </licenses>
+      <scm>
+        <url>[email protected]:scoverage/scalac-scoverage-plugin-core.git</url>
+        <connection>scm:[email protected]:scoverage/scalac-scoverage-plugin-core.git</connection>
+      </scm>
+      <developers>
+        <developer>
+          <id>sksamuel</id>
+          <name>Stephen Samuel</name>
+          <url>http://github.com/sksamuel</url>
+        </developer>
+      </developers>
+  },
+  pomIncludeRepository := {
+    _ => false
+  }
+) ++ Seq(
+  releaseCrossBuild := true,
+  releasePublishArtifactsAction := PgpKeys.publishSigned.value
+)
+
+lazy val noPublishSettings = Seq(
+  publishArtifact := false,
+  // The above is enough for Maven repos but it doesn't prevent publishing of ivy.xml files
+  publish := {},
+  publishLocal := {}
+)
+
+lazy val junitSettings = Seq(
+  testOptions += Tests.Argument(TestFrameworks.JUnit, "-a", "-v"),
+  libraryDependencies ++= Seq(
+    "com.novocode" % "junit-interface" % JUnitInterfaceVersion % "test",
+    "junit" % "junit" % JUnitVersion % "test"
+  )
+)
+
+lazy val root = Project("scalac-scoverage", file("."))
+  .settings(name := "scalac-scoverage")
+  .settings(appSettings: _*)
+  .settings(allCrossSettings)
+  .settings(noPublishSettings)
+  .aggregate(plugin, runtimeJava, runtimeScala, pluginTests)
+
+lazy val runtimeJava = Project("scalac-scoverage-runtime-java", file("scalac-scoverage-runtime-java"))
+  .settings(name := "scalac-scoverage-runtime-java")
+  .settings(appSettings: _*)
+  .settings(binaryCrossSettings)
+  .settings(junitSettings)
+  .dependsOn(pluginTests % "test->compile")
+
+lazy val runtimeScala = Project("scalac-scoverage-runtime-scala", file("scalac-scoverage-runtime-scala"))
+  .settings(name := "scalac-scoverage-runtime-scala")
+  .settings(appSettings: _*)
+  .settings(binaryCrossSettings)
+  .settings(junitSettings)
+  .dependsOn(pluginTests % "test->compile")
+
+lazy val plugin = Project("scalac-scoverage-plugin", file("scalac-scoverage-plugin"))
+  .settings(name := "scalac-scoverage-plugin")
+  .settings(appSettings: _*)
+  .settings(fullCrossSettings)
+
+lazy val pluginTests = Project("scalac-scoverage-plugin-tests", file("scalac-scoverage-plugin-tests"))
+  .dependsOn(plugin)
+  .settings(name := "scalac-scoverage-plugin-tests")
+  .settings(appSettings: _*)
+  .settings(binaryCrossSettings)
+  .settings(libraryDependencies ++= Seq(
+    "org.mockito" % "mockito-all" % MockitoVersion,
+    "com.novocode" % "junit-interface" % JUnitInterfaceVersion
+  ))

project/build.properties

@@ -0,0 +1 @@
+sbt.version=0.13.12

project/plugins.sbt

@@ -0,0 +1,5 @@
+addSbtPlugin("org.scalastyle" %% "scalastyle-sbt-plugin" % "0.8.0")
+
+addSbtPlugin("com.jsuereth" % "sbt-pgp" % "1.0.1")
+
+addSbtPlugin("com.github.gseitz" % "sbt-release" % "1.0.3")

scalac-scoverage-plugin-tests/src/main/scala/scoverage/AssertUtil.scala

@@ -0,0 +1,14 @@
+package scoverage
+
+import scala.xml.Node
+
+object AssertUtil {
+
+  implicit class TypedOps[A](v1: A) {
+    def ===(v2: A): Boolean = v1 == v2
+  }
+
+  implicit class NodeOps(n1: Node) {
+    def ===(n2: Node): Boolean = n1.strict_==(n2)
+  }
+}

scalac-scoverage-plugin-tests/src/main/scala/scoverage/CoverageTest.scala

@@ -0,0 +1,35 @@
+package scoverage
+
+import AssertUtil._
+import org.junit.Assert._
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+
+/** @author Stephen Samuel */
+@RunWith(classOf[JUnit4])
+class CoverageTest {
+
+  @Test
+  def coverageForNoStatementsIs1() = {
+    val coverage = Coverage()
+    assertTrue(1.0 === coverage.statementCoverage)
+  }
+
+  @Test
+  def coverageForNoInvokedStatementsIs0() = {
+    val coverage = Coverage()
+    coverage.add(Statement("", Location("", "", "", ClassType.Object, "", ""), 1, 2, 3, 4, "", "", "", false, 0))
+    assertTrue(0.0 === coverage.statementCoverage)
+  }
+
+  @Test
+  def coverageForInvokedStatements() = {
+    val coverage = Coverage()
+    coverage.add(Statement("", Location("", "", "", ClassType.Object, "", ""), 1, 2, 3, 4, "", "", "", false, 3))
+    coverage.add(Statement("", Location("", "", "", ClassType.Object, "", ""), 2, 2, 3, 4, "", "", "", false, 0))
+    coverage.add(Statement("", Location("", "", "", ClassType.Object, "", ""), 3, 2, 3, 4, "", "", "", false, 0))
+    coverage.add(Statement("", Location("", "", "", ClassType.Object, "", ""), 4, 2, 3, 4, "", "", "", false, 0))
+    assertTrue(0.25 === coverage.statementCoverage)
+  }
+}

scalac-scoverage-plugin-tests/src/main/scala/scoverage/IOUtilsTest.scala

@@ -0,0 +1,83 @@
+package scoverage
+
+import java.io.{File, FileWriter}
+import java.util.UUID
+
+import AssertUtil._
+import org.junit.Assert._
+import org.junit.{After, Before, Test}
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+
+/** @author Stephen Samuel */
+@RunWith(classOf[JUnit4])
+class IOUtilsTest {
+
+  val base = new File(IOUtils.getTempDirectory, UUID.randomUUID.toString)
+
+  @Before def setup(): Unit = {
+    base.mkdir()
+  }
+
+  @Test
+  def shouldParseMeasurementFiles() = {
+    val file = newTempFile("scoveragemeasurementtest.txt")
+    val writer = new FileWriter(file)
+    writer.write("1\n5\n9\n\n10\n")
+    writer.close()
+    val invokedSet = IOUtils.invoked(Seq(file)).toSet
+
+    assertTrue(invokedSet === Set(1, 5, 9, 10))
+  }
+
+  @Test
+  def shouldParseMultipleMeasurementFiles() = {
+    val file1 = newTempFile("scoverage.measurements.11.txt")
+    val writer1 = new FileWriter(file1)
+    writer1.write("1\n5\n9\n\n10\n")
+    writer1.close()
+    val file2 = newTempFile("scoverage.measurements.22.txt")
+    val writer2 = new FileWriter(file2)
+    writer2.write("1\n7\n14\n\n2\n")
+    writer2.close()
+
+    val files = IOUtils.findMeasurementFiles(file1.getParent)
+    val invokedSet = IOUtils.invoked(files).toSet
+
+    assertTrue(invokedSet === Set(1, 2, 5, 7, 9, 10, 14))
+  }
+
+  @Test
+  def shouldDeepSearchForReportFiles() = {
+
+    val file1 = newTempFile(Constants.XMLReportFilename)
+    val writer1 = new FileWriter(file1)
+    writer1.write("1\n3\n5\n\n\n7\n")
+    writer1.close()
+
+    val file2 = newTempFile(UUID.randomUUID + "/" + Constants.XMLReportFilename)
+    file2.getParentFile.mkdir()
+    val writer2 = new FileWriter(file2)
+    writer2.write("2\n4\n6\n\n8\n")
+    writer2.close()
+
+    val file3 = new File(file2.getParent + "/" + UUID.randomUUID + "/" + Constants.XMLReportFilename)
+    file3.getParentFile.mkdir()
+    val writer3 = new FileWriter(file3)
+    writer3.write("11\n20\n30\n\n44\n")
+    writer3.close()
+
+    val files = IOUtils.reportFileSearch(base, IOUtils.isReportFile)
+    val invokedSet = IOUtils.invoked(files).toSet
+
+    assertTrue(invokedSet === Set(1, 2, 3, 4, 5, 6, 7, 8, 11, 20, 30, 44))
+  }
+
+  @After def cleanup(): Unit = {
+    base.delete()
+  }
+
+  private def newTempFile(file: String): File = {
+    new File(s"$base/$file")
+  }
+}

scalac-scoverage-plugin-tests/src/main/scala/scoverage/InvokerConcurrencyTest.scala

@@ -0,0 +1,63 @@
+package scoverage
+
+import java.io.File
+import java.util.UUID
+import java.util.concurrent.Executors
+
+import AssertUtil._
+import org.junit.Assert._
+import org.junit.{After, Before, Test}
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+
+import scala.collection.breakOut
+import scala.concurrent._
+import scala.concurrent.duration._
+
+/**
+ * Verify that the runtime is thread-safe
+ */
+@RunWith(classOf[JUnit4])
+class InvokerConcurrencyTest {
+
+  implicit val executor = ExecutionContext.fromExecutor(Executors.newFixedThreadPool(8))
+
+  val measurementDir = new File(IOUtils.getTempDirectory, UUID.randomUUID.toString)  //"target/invoker-test.measurement.concurrent")
+
+  @Before def setup(): Unit =  {
+    deleteMeasurementFiles()
+    measurementDir.mkdirs()
+  }
+
+  @Test
+  def callingInvokerInvokedOnMultipleThreadsDoesNotCorruptTheMeasurementFile() = {
+
+    val testIds: Set[Int] = (1 to 1000).toSet
+
+    // Create 1k "invoked" calls on the common thread pool, to stress test
+    // the method
+    val futures: List[Future[Unit]] = testIds.map { i: Int =>
+      Future {
+        Invoker.invoked(i, measurementDir.toString)
+      }
+    }(breakOut)
+
+    futures.foreach(Await.result(_, 1.second))
+
+    // Now verify that the measurement file is not corrupted by loading it
+    val measurementFiles = IOUtils.findMeasurementFiles(measurementDir)
+    val idsFromFile = IOUtils.invoked(measurementFiles).toSet
+
+    assertTrue(idsFromFile === testIds)
+  }
+
+  @After def cleanup(): Unit = {
+    deleteMeasurementFiles()
+    measurementDir.delete()
+  }
+
+  private def deleteMeasurementFiles(): Unit = {
+    if (measurementDir.isDirectory)
+      measurementDir.listFiles().foreach(_.delete())
+  }
+}