Added branch coverage

Author: sksamuel

src/main/scala/scales/InstrumentationRuntime.scala

@@ -19,9 +19,10 @@ object InstrumentationRuntime {
  location: Location,
  start: Int,
  line: Int,
- desc: String) = {
+ desc: String,
+ branch: Boolean) = {
  val id = ids.incrementAndGet()
- val stmt = MeasuredStatement(location, id, start, line, desc)
+ val stmt = MeasuredStatement(location, id, start, line, desc, branch)
  coverage.add(stmt)
  stmt
  }

src/main/scala/scales/coverage.scala

@@ -6,7 +6,7 @@ import scala.reflect.internal.util.SourceFile
 /**
  * @author Stephen Samuel */
 class Coverage
- extends StatementCoverage with
+ extends CoverageMetrics with
  MethodBuilders with
  java.io.Serializable with
  ClassBuilders with
@@ -49,18 +49,18 @@ trait ClassBuilders {
  def classCount: Int = classes.size
 }
 
-case class MeasuredMethod(name: String, statements: Iterable[MeasuredStatement]) extends StatementCoverage
+case class MeasuredMethod(name: String, statements: Iterable[MeasuredStatement]) extends CoverageMetrics
 
 case class MeasuredClass(name: String, statements: Iterable[MeasuredStatement])
- extends StatementCoverage with MethodBuilders with Numerics
+ extends CoverageMetrics with MethodBuilders with Numerics
 
 case class MeasuredPackage(name: String, statements: Iterable[MeasuredStatement])
- extends StatementCoverage with ClassCoverage with ClassBuilders {
+ extends CoverageMetrics with ClassCoverage with ClassBuilders {
  def files = Nil //statements.groupBy(_.source).map(arg => MeasuredFile(arg._1, arg._2))
 }
 
 case class MeasuredFile(source: SourceFile, statements: Iterable[MeasuredStatement])
- extends StatementCoverage with ClassCoverage with ClassBuilders {
+ extends CoverageMetrics with ClassCoverage with ClassBuilders {
  def lineStatus(lineNumber: Int): LineStatus = {
  statements.filter(_.line == lineNumber) match {
  case i if i.isEmpty => NotInstrumented
@@ -78,6 +78,7 @@ case class MeasuredStatement(location: Location,
  start: Int,
  line: Int,
  desc: String,
+ branch: Boolean,
  var count: Int = 0) extends java.io.Serializable {
  def invoked(): Unit = count = count + 1
 }
@@ -87,17 +88,24 @@ trait Numerics {
  def loc = statements.map(stmt => stmt.location.fqn + ":" + stmt.line).toSet.size
 }
 
-case class Location(_package: String, _class: String, classType: ClassType, method: Option[String])
+case class Location(_package: String, _class: String, classType: ClassType, method: String)
  extends java.io.Serializable {
  val fqn = (_package + ".").replace("<empty>.", "") + _class
 }
 
-trait StatementCoverage {
+trait CoverageMetrics {
  val statements: Iterable[MeasuredStatement]
- def statementCoverage: Double = invokedStatements / statements.size.toDouble
+ def statementCount: Int = statements.count(!_.branch)
+ def invokedStatements: Iterable[MeasuredStatement] = statements.filter(_.count > 0)
+ def invokedStatementCount = invokedStatements.size
+ def statementCoverage: Double = invokedStatements / statementCount.toDouble
  def statementCoverageFormatted: String = "%.2f".format(statementCoverage * 100)
- def statementCount: Int = statements.size
- def invokedStatements: Int = statements.count(_.count > 0)
+ def branches: Iterable[MeasuredStatement] = statements.filter(_.branch)
+ def branchCount: Int = branches.size
+ def invokedBranches: Iterable[MeasuredStatement] = branches.filter(_.count > 0)
+ def invokedBranchesCount = invokedBranches.size
+ def branchCoverage: Double = invokedBranchesCount / branchCount.toDouble
+ def branchCoverageFormatted: String = "%.2f".format(branchCoverage * 100)
 }
 
 trait ClassCoverage {

src/main/scala/scales/plugin.scala

@@ -52,7 +52,11 @@ class ScalesComponent(val global: Global)
 
  // instrument the given case defintions not changing the patterns or guards
  def transformCases(cases: List[CaseDef]): List[CaseDef] = {
- cases.map(c => treeCopy.CaseDef(c, c.pat, c.guard, instrument(c.body)))
+ cases.map(c => treeCopy.CaseDef(c, c.pat, c.guard, instrument(instrument(c.body), true)))
+ }
+
+ def transformIf(tree: Tree) = {
+ instrument(process(tree), true)
  }
 
  // Creates a call to the invoker
@@ -76,12 +80,12 @@ class ScalesComponent(val global: Global)
  def safeSource(tree: Tree): Option[SourceFile] = if (tree.pos.isDefined) Some(tree.pos.source) else None
 
  // wraps the given tree with an Instrumentation call
- def instrument(tree: Tree) = {
+ def instrument(tree: Tree, branch: Boolean = false) = {
  safeSource(tree) match {
  case None => tree
  case Some(source) =>
  val instruction =
- InstrumentationRuntime.add(source, location, safeStart(tree), safeLine(tree), tree.toString())
+ InstrumentationRuntime.add(source, location, safeStart(tree), safeLine(tree), tree.toString(), branch)
  val apply = invokeCall(instruction.id)
  val block = Block(apply, tree)
  localTyper.typed(atPos(tree.pos)(block))
@@ -125,10 +129,10 @@ class ScalesComponent(val global: Global)
  //registerClass(c)
  super.transform(tree)
 
- case t: Template => treeCopy.Template(tree, t.parents, t.self, transformStatements(t.body))
+ case t: Template =>
+ treeCopy.Template(tree, t.parents, t.self, transformStatements(t.body))
 
  case _: TypeTree => super.transform(tree)
- case _: If => super.transform(tree)
  case _: Ident => super.transform(tree)
  case _: Block => super.transform(tree)
 
@@ -171,7 +175,7 @@ class ScalesComponent(val global: Global)
  super.transform(tree)
 
  case d: DefDef if d.symbol.isCaseApplyOrUnapply =>
- println("Case apply/unapply")
+ println("Case apply/unapply " + d)
  updateLocation(d.symbol)
  super.transform(tree)
 
@@ -180,6 +184,9 @@ class ScalesComponent(val global: Global)
  updateLocation(d.symbol)
  super.transform(tree)
 
+ case i: If =>
+ treeCopy.If(i, i.cond, transformIf(i.thenp), transformIf(i.elsep))
+
  // should only occur inside something we are instrumenting.
  case s: Select =>
  super.transform(tree)