Simplify validation test setup (#718)

36 files changed, 503 insertions, 903 deletions

diff --git a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/AnnotationInitializerTest.java b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/AnnotationInitializerTest.java
index 7286cd13..c04826a1 100644
--- a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/AnnotationInitializerTest.java
+++ b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/AnnotationInitializerTest.java
@@ -11,12 +11,10 @@
  *******************************************************************************/
 package org.jacoco.core.test.validation.java5;
 
-import org.jacoco.core.analysis.ICounter;
+import static org.junit.Assert.assertEquals;
+
 import org.jacoco.core.test.validation.ValidationTestBase;
 import org.jacoco.core.test.validation.java5.targets.AnnotationInitializerTarget;
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
 
 /**
  * Test of initializer in annotations.
@@ -39,10 +37,4 @@ public class AnnotationInitializerTest extends ValidationTestBase {
 		targetClass.getField("CONST").get(null);
 	}
 
-	@Test
-	public void testCoverageResult() {
-		assertLine("const", ICounter.FULLY_COVERED);
-		assertLine("value", ICounter.EMPTY);
-	}
-
 }
diff --git a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/BadCycleClassTest.java b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/BadCycleClassTest.java
index da53f5a0..4ae12f09 100644
--- a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/BadCycleClassTest.java
+++ b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/BadCycleClassTest.java
@@ -11,7 +11,6 @@
  *******************************************************************************/
 package org.jacoco.core.test.validation.java5;
 
-import org.jacoco.core.analysis.ICounter;
 import org.jacoco.core.test.validation.ValidationTestBase;
 import org.jacoco.core.test.validation.java5.targets.BadCycleClassTarget;
 import org.junit.Test;
@@ -26,11 +25,7 @@ public class BadCycleClassTest extends ValidationTestBase {
 	}
 
 	@Test
-	public void test() throws Exception {
-		assertLine("childinit", ICounter.FULLY_COVERED);
-		assertLine("childsomeMethod", ICounter.FULLY_COVERED);
-		assertLine("childclinit", ICounter.FULLY_COVERED);
-
+	public void method_execution_sequence() throws Exception {
 		// The cycle causes a constructor and instance method to be called
 		// before the static initializer of a class:
 		assertLogEvents("childinit", "childsomeMethod", "childclinit",
diff --git a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/BooleanExpressionsTest.java b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/BooleanExpressionsTest.java
index f91e1c10..5335ca89 100644
--- a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/BooleanExpressionsTest.java
+++ b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/BooleanExpressionsTest.java
@@ -11,10 +11,8 @@
  *******************************************************************************/
 package org.jacoco.core.test.validation.java5;
 
-import org.jacoco.core.analysis.ICounter;
 import org.jacoco.core.test.validation.ValidationTestBase;
 import org.jacoco.core.test.validation.java5.targets.BooleanExpressionsTarget;
-import org.junit.Test;
 
 /**
  * Tests of basic Java boolean expressions.
@@ -25,56 +23,4 @@ public class BooleanExpressionsTest extends ValidationTestBase {
 		super(BooleanExpressionsTarget.class);
 	}
 
-	@Test
-	public void testCoverageResult() {
-
-		// 1. Boolean comparison result (one case)
-		assertLine("booleancmp1", ICounter.PARTLY_COVERED, 1, 1);
-
-		// 2. Boolean comparison result (both cases)
-		assertLine("booleancmp2", ICounter.FULLY_COVERED, 0, 2);
-
-		// 3. And
-		assertLine("andFF", ICounter.FULLY_COVERED, 1, 1);
-		assertLine("andFT", ICounter.FULLY_COVERED, 1, 1);
-		assertLine("andTF", ICounter.FULLY_COVERED, 1, 1);
-		assertLine("andTT", ICounter.FULLY_COVERED, 1, 1);
-
-		// 4. Conditional And
-		assertLine("conditionalandFF", ICounter.PARTLY_COVERED, 3, 1);
-		assertLine("conditionalandFT", ICounter.PARTLY_COVERED, 3, 1);
-		assertLine("conditionalandTF", ICounter.FULLY_COVERED, 2, 2);
-		assertLine("conditionalandTT", ICounter.FULLY_COVERED, 2, 2);
-
-		// 5. Or
-		assertLine("orFF", ICounter.FULLY_COVERED, 1, 1);
-		assertLine("orFT", ICounter.FULLY_COVERED, 1, 1);
-		assertLine("orTF", ICounter.FULLY_COVERED, 1, 1);
-		assertLine("orTT", ICounter.FULLY_COVERED, 1, 1);
-
-		// 6. Conditional Or
-		assertLine("conditionalorFF", ICounter.FULLY_COVERED, 2, 2);
-		assertLine("conditionalorFT", ICounter.FULLY_COVERED, 2, 2);
-		assertLine("conditionalorTF", ICounter.PARTLY_COVERED, 3, 1);
-		assertLine("conditionalorTT", ICounter.PARTLY_COVERED, 3, 1);
-
-		// 7. Exclusive Or
-		assertLine("xorFF", ICounter.FULLY_COVERED, 1, 1);
-		assertLine("xorFT", ICounter.FULLY_COVERED, 1, 1);
-		assertLine("xorTF", ICounter.FULLY_COVERED, 1, 1);
-		assertLine("xorTT", ICounter.FULLY_COVERED, 1, 1);
-
-		// 8. Conditional Operator
-		assertLine("condT", ICounter.PARTLY_COVERED, 1, 1);
-		assertLine("condF", ICounter.PARTLY_COVERED, 1, 1);
-
-		// 9. Not (one case)
-		assertLine("notT", ICounter.PARTLY_COVERED, 1, 1);
-		assertLine("notF", ICounter.PARTLY_COVERED, 1, 1);
-
-		// 10. Not (both cases)
-		assertLine("notTF", ICounter.FULLY_COVERED, 0, 2);
-
-	}
-
 }
diff --git a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/ClassInitializerTest.java b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/ClassInitializerTest.java
index 8df6e8d8..7b1959de 100644
--- a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/ClassInitializerTest.java
+++ b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/ClassInitializerTest.java
@@ -11,10 +11,8 @@
  *******************************************************************************/
 package org.jacoco.core.test.validation.java5;
 
-import org.jacoco.core.analysis.ICounter;
 import org.jacoco.core.test.validation.ValidationTestBase;
 import org.jacoco.core.test.validation.java5.targets.ClassInitializerTarget;
-import org.junit.Test;
 
 /**
  * Tests of static initializer in classes.
@@ -25,21 +23,4 @@ public class ClassInitializerTest extends ValidationTestBase {
 		super(ClassInitializerTarget.class);
 	}
 
-	@Test
-	public void testCoverageResult() {
-
-		assertLine("const1", ICounter.EMPTY);
-		assertLine("const2", ICounter.EMPTY);
-
-		assertLine("const3", ICounter.FULLY_COVERED);
-		assertLine("const4", ICounter.FULLY_COVERED);
-
-		assertLine("field1", ICounter.FULLY_COVERED);
-		assertLine("field2", ICounter.FULLY_COVERED);
-		assertLine("field3", ICounter.FULLY_COVERED);
-		assertLine("field4", ICounter.FULLY_COVERED);
-
-		assertLine("staticblock", ICounter.FULLY_COVERED);
-	}
-
 }
diff --git a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/ConstructorsTest.java b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/ConstructorsTest.java
index 4c3ed6ac..a9980116 100644
--- a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/ConstructorsTest.java
+++ b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/ConstructorsTest.java
@@ -11,10 +11,8 @@
  *******************************************************************************/
 package org.jacoco.core.test.validation.java5;
 
-import org.jacoco.core.analysis.ICounter;
 import org.jacoco.core.test.validation.ValidationTestBase;
 import org.jacoco.core.test.validation.java5.targets.ConstructorsTarget;
-import org.junit.Test;
 
 /**
  * Tests for different constructors. Private empty constructors without
@@ -26,38 +24,4 @@ public class ConstructorsTest extends ValidationTestBase {
 		super(ConstructorsTarget.class);
 	}
 
-	@Test
-	public void testCoverageResult() {
-		// not filtered because not private:
-		assertLine("packageLocal", ICounter.FULLY_COVERED);
-
-		// not filtered because has argument:
-		assertLine("arg", ICounter.FULLY_COVERED);
-
-		// not filtered because not empty - prepares arguments for super
-		// constructor:
-		assertLine("super", ICounter.FULLY_COVERED);
-
-		// not filtered because contains initialization of a field to hold
-		// reference to an instance of outer class that is passed as an
-		// argument:
-		assertLine("inner", ICounter.FULLY_COVERED);
-
-		// not filtered because not empty - contains initialization of
-		// a field:
-		assertLine("innerStatic", ICounter.FULLY_COVERED);
-
-		// not filtered because default constructor for not private inner
-		// classes is not private:
-		assertLine("publicDefault", ICounter.FULLY_COVERED);
-		assertLine("packageLocalDefault", ICounter.FULLY_COVERED);
-
-		assertLine("privateDefault", ICounter.EMPTY);
-
-		assertLine("privateNonEmptyNoArg", ICounter.FULLY_COVERED);
-
-		assertLine("privateEmptyNoArg", ICounter.EMPTY);
-		assertLine("return", ICounter.EMPTY);
-	}
-
 }
diff --git a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/ControlStructureBeforeSuperConstructorTest.java b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/ControlStructureBeforeSuperConstructorTest.java
index d381887a..4d14d241 100644
--- a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/ControlStructureBeforeSuperConstructorTest.java
+++ b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/ControlStructureBeforeSuperConstructorTest.java
@@ -11,25 +11,17 @@
  *******************************************************************************/
 package org.jacoco.core.test.validation.java5;
 
-import org.jacoco.core.analysis.ICounter;
 import org.jacoco.core.test.validation.ValidationTestBase;
 import org.jacoco.core.test.validation.java5.targets.ControlStructureBeforeSuperConstructorTarget;
-import org.junit.Test;
 
 /**
  * Test of probes before the super constructor call.
  */
-public class ControlStructureBeforeSuperConstructorTest extends ValidationTestBase {
+public class ControlStructureBeforeSuperConstructorTest
+		extends ValidationTestBase {
 
 	public ControlStructureBeforeSuperConstructorTest() {
 		super(ControlStructureBeforeSuperConstructorTarget.class);
 	}
 
-	@Test
-	public void testCoverageResult() {
-
-		assertLine("super", ICounter.PARTLY_COVERED, 3, 1);
-
-	}
-
 }
diff --git a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/ControlStructuresTest.java b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/ControlStructuresTest.java
index 768312fc..b62ab738 100644
--- a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/ControlStructuresTest.java
+++ b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/ControlStructuresTest.java
@@ -11,10 +11,8 @@
  *******************************************************************************/
 package org.jacoco.core.test.validation.java5;
 
-import org.jacoco.core.analysis.ICounter;
 import org.jacoco.core.test.validation.ValidationTestBase;
 import org.jacoco.core.test.validation.java5.targets.ControlStructuresTarget;
-import org.junit.Test;
 
 /**
  * Tests of basic Java control structures.
@@ -25,114 +23,4 @@ public class ControlStructuresTest extends ValidationTestBase {
 		super(ControlStructuresTarget.class);
 	}
 
-	@Test
-	public void testCoverageResult() {
-
-		// 1. Direct unconditional execution
-		assertLine("unconditional", ICounter.FULLY_COVERED);
-
-		// 2. Missed if block
-		assertLine("iffalse", ICounter.FULLY_COVERED, 1, 1);
-		assertLine("missedif", ICounter.NOT_COVERED);
-		assertLine("executedelse", ICounter.FULLY_COVERED);
-
-		// 3. Executed if block
-		assertLine("iftrue", ICounter.FULLY_COVERED, 1, 1);
-		assertLine("executedif", ICounter.FULLY_COVERED);
-		assertLine("missedelse", ICounter.NOT_COVERED);
-
-		// 4. Missed while block
-		assertLine("whilefalse", ICounter.FULLY_COVERED, 1, 1);
-		assertLine("missedwhile", ICounter.NOT_COVERED);
-
-		// 5. Always true while block
-		assertLine("whiletrue", ICounter.FULLY_COVERED, 1, 1);
-
-		// 6. Executed while block
-		assertLine("whiletruefalse", ICounter.FULLY_COVERED, 0, 2);
-		assertLine("executedwhile", ICounter.FULLY_COVERED);
-
-		// 7. Executed do while block
-		assertLine("executeddowhile", ICounter.FULLY_COVERED);
-		assertLine("executeddowhilefalse", ICounter.FULLY_COVERED, 1, 1);
-
-		// 8. Missed for block
-		assertLine("missedforincrementer", ICounter.PARTLY_COVERED, 1, 1);
-		assertLine("missedfor", ICounter.NOT_COVERED);
-
-		// 9. Executed for block
-		assertLine("executedforincrementer", ICounter.FULLY_COVERED, 0, 2);
-		assertLine("executedfor", ICounter.FULLY_COVERED);
-
-		// 10. Missed for each block
-		assertLine("missedforeachincrementer", ICounter.PARTLY_COVERED, 1, 1);
-		assertLine("missedforeach", ICounter.NOT_COVERED);
-
-		// 11. Executed for each block
-		assertLine("executedforeachincrementer", ICounter.FULLY_COVERED, 0, 2);
-		assertLine("executedforeach", ICounter.FULLY_COVERED);
-
-		// 12. Table switch with hit
-		assertLine("tswitch1", ICounter.FULLY_COVERED, 3, 1);
-		assertLine("tswitch1case1", ICounter.NOT_COVERED);
-		assertLine("tswitch1case2", ICounter.FULLY_COVERED);
-		assertLine("tswitch1case3", ICounter.NOT_COVERED);
-		assertLine("tswitch1default", ICounter.NOT_COVERED);
-
-		// 13. Continued table switch with hit
-		assertLine("tswitch2", ICounter.FULLY_COVERED, 3, 1);
-		assertLine("tswitch2case1", ICounter.NOT_COVERED);
-		assertLine("tswitch2case2", ICounter.FULLY_COVERED);
-		assertLine("tswitch2case3", ICounter.FULLY_COVERED);
-		assertLine("tswitch2default", ICounter.FULLY_COVERED);
-
-		// 14. Table switch without hit
-		assertLine("tswitch2", ICounter.FULLY_COVERED, 3, 1);
-		assertLine("tswitch3case1", ICounter.NOT_COVERED);
-		assertLine("tswitch3case2", ICounter.NOT_COVERED);
-		assertLine("tswitch3case3", ICounter.NOT_COVERED);
-		assertLine("tswitch3default", ICounter.FULLY_COVERED);
-
-		// 15. Lookup switch with hit
-		assertLine("lswitch1", ICounter.FULLY_COVERED, 3, 1);
-		assertLine("lswitch1case1", ICounter.NOT_COVERED);
-		assertLine("lswitch1case2", ICounter.FULLY_COVERED);
-		assertLine("lswitch1case3", ICounter.NOT_COVERED);
-		assertLine("lswitch1default", ICounter.NOT_COVERED);
-
-		// 16. Continued lookup switch with hit
-		assertLine("lswitch2", ICounter.FULLY_COVERED, 3, 1);
-		assertLine("lswitch2case1", ICounter.NOT_COVERED);
-		assertLine("lswitch2case2", ICounter.FULLY_COVERED);
-		assertLine("lswitch2case3", ICounter.FULLY_COVERED);
-		assertLine("lswitch2default", ICounter.FULLY_COVERED);
-
-		// 17. Lookup switch without hit
-		assertLine("lswitch3", ICounter.FULLY_COVERED, 3, 1);
-		assertLine("lswitch3case1", ICounter.NOT_COVERED);
-		assertLine("lswitch3case2", ICounter.NOT_COVERED);
-		assertLine("lswitch3case3", ICounter.NOT_COVERED);
-		assertLine("lswitch3default", ICounter.FULLY_COVERED);
-
-		// 18. Break statement
-		assertLine("executedbreak", ICounter.FULLY_COVERED);
-		assertLine("missedafterbreak", ICounter.NOT_COVERED);
-
-		// 19. Continue statement
-		assertLine("executedcontinue", ICounter.FULLY_COVERED);
-		assertLine("missedaftercontinue", ICounter.NOT_COVERED);
-
-		// 20. Conditional return statement
-		assertLine("conditionalreturn", ICounter.FULLY_COVERED);
-		assertLine("afterconditionalreturn", ICounter.NOT_COVERED);
-
-		// 21. Implicit return
-		assertLine("implicitreturn", ICounter.FULLY_COVERED);
-
-		// 22. Explicit return
-		assertLine("explicitreturn", ICounter.FULLY_COVERED);
-		assertLine("afterexplicitreturn", ICounter.EMPTY);
-
-	}
-
 }
diff --git a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/EnumConstructorTest.java b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/EnumConstructorTest.java
index 28652700..ae96745f 100644
--- a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/EnumConstructorTest.java
+++ b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/EnumConstructorTest.java
@@ -11,10 +11,8 @@
  *******************************************************************************/
 package org.jacoco.core.test.validation.java5;
 
-import org.jacoco.core.analysis.ICounter;
 import org.jacoco.core.test.validation.ValidationTestBase;
 import org.jacoco.core.test.validation.java5.targets.EnumConstructorTarget;
-import org.junit.Test;
 
 /**
  * Test of filtering of enum constructors.
@@ -25,39 +23,4 @@ public class EnumConstructorTest extends ValidationTestBase {
 		super(EnumConstructorTarget.class);
 	}
 
-	/**
-	 * {@link EnumConstructorTarget.ImplicitConstructor}
-	 */
-	@Test
-	public void implicit_constructor_should_be_filtered() {
-		// without filter next line is partly covered:
-		assertLine("implicitConstructor", ICounter.FULLY_COVERED);
-	}
-
-	/**
-	 * {@link EnumConstructorTarget.ExplicitNonEmptyConstructor#ExplicitNonEmptyConstructor()}
-	 */
-	@Test
-	public void explicit_non_empty_constructor_should_not_be_filtered() {
-		assertLine("explicitNonEmptyConstructor", ICounter.NOT_COVERED);
-	}
-
-	/**
-	 * {@link EnumConstructorTarget.ExplicitEmptyConstructor#ExplicitEmptyConstructor()}
-	 */
-	@Test
-	public void explicit_empty_constructor_should_be_filtered() {
-		// without filter next line is not covered:
-		assertLine("explicitEmptyConstructor", ICounter.EMPTY);
-	}
-
-	/**
-	 * {@link EnumConstructorTarget.ExplicitEmptyConstructor#ExplicitEmptyConstructor(Object)}
-	 */
-	@Test
-	public void explicit_empty_constructor_with_parameters_should_not_be_filtered() {
-		assertLine("explicitEmptyConstructorWithParameter",
-				ICounter.NOT_COVERED);
-	}
-
 }
diff --git a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/EnumImplicitMethodsTest.java b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/EnumImplicitMethodsTest.java
index ced66609..397e2d21 100644
--- a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/EnumImplicitMethodsTest.java
+++ b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/EnumImplicitMethodsTest.java
@@ -11,7 +11,6 @@
  *******************************************************************************/
 package org.jacoco.core.test.validation.java5;
 
-import org.jacoco.core.analysis.ICounter;
 import org.jacoco.core.test.validation.ValidationTestBase;
 import org.jacoco.core.test.validation.java5.targets.EnumImplicitMethodsTarget;
 import org.junit.Test;
@@ -21,22 +20,13 @@ import org.junit.Test;
  */
 public class EnumImplicitMethodsTest extends ValidationTestBase {
 
-    public EnumImplicitMethodsTest() {
-        super(EnumImplicitMethodsTarget.class);
-    }
+	public EnumImplicitMethodsTest() {
+		super(EnumImplicitMethodsTarget.class);
+	}
 
-    @Test
-    public void testCoverageResult() {
-        assertMethodCount(5);
-
-        assertLine("classdef", ICounter.FULLY_COVERED);
-        assertLine("customValueOfMethod", ICounter.NOT_COVERED);
-        assertLine("customValuesMethod", ICounter.NOT_COVERED);
-
-        assertLine("const", ICounter.PARTLY_COVERED, 1, 1);
-        assertLine("staticblock", ICounter.FULLY_COVERED);
-        assertLine("super", ICounter.FULLY_COVERED);
-        assertLine("constructor", ICounter.FULLY_COVERED);
-    }
+	@Test
+	public void test_method_count() {
+		assertMethodCount(5);
+	}
 
 }
diff --git a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/EnumSwitchTest.java b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/EnumSwitchTest.java
index fa3c44ca..24578386 100644
--- a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/EnumSwitchTest.java
+++ b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/EnumSwitchTest.java
@@ -11,10 +11,9 @@
  *******************************************************************************/
 package org.jacoco.core.test.validation.java5;
 
-import org.jacoco.core.analysis.ICounter;
+import org.jacoco.core.test.validation.Source.Line;
 import org.jacoco.core.test.validation.ValidationTestBase;
 import org.jacoco.core.test.validation.java5.targets.EnumSwitchTarget;
-import org.junit.Test;
 
 /**
  * Test of filtering of a synthetic class that is generated by javac for a enum
@@ -26,14 +25,13 @@ public class EnumSwitchTest extends ValidationTestBase {
 		super(EnumSwitchTarget.class);
 	}
 
-	@Test
-	public void testCoverageResult() {
+	public void assertSwitch(final Line line) {
 		if (isJDKCompiler && JAVA_VERSION.isBefore("1.6")) {
 			// class that holds "switch map" is not marked as synthetic when
 			// compiling with javac 1.5
-			assertLine("switch", ICounter.PARTLY_COVERED, 0, 2);
+			assertPartlyCovered(line, 0, 2);
 		} else {
-			assertLine("switch", ICounter.FULLY_COVERED, 0, 2);
+			assertFullyCovered(line, 0, 2);
 		}
 	}
 
diff --git a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/ExceptionsTest.java b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/ExceptionsTest.java
index 15e47167..86350fd1 100644
--- a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/ExceptionsTest.java
+++ b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/ExceptionsTest.java
@@ -11,10 +11,9 @@
  *******************************************************************************/
 package org.jacoco.core.test.validation.java5;
 
-import org.jacoco.core.analysis.ICounter;
+import org.jacoco.core.test.validation.Source.Line;
 import org.jacoco.core.test.validation.ValidationTestBase;
 import org.jacoco.core.test.validation.java5.targets.ExceptionsTarget;
-import org.junit.Test;
 
 /**
  * Tests of exception based control flow.
@@ -25,109 +24,60 @@ public class ExceptionsTest extends ValidationTestBase {
 		super(ExceptionsTarget.class);
 	}
 
-	@Test
-	public void testCoverageResult() {
-
-		// 0. Implicit NullPointerException
-		// Currently no coverage at all, as we don't see when a block aborts
-		// somewhere in the middle.
-		assertLine("implicitNullPointerException.before", ICounter.NOT_COVERED);
-		assertLine("implicitNullPointerException.exception",
-				ICounter.NOT_COVERED);
-		assertLine("implicitNullPointerException.after", ICounter.NOT_COVERED);
-
-		// 1. Implicit Exception
-		assertLine("implicitException.before", ICounter.FULLY_COVERED);
-		assertLine("implicitException.exception", ICounter.NOT_COVERED);
-		assertLine("implicitException.after", ICounter.NOT_COVERED);
-
-		// 2. Explicit Exception
-		// Full coverage, as we recognize throw statements as block boundaries.
-		assertLine("explicitException.before", ICounter.FULLY_COVERED);
-		assertLine("explicitException.throw", ICounter.FULLY_COVERED);
-
-		// 3. Try/Catch Block Without Exception Thrown
-		assertLine("noExceptionTryCatch.beforeBlock", ICounter.FULLY_COVERED);
-		assertLine("noExceptionTryCatch.tryBlock", ICounter.FULLY_COVERED);
-		assertLine("noExceptionTryCatch.catch",
-				isJDKCompiler ? ICounter.NOT_COVERED : ICounter.PARTLY_COVERED);
-		assertLine("noExceptionTryCatch.catchBlock", ICounter.NOT_COVERED);
-		assertLine("noExceptionTryCatch.catchBlockEnd",
-				isJDKCompiler ? ICounter.FULLY_COVERED : ICounter.EMPTY);
-		assertLine("noExceptionTryCatch.afterBlock", ICounter.FULLY_COVERED);
-
-		// 4. Try/Catch Block With Exception Thrown Implicitly
-		assertLine("implicitExceptionTryCatch.beforeBlock",
-				ICounter.FULLY_COVERED);
-		assertLine("implicitExceptionTryCatch.before", ICounter.FULLY_COVERED);
-		assertLine("implicitExceptionTryCatch.exception", ICounter.NOT_COVERED);
-		assertLine("implicitExceptionTryCatch.after", ICounter.NOT_COVERED);
-		assertLine("implicitExceptionTryCatch.catch", isJDKCompiler
-				? ICounter.FULLY_COVERED : ICounter.PARTLY_COVERED);
-		assertLine("implicitExceptionTryCatch.catchBlock",
-				ICounter.FULLY_COVERED);
-		assertLine("implicitExceptionTryCatch.catchBlockEnd",
-				isJDKCompiler ? ICounter.NOT_COVERED : ICounter.EMPTY);
-		assertLine("implicitExceptionTryCatch.afterBlock",
-				ICounter.FULLY_COVERED);
+	public void assertCatchNoException(final Line line) {
+		if (isJDKCompiler) {
+			assertNotCovered(line);
+		} else {
+			assertPartlyCovered(line);
+		}
+	}
 
-		// 5. Try/Catch Block With Exception Thrown Implicitly After Condition
-		// As the try/catch block is entered at one branch of the condition
-		// should be marked as executed
-		assertLine("implicitExceptionTryCatchAfterCondition.condition",
-				ICounter.FULLY_COVERED, 1, 1);
-		assertLine("implicitExceptionTryCatchAfterCondition.exception",
-				ICounter.NOT_COVERED);
-		assertLine("implicitExceptionTryCatchAfterCondition.catchBlock",
-				ICounter.FULLY_COVERED);
+	public void assertCatchBlockEndNoException(final Line line) {
+		if (isJDKCompiler) {
+			assertFullyCovered(line);
+		} else {
+			assertEmpty(line);
+		}
+	}
 
-		// 6. Try/Catch Block With Exception Thrown Explicitly
-		assertLine("explicitExceptionTryCatch.beforeBlock",
-				ICounter.FULLY_COVERED);
-		assertLine("explicitExceptionTryCatch.before", ICounter.FULLY_COVERED);
-		assertLine("explicitExceptionTryCatch.throw", ICounter.FULLY_COVERED);
-		assertLine("explicitExceptionTryCatch.catch", ICounter.FULLY_COVERED);
-		assertLine("explicitExceptionTryCatch.catchBlock",
-				ICounter.FULLY_COVERED);
-		assertLine("explicitExceptionTryCatch.catchBlockEnd", ICounter.EMPTY);
-		assertLine("explicitExceptionTryCatch.afterBlock",
-				ICounter.FULLY_COVERED);
+	public void assertCatchImplicitException(final Line line) {
+		if (isJDKCompiler) {
+			assertFullyCovered(line);
+		} else {
+			assertPartlyCovered(line);
+		}
+	}
 
-		// 7. Finally Block Without Exception Thrown
-		assertLine("noExceptionFinally.beforeBlock", ICounter.FULLY_COVERED);
-		assertLine("noExceptionFinally.tryBlock", ICounter.FULLY_COVERED);
-		assertLine("noExceptionFinally.finally",
-				isJDKCompiler ? ICounter.EMPTY : ICounter.FULLY_COVERED);
-		assertLine("noExceptionFinally.finallyBlock", ICounter.FULLY_COVERED);
-		assertLine("noExceptionFinally.finallyBlockEnd", ICounter.EMPTY);
-		assertLine("noExceptionFinally.afterBlock", ICounter.FULLY_COVERED);
+	public void assertCatchBlockEndImplicitException(final Line line) {
+		if (isJDKCompiler) {
+			assertNotCovered(line);
+		} else {
+			assertEmpty(line);
+		}
+	}
 
-		// 8. Finally Block With Implicit Exception
-		assertLine("implicitExceptionFinally.beforeBlock",
-				ICounter.FULLY_COVERED);
-		assertLine("implicitExceptionFinally.before", ICounter.FULLY_COVERED);
-		assertLine("implicitExceptionFinally.exception", ICounter.NOT_COVERED);
-		assertLine("implicitExceptionFinally.after", ICounter.NOT_COVERED);
-		assertLine("implicitExceptionFinally.finally",
-				isJDKCompiler ? ICounter.EMPTY : ICounter.NOT_COVERED);
-		assertLine("implicitExceptionFinally.finallyBlock",
-				ICounter.FULLY_COVERED);
-		assertLine("implicitExceptionFinally.finallyBlockEnd", ICounter.EMPTY);
-		assertLine("implicitExceptionFinally.afterBlock", ICounter.NOT_COVERED);
+	public void assertFinally(final Line line) {
+		if (isJDKCompiler) {
+			assertEmpty(line);
+		} else {
+			assertFullyCovered(line);
+		}
+	}
 
-		// 9. Finally Block With Exception Thrown Explicitly
-		assertLine("explicitExceptionFinally.beforeBlock",
-				ICounter.FULLY_COVERED);
-		assertLine("explicitExceptionFinally.before", ICounter.FULLY_COVERED);
-		assertLine("explicitExceptionFinally.throw", ICounter.FULLY_COVERED);
-		assertLine("explicitExceptionFinally.finally",
-				isJDKCompiler ? ICounter.EMPTY : ICounter.FULLY_COVERED);
-		assertLine("explicitExceptionFinally.finallyBlock",
-				ICounter.FULLY_COVERED);
-		assertLine("explicitExceptionFinally.finallyBlockEnd",
-				isJDKCompiler ? ICounter.EMPTY : ICounter.FULLY_COVERED);
-		assertLine("explicitExceptionFinally.afterBlock", ICounter.EMPTY);
+	public void assertFinallyImplicitException(final Line line) {
+		if (isJDKCompiler) {
+			assertEmpty(line);
+		} else {
+			assertNotCovered(line);
+		}
+	}
 
+	public void assertBlockEndImplicitException(final Line line) {
+		if (isJDKCompiler) {
+			assertEmpty(line);
+		} else {
+			assertFullyCovered(line);
+		}
 	}
 
 }
diff --git a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/ExplicitInitialFrameTest.java b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/ExplicitInitialFrameTest.java
index b04c1a6b..2aa064b9 100644
--- a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/ExplicitInitialFrameTest.java
+++ b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/ExplicitInitialFrameTest.java
@@ -11,10 +11,8 @@
  *******************************************************************************/
 package org.jacoco.core.test.validation.java5;
 
-import org.jacoco.core.analysis.ICounter;
 import org.jacoco.core.test.validation.ValidationTestBase;
 import org.jacoco.core.test.validation.java5.targets.ExplicitInitialFrameTarget;
-import org.junit.Test;
 
 /**
  * Test for a methods having a explicit initial frame.
@@ -25,11 +23,4 @@ public class ExplicitInitialFrameTest extends ValidationTestBase {
 		super(ExplicitInitialFrameTarget.class);
 	}
 
-	@Test
-	public void testCoverageResult() {
-
-		assertLine("dowhilebody", ICounter.FULLY_COVERED);
-
-	}
-
 }
diff --git a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/FieldInitializationInTwoConstructorsTest.java b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/FieldInitializationInTwoConstructorsTest.java
index 6be37f4d..ec83ad54 100644
--- a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/FieldInitializationInTwoConstructorsTest.java
+++ b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/FieldInitializationInTwoConstructorsTest.java
@@ -11,29 +11,17 @@
  *******************************************************************************/
 package org.jacoco.core.test.validation.java5;
 
-import org.jacoco.core.analysis.ICounter;
 import org.jacoco.core.test.validation.ValidationTestBase;
 import org.jacoco.core.test.validation.java5.targets.FieldInitializationInTwoConstructorsTarget;
-import org.junit.Test;
 
 /**
  * Test of field initialization in two constructors.
  */
-public class FieldInitializationInTwoConstructorsTest extends
-		ValidationTestBase {
+public class FieldInitializationInTwoConstructorsTest
+		extends ValidationTestBase {
 
 	public FieldInitializationInTwoConstructorsTest() {
 		super(FieldInitializationInTwoConstructorsTarget.class);
 	}
 
-	@Test
-	public void testCoverageResult() {
-
-		assertLine("field1", ICounter.PARTLY_COVERED);
-		assertLine("field2", ICounter.PARTLY_COVERED);
-		assertLine("constr1", ICounter.FULLY_COVERED);
-		assertLine("constr2", ICounter.NOT_COVERED);
-
-	}
-
 }
diff --git a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/FinallyTest.java b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/FinallyTest.java
index 69cf4295..82fb08cc 100644
--- a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/FinallyTest.java
+++ b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/FinallyTest.java
@@ -12,16 +12,21 @@
 package org.jacoco.core.test.validation.java5;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
 
 import java.io.IOException;
+import java.util.HashMap;
 import java.util.HashSet;
+import java.util.Map;
 import java.util.Set;
 
-import org.jacoco.core.analysis.ICounter;
 import org.jacoco.core.internal.BytecodeVersion;
 import org.jacoco.core.test.TargetLoader;
+import org.jacoco.core.test.validation.Source.Line;
 import org.jacoco.core.test.validation.ValidationTestBase;
 import org.jacoco.core.test.validation.java5.targets.FinallyTarget;
+import org.junit.Before;
 import org.junit.Test;
 import org.objectweb.asm.ClassReader;
 import org.objectweb.asm.Opcodes;
@@ -35,180 +40,101 @@ import org.objectweb.asm.tree.MethodNode;
  */
 public class FinallyTest extends ValidationTestBase {
 
+	private Map<Integer, String> tags;
+
 	public FinallyTest() {
 		super(FinallyTarget.class);
 	}
 
-	/**
-	 * {@link FinallyTarget#example(boolean)}
-	 */
-	@Test
-	public void example() {
+	@Before
+	@Override
+	public void setup() throws Exception {
+		super.setup();
+		tags = new HashMap<Integer, String>();
+	}
+
+	public void assertFinally(final Line line) {
 		if (isJDKCompiler) {
-			assertLine("example.0", ICounter.EMPTY);
+			assertEmpty(line);
 		} else {
-			assertLine("example.0", ICounter.FULLY_COVERED);
+			assertFullyCovered(line);
 		}
-		assertLine("example.1", ICounter.FULLY_COVERED, 0, 2);
-		assertLine("example.2", ICounter.FULLY_COVERED);
-		assertLine("example.3", ICounter.EMPTY);
-		assertLine("example.4", ICounter.EMPTY);
-	}
-
-	/**
-	 * GOTO instructions at the end of duplicates of finally block might have
-	 * line number of a last instruction of finally block and hence lead to
-	 * unexpected coverage results, like for example in case of ECJ for
-	 * {@link FinallyTarget#catchNotExecuted()},
-	 * {@link FinallyTarget#emptyCatch()}. So we decided to ignore them, even if
-	 * they can correspond to a real break statement.
-	 * <p>
-	 * See also <a href=
-	 * "https://bugs.openjdk.java.net/browse/JDK-8180141">JDK-8180141</a> and
-	 * <a href=
-	 * "https://bugs.openjdk.java.net/browse/JDK-7008643">JDK-7008643</a>.
-	 * <p>
-	 * {@link FinallyTarget#breakStatement()}
-	 */
-	@Test
-	public void breakStatement() {
-		assertLine("breakStatement", ICounter.EMPTY);
-
-		assertLine("breakStatement.1", ICounter.FULLY_COVERED);
-		assertLine("breakStatement.2", ICounter.EMPTY);
 	}
 
-	/**
-	 * {@link FinallyTarget#catchNotExecuted()}
-	 */
-	@Test
-	public void catchNotExecuted() {
-		assertLine("catchNotExecuted.catch", ICounter.NOT_COVERED);
-		assertLine("catchNotExecuted.0", ICounter.EMPTY);
-		assertLine("catchNotExecuted.1", ICounter.FULLY_COVERED);
-		assertLine("catchNotExecuted.2", ICounter.EMPTY);
-	}
-
-	/**
-	 * {@link FinallyTarget#emptyCatch()}
-	 */
-	@Test
-	public void emptyCatch() {
-		assertLine("emptyCatch.0", ICounter.EMPTY);
-		assertLine("emptyCatch.1", ICounter.FULLY_COVERED);
-		assertLine("emptyCatch.2", ICounter.EMPTY);
+	public void assertTwoRegions1(final Line line) {
+		if (isJDKCompiler && JAVA_VERSION.isBefore("1.8")) {
+			// https://bugs.openjdk.java.net/browse/JDK-7008643
+			assertPartlyCovered(line);
+		} else {
+			assertFullyCovered(line);
+		}
 	}
 
-	/**
-	 * {@link FinallyTarget#twoRegions()}
-	 */
-	@Test
-	public void twoRegions() {
-		assertLine("twoRegions.0", ICounter.EMPTY);
+	public void assertTwoRegionsReturn1(final Line line) {
 		if (isJDKCompiler && JAVA_VERSION.isBefore("1.8")) {
 			// https://bugs.openjdk.java.net/browse/JDK-7008643
-			assertLine("twoRegions.1", ICounter.PARTLY_COVERED);
-			assertLine("twoRegions.return.1", ICounter.EMPTY);
-			assertLine("twoRegions.return.2", ICounter.EMPTY);
+			assertEmpty(line);
 		} else {
-			assertLine("twoRegions.1", ICounter.FULLY_COVERED);
-			assertLine("twoRegions.return.1", ICounter.FULLY_COVERED);
-			assertLine("twoRegions.return.2", ICounter.NOT_COVERED);
+			assertFullyCovered(line);
 		}
-		assertLine("twoRegions.2", ICounter.EMPTY);
-
-		assertLine("twoRegions.if", ICounter.FULLY_COVERED, 1, 1);
-		assertLine("twoRegions.region.1", ICounter.FULLY_COVERED);
-		assertLine("twoRegions.region.2", ICounter.NOT_COVERED);
 	}
 
-	/**
-	 * {@link FinallyTarget#nested()}
-	 */
-	@Test
-	public void nested() {
-		if (isJDKCompiler) {
-			assertLine("nested.0", ICounter.EMPTY);
+	public void assertTwoRegionsReturn2(final Line line) {
+		if (isJDKCompiler && JAVA_VERSION.isBefore("1.8")) {
+			// https://bugs.openjdk.java.net/browse/JDK-7008643
+			assertEmpty(line);
 		} else {
-			assertLine("nested.0", ICounter.FULLY_COVERED);
+			assertNotCovered(line);
 		}
-		assertLine("nested.1", ICounter.EMPTY);
-		assertLine("nested.2", ICounter.FULLY_COVERED);
-		if (isJDKCompiler) {
-			assertLine("nested.3", ICounter.EMPTY);
+	}
+
+	public void assertEmptyTry1(final Line line) {
+		if (isJDKCompiler && JAVA_VERSION.isBefore("1.8")) {
+			// compiler bug fixed in javac >= 1.8:
+			assertPartlyCovered(line);
 		} else {
-			assertLine("nested.3", ICounter.FULLY_COVERED);
+			assertFullyCovered(line);
 		}
-		assertLine("nested.4", ICounter.FULLY_COVERED);
 	}
 
-	/**
-	 * {@link FinallyTarget#emptyTry()}
-	 */
-	@Test
-	public void emptyTry() {
-		assertLine("emptyTry.0", ICounter.EMPTY);
+	public void assertEmptyTry2(final Line line) {
 		if (isJDKCompiler && JAVA_VERSION.isBefore("1.8")) {
 			// compiler bug fixed in javac >= 1.8:
-			assertLine("emptyTry.1", ICounter.PARTLY_COVERED);
-			assertLine("emptyTry.2", ICounter.FULLY_COVERED);
+			assertFullyCovered(line);
 		} else {
-			assertLine("emptyTry.1", ICounter.FULLY_COVERED);
-			assertLine("emptyTry.2", ICounter.EMPTY);
+			assertEmpty(line);
 		}
 	}
 
-	/**
-	 * {@link FinallyTarget#alwaysCompletesAbruptly()}
-	 */
-	@Test
-	public void alwaysCompletesAbruptly() {
+	public void assertAlwaysCompletesAbruptly0(final Line line) {
 		if (isJDKCompiler) {
 			// uncovered case:
-			assertLine("alwaysCompletesAbruptly.0", ICounter.EMPTY);
-			assertLine("alwaysCompletesAbruptly.1", ICounter.PARTLY_COVERED);
+			assertEmpty(line);
 		} else {
-			assertLine("alwaysCompletesAbruptly.0", ICounter.PARTLY_COVERED);
-			assertLine("alwaysCompletesAbruptly.1", ICounter.FULLY_COVERED);
+			assertPartlyCovered(line);
 		}
-		assertLine("alwaysCompletesAbruptly.2", ICounter.EMPTY);
+	}
+
+	public void assertAlwaysCompletesAbruptly1(final Line line) {
+		if (isJDKCompiler) {
+			// uncovered case:
+			assertPartlyCovered(line);
+		} else {
+			assertFullyCovered(line);
+		}
+	}
+
+	@Test
+	@Override
+	public void execute_assertions_in_comments() throws IOException {
+		super.execute_assertions_in_comments();
+		gotos();
 	}
 
 	/**
 	 * This test studies placement of GOTO instructions.
 	 */
-	@Test
-	public void gotos() throws IOException {
-		byte[] b = TargetLoader.getClassDataAsBytes(FinallyTarget.class);
-		b = BytecodeVersion.downgradeIfNeeded(BytecodeVersion.get(b), b);
-
-		final ClassNode classNode = new ClassNode();
-		new ClassReader(b).accept(classNode, 0);
-		final Set<String> tags = new HashSet<String>();
-		for (final MethodNode m : classNode.methods) {
-			if ("main".equals(m.name)) {
-				// skip it
-				continue;
-			}
-			int lineNumber = -1;
-			for (AbstractInsnNode i = m.instructions
-					.getFirst(); i != null; i = i.getNext()) {
-				if (AbstractInsnNode.LINE == i.getType()) {
-					lineNumber = ((LineNumberNode) i).line;
-				}
-				if (Opcodes.GOTO == i.getOpcode()) {
-					final String line = getSource().getLine(lineNumber);
-					if (line.indexOf('$') < 0) {
-						throw new AssertionError(
-								"No tag at line " + lineNumber);
-					}
-					final String tag = line.substring(
-							line.indexOf('$') + "$line-".length(),
-							line.lastIndexOf('$'));
-					tags.add(tag);
-				}
-			}
-		}
+	private void gotos() throws IOException {
 
 		final Set<String> expected = new HashSet<String>();
 
@@ -261,7 +187,46 @@ public class FinallyTest extends ValidationTestBase {
 			expected.add("alwaysCompletesAbruptly.0");
 		}
 
-		assertEquals(expected, tags);
+		assertEquals(expected, getTagsWithGotos());
+	}
+
+	private Set<String> getTagsWithGotos() throws IOException {
+		final Set<String> gotoTags = new HashSet<String>();
+
+		byte[] b = TargetLoader.getClassDataAsBytes(FinallyTarget.class);
+		b = BytecodeVersion.downgradeIfNeeded(BytecodeVersion.get(b), b);
+
+		final ClassNode classNode = new ClassNode();
+		new ClassReader(b).accept(classNode, 0);
+		for (final MethodNode m : classNode.methods) {
+			if ("main".equals(m.name)) {
+				// skip it
+				continue;
+			}
+			int lineNumber = -1;
+			for (AbstractInsnNode i = m.instructions
+					.getFirst(); i != null; i = i.getNext()) {
+				if (AbstractInsnNode.LINE == i.getType()) {
+					lineNumber = ((LineNumberNode) i).line;
+				}
+				if (Opcodes.GOTO == i.getOpcode()) {
+					String tag = tags.get(Integer.valueOf(lineNumber));
+					if (tag == null) {
+						throw new AssertionError(
+								"No tag at line " + lineNumber);
+					}
+					gotoTags.add(tag);
+				}
+			}
+		}
+
+		return gotoTags;
+	}
+
+	public void tag(final Line line, String tag) {
+		assertFalse("duplicate tag " + tag, tags.containsValue(tag));
+		assertNull("duplicate tag in " + line,
+				tags.put(Integer.valueOf(line.getNr()), tag));
 	}
 
 }
diff --git a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/ImplicitFieldInitializationTest.java b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/ImplicitFieldInitializationTest.java
index d87d039b..3b226c37 100644
--- a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/ImplicitFieldInitializationTest.java
+++ b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/ImplicitFieldInitializationTest.java
@@ -11,10 +11,8 @@
  *******************************************************************************/
 package org.jacoco.core.test.validation.java5;
 
-import org.jacoco.core.analysis.ICounter;
 import org.jacoco.core.test.validation.ValidationTestBase;
 import org.jacoco.core.test.validation.java5.targets.ImplicitFieldInitializationTarget;
-import org.junit.Test;
 
 /**
  * Test of a implicit field initialization.
@@ -25,15 +23,4 @@ public class ImplicitFieldInitializationTest extends ValidationTestBase {
 		super(ImplicitFieldInitializationTarget.class);
 	}
 
-	@Test
-	public void testCoverageResult() {
-
-		assertLine("classdef", ICounter.FULLY_COVERED);
-		assertLine("field1", ICounter.EMPTY);
-		assertLine("field2", ICounter.FULLY_COVERED);
-		assertLine("field3", ICounter.EMPTY);
-		assertLine("field4", ICounter.FULLY_COVERED);
-
-	}
-
 }
diff --git a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/InterfaceClassInitializerTest.java b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/InterfaceClassInitializerTest.java
index 9e13debb..c56293c0 100644
--- a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/InterfaceClassInitializerTest.java
+++ b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/InterfaceClassInitializerTest.java
@@ -11,10 +11,8 @@
  *******************************************************************************/
 package org.jacoco.core.test.validation.java5;
 
-import org.jacoco.core.analysis.ICounter;
 import org.jacoco.core.test.validation.ValidationTestBase;
 import org.jacoco.core.test.validation.java5.targets.InterfaceClassInitializerTarget;
-import org.junit.Test;
 
 /**
  * Tests of static initializer in interfaces.
@@ -31,14 +29,4 @@ public class InterfaceClassInitializerTest extends ValidationTestBase {
 		targetClass.getField("CONST1").get(null);
 	}
 
-	@Test
-	public void testCoverageResult() {
-
-		assertLine("const1", ICounter.EMPTY);
-		assertLine("const2", ICounter.EMPTY);
-
-		assertLine("const3", ICounter.FULLY_COVERED);
-		assertLine("const4", ICounter.FULLY_COVERED);
-	}
-
 }
diff --git a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/SynchronizedTest.java b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/SynchronizedTest.java
index c1498be1..821f5377 100644
--- a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/SynchronizedTest.java
+++ b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/SynchronizedTest.java
@@ -11,10 +11,9 @@
  *******************************************************************************/
 package org.jacoco.core.test.validation.java5;
 
-import org.jacoco.core.analysis.ICounter;
+import org.jacoco.core.test.validation.Source.Line;
 import org.jacoco.core.test.validation.ValidationTestBase;
 import org.jacoco.core.test.validation.java5.targets.SynchronizedTarget;
-import org.junit.Test;
 
 /**
  * Test of filtering of a bytecode that is generated for a synchronized
@@ -26,48 +25,29 @@ public class SynchronizedTest extends ValidationTestBase {
 		super(SynchronizedTarget.class);
 	}
 
-	/**
-	 * {@link SynchronizedTarget#normal()}
-	 */
-	@Test
-	public void normal() {
-		assertLine("before", ICounter.FULLY_COVERED);
-		// when compiled with ECJ next line covered partly without filter:
-		assertLine("monitorEnter", ICounter.FULLY_COVERED);
-		assertLine("body", ICounter.FULLY_COVERED);
+	public void assertMonitorEnterImplicitException(final Line line) {
 		if (isJDKCompiler) {
-			// without filter next line covered partly:
-			assertLine("monitorExit", ICounter.FULLY_COVERED);
+			assertFullyCovered(line);
 		} else {
-			assertLine("monitorExit", ICounter.EMPTY);
+			assertPartlyCovered(line);
 		}
-		assertLine("after", ICounter.FULLY_COVERED);
 	}
 
-	/**
-	 * {@link SynchronizedTarget#explicitException()}
-	 */
-	@Test
-	public void explicitException() {
-		assertLine("explicitException.monitorEnter", ICounter.FULLY_COVERED);
-		assertLine("explicitException.exception", ICounter.FULLY_COVERED);
-		// when compiled with javac next line covered fully without filter:
-		assertLine("explicitException.monitorExit", ICounter.EMPTY);
+	public void assertMonitorExit(final Line line) {
+		if (isJDKCompiler) {
+			// without filter next line covered partly:
+			assertFullyCovered(line);
+		} else {
+			assertEmpty(line);
+		}
 	}
 
-	/**
-	 * {@link SynchronizedTarget#implicitException()}
-	 */
-	@Test
-	public void implicitException() {
-		assertLine("implicitException.monitorEnter", isJDKCompiler
-				? ICounter.FULLY_COVERED : ICounter.PARTLY_COVERED);
-		assertLine("implicitException.exception", ICounter.NOT_COVERED);
+	public void assertMonitorExitImplicitException(final Line line) {
 		if (isJDKCompiler) {
 			// without filter next line covered partly:
-			assertLine("implicitException.monitorExit", ICounter.NOT_COVERED);
+			assertNotCovered(line);
 		} else {
-			assertLine("implicitException.monitorExit", ICounter.EMPTY);
+			assertEmpty(line);
 		}
 	}
 
diff --git a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/SyntheticTest.java b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/SyntheticTest.java
index f1f8372e..82b5128d 100644
--- a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/SyntheticTest.java
+++ b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/SyntheticTest.java
@@ -11,10 +11,8 @@
  *******************************************************************************/
 package org.jacoco.core.test.validation.java5;
 
-import org.jacoco.core.analysis.ICounter;
 import org.jacoco.core.test.validation.ValidationTestBase;
 import org.jacoco.core.test.validation.java5.targets.SyntheticTarget;
-import org.junit.Test;
 
 /**
  * Test of filtering of synthetic methods.
@@ -25,14 +23,8 @@ public class SyntheticTest extends ValidationTestBase {
 		super(SyntheticTarget.class);
 	}
 
-	@Test
-	public void testCoverageResult() {
+	public void test_method_count() {
 		assertMethodCount(5);
-
-		assertLine("classdef", ICounter.EMPTY);
-		assertLine("field", ICounter.EMPTY);
-
-		assertLine("inner.classdef", ICounter.EMPTY);
 	}
 
 }
diff --git a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/AnnotationInitializerTarget.java b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/AnnotationInitializerTarget.java
index 95171b3b..c53a2068 100644
--- a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/AnnotationInitializerTarget.java
+++ b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/AnnotationInitializerTarget.java
@@ -16,8 +16,8 @@ package org.jacoco.core.test.validation.java5.targets;
  */
 public @interface AnnotationInitializerTarget {
 
-	Object CONST = new Object(); // $line-const$
+	Object CONST = new Object(); // assertFullyCovered()
 
-	int value() default 0; // $line-value$
+	int value() default 0; // assertEmpty()
 
 }
diff --git a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/BadCycleClassTarget.java b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/BadCycleClassTarget.java
index 27b48dcc..e5c40409 100644
--- a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/BadCycleClassTarget.java
+++ b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/BadCycleClassTarget.java
@@ -26,15 +26,15 @@ public class BadCycleClassTarget {
 	public static class Child extends Base {
 
 		static {
-			Stubs.logEvent("childclinit"); // $line-childclinit$
+			Stubs.logEvent("childclinit"); // assertFullyCovered()
 		}
 
 		public Child() {
-			Stubs.logEvent("childinit"); // $line-childinit$
+			Stubs.logEvent("childinit"); // assertFullyCovered()
 		}
 
 		void someMethod() {
-			Stubs.logEvent("childsomeMethod"); // $line-childsomeMethod$
+			Stubs.logEvent("childsomeMethod"); // assertFullyCovered()
 		}
 
 	}
diff --git a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/BooleanExpressionsTarget.java b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/BooleanExpressionsTarget.java
index a0b4ff50..249e6719 100644
--- a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/BooleanExpressionsTarget.java
+++ b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/BooleanExpressionsTarget.java
@@ -24,95 +24,95 @@ public class BooleanExpressionsTarget {
 
 	public static void main(String[] args) {
 
-		// 1. Boolean comparison result (one case)
-		nop(i2() > 3); // $line-booleancmp1$
+		/* 1. Boolean comparison result (one case) */
+		nop(i2() > 3); // assertPartlyCovered(1, 1)
 
-		// 2. Boolean comparison result (both cases)
+		/* 2. Boolean comparison result (both cases) */
 		for (int i = 0; i < 2; i++) {
-			nop(i < 1); // $line-booleancmp2$
+			nop(i < 1); // assertFullyCovered(0, 2)
 		}
 
-		// 3. And
-		if (f() & f()) { // $line-andFF$
+		/* 3. And */
+		if (f() & f()) { // assertFullyCovered(1, 1)
 			nop();
 		}
-		if (f() & t()) { // $line-andFT$
+		if (f() & t()) { // assertFullyCovered(1, 1)
 			nop();
 		}
-		if (t() & f()) { // $line-andTF$
+		if (t() & f()) { // assertFullyCovered(1, 1)
 			nop();
 		}
-		if (t() & t()) { // $line-andTT$
+		if (t() & t()) { // assertFullyCovered(1, 1)
 			nop();
 		}
 
-		// 4. Conditional And
-		if (f() && f()) { // $line-conditionalandFF$
+		/* 4. Conditional And */
+		if (f() && f()) { // assertPartlyCovered(3, 1)
 			nop();
 		}
-		if (f() && t()) { // $line-conditionalandFT$
+		if (f() && t()) { // assertPartlyCovered(3, 1)
 			nop();
 		}
-		if (t() && f()) { // $line-conditionalandTF$
+		if (t() && f()) { // assertFullyCovered(2, 2)
 			nop();
 		}
-		if (t() && t()) { // $line-conditionalandTT$
+		if (t() && t()) { // assertFullyCovered(2, 2)
 			nop();
 		}
 
-		// 5. Or
-		if (f() | f()) { // $line-orFF$
+		/* 5. Or */
+		if (f() | f()) { // assertFullyCovered(1, 1)
 			nop();
 		}
-		if (f() | t()) { // $line-orFT$
+		if (f() | t()) { // assertFullyCovered(1, 1)
 			nop();
 		}
-		if (t() | f()) { // $line-orTF$
+		if (t() | f()) { // assertFullyCovered(1, 1)
 			nop();
 		}
-		if (t() | t()) { // $line-orTT$
+		if (t() | t()) { // assertFullyCovered(1, 1)
 			nop();
 		}
 
-		// 6. Conditional Or
-		if (f() || f()) { // $line-conditionalorFF$
+		/* 6. Conditional Or */
+		if (f() || f()) { // assertFullyCovered(2, 2)
 			nop();
 		}
-		if (f() || t()) { // $line-conditionalorFT$
+		if (f() || t()) { // assertFullyCovered(2, 2)
 			nop();
 		}
-		if (t() || f()) { // $line-conditionalorTF$
+		if (t() || f()) { // assertPartlyCovered(3, 1)
 			nop();
 		}
-		if (t() || t()) { // $line-conditionalorTT$
+		if (t() || t()) { // assertPartlyCovered(3, 1)
 			nop();
 		}
 
-		// 7. Exclusive Or
-		if (f() ^ f()) { // $line-xorFF$
+		/* 7. Exclusive Or */
+		if (f() ^ f()) { // assertFullyCovered(1, 1)
 			nop();
 		}
-		if (f() ^ t()) { // $line-xorFT$
+		if (f() ^ t()) { // assertFullyCovered(1, 1)
 			nop();
 		}
-		if (t() ^ f()) { // $line-xorTF$
+		if (t() ^ f()) { // assertFullyCovered(1, 1)
 			nop();
 		}
-		if (t() ^ t()) { // $line-xorTT$
+		if (t() ^ t()) { // assertFullyCovered(1, 1)
 			nop();
 		}
 
-		// 8. Conditional Operator
-		nop(t() ? i1() : i2()); // $line-condT$
-		nop(f() ? i1() : i2()); // $line-condF$
+		/* 8. Conditional Operator */
+		nop(t() ? i1() : i2()); // assertPartlyCovered(1, 1)
+		nop(f() ? i1() : i2()); // assertPartlyCovered(1, 1)
 
-		// 9. Not (one case)
-		nop(!t()); // $line-notT$
-		nop(!f()); // $line-notF$
+		/* 9. Not (one case) */
+		nop(!t()); // assertPartlyCovered(1, 1)
+		nop(!f()); // assertPartlyCovered(1, 1)
 
-		// 10. Not (both cases)
+		/* 10. Not (both cases) */
 		for (boolean b : new boolean[] { true, false }) {
-			nop(!b); // $line-notTF$
+			nop(!b); // assertFullyCovered(0, 2)
 		}
 
 	}
diff --git a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/ClassInitializerTarget.java b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/ClassInitializerTarget.java
index a8978362..373e33f5 100644
--- a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/ClassInitializerTarget.java
+++ b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/ClassInitializerTarget.java
@@ -20,28 +20,28 @@ import org.jacoco.core.test.validation.targets.Stubs;
  */
 public class ClassInitializerTarget {
 
-	// No code required to initialize these fields:
+	/* No code required to initialize these fields: */
 
-	public static final int CONST1 = 3; // $line-const1$
+	public static final int CONST1 = 3; // assertEmpty()
 
-	public static final String CONST2 = "Hello"; // $line-const2$
+	public static final String CONST2 = "Hello"; // assertEmpty()
 
-	// These fields are initialized within <clinit>
+	/* These fields are initialized within <clinit> */
 
-	public static final int CONST3 = i1(); // $line-const3$
+	public static final int CONST3 = i1(); // assertFullyCovered()
 
-	public static final Object CONST4 = new Object(); // $line-const4$
+	public static final Object CONST4 = new Object(); // assertFullyCovered()
 
-	public static int field1 = 3; // $line-field1$
+	public static int field1 = 3; // assertFullyCovered()
 
-	public static String field2 = "Hello"; // $line-field2$
+	public static String field2 = "Hello"; // assertFullyCovered()
 
-	public static int field3 = i1(); // $line-field3$
+	public static int field3 = i1(); // assertFullyCovered()
 
-	public static Object field4 = new Object(); // $line-field4$
+	public static Object field4 = new Object(); // assertFullyCovered()
 
 	static {
-		Stubs.nop(); // $line-staticblock$
+		Stubs.nop(); // assertFullyCovered()
 	}
 
 	private ClassInitializerTarget() {
diff --git a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/ConstructorsTarget.java b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/ConstructorsTarget.java
index 99ff020d..5376299c 100644
--- a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/ConstructorsTarget.java
+++ b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/ConstructorsTarget.java
@@ -18,20 +18,31 @@ import static org.jacoco.core.test.validation.targets.Stubs.nop;
  */
 public class ConstructorsTarget {
 
-	ConstructorsTarget() { // $line-packageLocal$
+	/* not filtered because not private: */
+	ConstructorsTarget() { // assertFullyCovered()
 	}
 
-	private ConstructorsTarget(Object arg) { // $line-arg$
+	/* not filtered because has argument: */
+	private ConstructorsTarget(Object arg) { // assertFullyCovered()
 	}
 
 	private static class Super extends ConstructorsTarget {
 		private Super() {
-			super(null); // $line-super$
+			/*
+			 * not filtered because not empty - prepares arguments for super
+			 * constructor:
+			 */
+			super(null); // assertFullyCovered()
 		}
 	}
 
 	private class Inner {
-		private Inner() { // $line-inner$
+		/*
+		 * not filtered because contains initialization of a field to hold
+		 * reference to an instance of outer class that is passed as an
+		 * argument:
+		 */
+		private Inner() { // assertFullyCovered()
 		}
 	}
 
@@ -39,28 +50,35 @@ public class ConstructorsTarget {
 		@SuppressWarnings("unused")
 		private final Object field = this;
 
-		private InnerStatic() { // $line-innerStatic$
+		/*
+		 * not filtered because not empty - contains initialization of a field:
+		 */
+		private InnerStatic() { // assertFullyCovered()
 		}
 	}
 
-	public static class PublicDefault { // $line-publicDefault$
+	/*
+	 * not filtered because default constructor for not private inner classes is
+	 * not private:
+	 */
+	public static class PublicDefault { // assertFullyCovered()
 	}
 
-	static class PackageLocalDefault { // $line-packageLocalDefault$
+	static class PackageLocalDefault { // assertFullyCovered()
 	}
 
-	private static class PrivateDefault { // $line-privateDefault$
+	private static class PrivateDefault { // assertEmpty()
 	}
 
 	private static class PrivateNonEmptyNoArg {
 		private PrivateNonEmptyNoArg() {
-			nop(); // $line-privateNonEmptyNoArg$
+			nop(); // assertFullyCovered()
 		}
 	}
 
 	private static class PrivateEmptyNoArg {
-		private PrivateEmptyNoArg() { // $line-privateEmptyNoArg$
-		} // $line-return$
+		private PrivateEmptyNoArg() { // assertEmpty()
+		} // assertEmpty()
 	}
 
 	public static void main(String[] args) {
diff --git a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/ControlStructureBeforeSuperConstructorTarget.java b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/ControlStructureBeforeSuperConstructorTarget.java
index ffc1d5f7..20317b8b 100644
--- a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/ControlStructureBeforeSuperConstructorTarget.java
+++ b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/ControlStructureBeforeSuperConstructorTarget.java
@@ -23,7 +23,7 @@ import org.jacoco.core.test.validation.targets.Stubs.SuperClass;
 public class ControlStructureBeforeSuperConstructorTarget extends SuperClass {
 
 	public ControlStructureBeforeSuperConstructorTarget() {
-		super(t() || f()); // $line-super$
+		super(t() || f()); // assertPartlyCovered(3, 1)
 	}
 
 	public static void main(String[] args) {
diff --git a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/ControlStructuresTarget.java b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/ControlStructuresTarget.java
index 3152a8b1..669a48db 100644
--- a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/ControlStructuresTarget.java
+++ b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/ControlStructuresTarget.java
@@ -52,41 +52,41 @@ public class ControlStructuresTarget {
 
 	private static void unconditionalExecution() {
 
-		nop(); // $line-unconditional$
+		nop(); // assertFullyCovered()
 
 	}
 
 	private static void missedIfBlock() {
 
-		if (f()) { // $line-iffalse$
-			nop(); // $line-missedif$
+		if (f()) { // assertFullyCovered(1, 1)
+			nop(); // assertNotCovered()
 		} else {
-			nop(); // $line-executedelse$
+			nop(); // assertFullyCovered()
 		}
 
 	}
 
 	private static void executedIfBlock() {
 
-		if (t()) { // $line-iftrue$
-			nop(); // $line-executedif$
+		if (t()) { // assertFullyCovered(1, 1)
+			nop(); // assertFullyCovered()
 		} else {
-			nop(); // $line-missedelse$
+			nop(); // assertNotCovered()
 		}
 
 	}
 
 	private static void missedWhileBlock() {
 
-		while (f()) { // $line-whilefalse$
-			nop(); // $line-missedwhile$
+		while (f()) { // assertFullyCovered(1, 1)
+			nop(); // assertNotCovered()
 		}
 
 	}
 
 	private static void alwaysExecutedWhileBlock() {
 
-		while (t()) { // $line-whiletrue$
+		while (t()) { // assertFullyCovered(1, 1)
 			if (t()) {
 				break;
 			}
@@ -97,8 +97,8 @@ public class ControlStructuresTarget {
 	private static void executedWhileBlock() {
 
 		int i = 0;
-		while (i++ < 3) { // $line-whiletruefalse$
-			nop(); // $line-executedwhile$
+		while (i++ < 3) { // assertFullyCovered(0, 2)
+			nop(); // assertFullyCovered()
 		}
 
 	}
@@ -106,57 +106,57 @@ public class ControlStructuresTarget {
 	private static void executedDoWhileBlock() {
 
 		do {
-			nop(); // $line-executeddowhile$
-		} while (f()); // $line-executeddowhilefalse$
+			nop(); // assertFullyCovered()
+		} while (f()); // assertFullyCovered(1, 1)
 
 	}
 
 	private static void missedForBlock() {
 
-		for (nop(); f(); nop()) { // $line-missedforincrementer$
-			nop(); // $line-missedfor$
+		for (nop(); f(); nop()) { // assertPartlyCovered(1, 1)
+			nop(); // assertNotCovered()
 		}
 
 	}
 
 	private static void executedForBlock() {
 
-		for (int j = 0; j < 1; j++) { // $line-executedforincrementer$
-			nop(); // $line-executedfor$
+		for (int j = 0; j < 1; j++) { // assertFullyCovered(0, 2)
+			nop(); // assertFullyCovered()
 		}
 
 	}
 
 	private static void missedForEachBlock() {
 
-		for (Object o : Collections.emptyList()) { // $line-missedforeachincrementer$
-			nop(o); // $line-missedforeach$
+		for (Object o : Collections.emptyList()) { // assertPartlyCovered(1, 1)
+			nop(o); // assertNotCovered()
 		}
 
 	}
 
 	private static void executedForEachBlock() {
 
-		for (Object o : Collections.singleton(new Object())) { // $line-executedforeachincrementer$
-			nop(o); // $line-executedforeach$
+		for (Object o : Collections.singleton(new Object())) { // assertFullyCovered(0,2)
+			nop(o); // assertFullyCovered()
 		}
 
 	}
 
 	private static void tableSwitchWithHit() {
 
-		switch (i2()) { // $line-tswitch1$
+		switch (i2()) { // assertFullyCovered(3, 1)
 		case 1:
-			nop(); // $line-tswitch1case1$
+			nop(); // assertNotCovered()
 			break;
 		case 2:
-			nop(); // $line-tswitch1case2$
+			nop(); // assertFullyCovered()
 			break;
 		case 3:
-			nop(); // $line-tswitch1case3$
+			nop(); // assertNotCovered()
 			break;
 		default:
-			nop(); // $line-tswitch1default$
+			nop(); // assertNotCovered()
 			break;
 		}
 
@@ -164,33 +164,33 @@ public class ControlStructuresTarget {
 
 	private static void continuedTableSwitchWithHit() {
 
-		switch (i2()) { // $line-tswitch2$
+		switch (i2()) { // assertFullyCovered(3, 1)
 		case 1:
-			nop(); // $line-tswitch2case1$
+			nop(); // assertNotCovered()
 		case 2:
-			nop(); // $line-tswitch2case2$
+			nop(); // assertFullyCovered()
 		case 3:
-			nop(); // $line-tswitch2case3$
+			nop(); // assertFullyCovered()
 		default:
-			nop(); // $line-tswitch2default$
+			nop(); // assertFullyCovered()
 		}
 
 	}
 
 	private static void tableSwitchWithoutHit() {
 
-		switch (i2()) { // $line-tswitch3$
+		switch (i2()) { // assertFullyCovered(3, 1)
 		case 3:
-			nop(); // $line-tswitch3case1$
+			nop(); // assertNotCovered()
 			break;
 		case 4:
-			nop(); // $line-tswitch3case2$
+			nop(); // assertNotCovered()
 			break;
 		case 5:
-			nop(); // $line-tswitch3case3$
+			nop(); // assertNotCovered()
 			break;
 		default:
-			nop(); // $line-tswitch3default$
+			nop(); // assertFullyCovered()
 			break;
 		}
 
@@ -198,18 +198,18 @@ public class ControlStructuresTarget {
 
 	private static void lookupSwitchWithHit() {
 
-		switch (i2()) { // $line-lswitch1$
+		switch (i2()) { // assertFullyCovered(3, 1)
 		case -123:
-			nop(); // $line-lswitch1case1$
+			nop(); // assertNotCovered()
 			break;
 		case 2:
-			nop(); // $line-lswitch1case2$
+			nop(); // assertFullyCovered()
 			break;
 		case 456:
-			nop(); // $line-lswitch1case3$
+			nop(); // assertNotCovered()
 			break;
 		default:
-			nop(); // $line-lswitch1default$
+			nop(); // assertNotCovered()
 			break;
 		}
 
@@ -217,33 +217,33 @@ public class ControlStructuresTarget {
 
 	private static void continuedLookupSwitchWithHit() {
 
-		switch (i2()) { // $line-lswitch2$
+		switch (i2()) { // assertFullyCovered(3, 1)
 		case -123:
-			nop(); // $line-lswitch2case1$
+			nop(); // assertNotCovered()
 		case 2:
-			nop(); // $line-lswitch2case2$
+			nop(); // assertFullyCovered()
 		case 456:
-			nop(); // $line-lswitch2case3$
+			nop(); // assertFullyCovered()
 		default:
-			nop(); // $line-lswitch2default$
+			nop(); // assertFullyCovered()
 		}
 
 	}
 
 	private static void lookupSwitchWithoutHit() {
 
-		switch (i2()) { // $line-lswitch3$
+		switch (i2()) { // assertFullyCovered(3, 1)
 		case -123:
-			nop(); // $line-lswitch3case1$
+			nop(); // assertNotCovered()
 			break;
 		case 456:
-			nop(); // $line-lswitch3case2$
+			nop(); // assertNotCovered()
 			break;
 		case 789:
-			nop(); // $line-lswitch3case3$
+			nop(); // assertNotCovered()
 			break;
 		default:
-			nop(); // $line-lswitch3default$
+			nop(); // assertFullyCovered()
 			break;
 		}
 
@@ -253,9 +253,9 @@ public class ControlStructuresTarget {
 
 		while (true) {
 			if (t()) {
-				break; // $line-executedbreak$
+				break; // assertFullyCovered()
 			}
-			nop(); // $line-missedafterbreak$
+			nop(); // assertNotCovered()
 		}
 
 	}
@@ -264,9 +264,9 @@ public class ControlStructuresTarget {
 
 		for (int j = 0; j < 1; j++) {
 			if (t()) {
-				continue; // $line-executedcontinue$
+				continue; // assertFullyCovered()
 			}
-			nop(); // $line-missedaftercontinue$
+			nop(); // assertNotCovered()
 		}
 
 	}
@@ -274,20 +274,20 @@ public class ControlStructuresTarget {
 	private static void conditionalReturn() {
 
 		if (t()) {
-			return; // $line-conditionalreturn$
+			return; // assertFullyCovered()
 		}
-		nop(); // $line-afterconditionalreturn$
+		nop(); // assertNotCovered()
 
 	}
 
 	private static void implicitReturn() {
 
-	} // $line-implicitreturn$
+	} // assertFullyCovered()
 
 	private static void explicitReturn() {
 
-		return; // $line-explicitreturn$
+		return; // assertFullyCovered()
 
-	} // $line-afterexplicitreturn$
+	} // assertEmpty()
 
 }
diff --git a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/EnumConstructorTarget.java b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/EnumConstructorTarget.java
index 7d232bd7..d8b3e23b 100644
--- a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/EnumConstructorTarget.java
+++ b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/EnumConstructorTarget.java
@@ -18,26 +18,32 @@ import static org.jacoco.core.test.validation.targets.Stubs.nop;
  */
 public class EnumConstructorTarget {
 
-	private enum ImplicitConstructor { // $line-implicitConstructor$
+	/*
+	 * Implicit constructor should be filtered. without filter next line is
+	 * partly covered:
+	 */
+	private enum ImplicitConstructor { // assertFullyCovered()
 	}
 
+	/* Explicit non empty constructor should not be filtered: */
 	private enum ExplicitNonEmptyConstructor {
 		;
 
 		ExplicitNonEmptyConstructor() {
-			nop(); // $line-explicitNonEmptyConstructor$
+			nop(); // assertNotCovered()
 		}
 	}
 
-	@SuppressWarnings("unused")
+	/* Explicit empty constructor should be filtered: */
 	private enum ExplicitEmptyConstructor {
 		;
 
 		ExplicitEmptyConstructor() {
-		} // $line-explicitEmptyConstructor$
+			/* without filter next line is not covered: */
+		} // assertEmpty()
 
 		ExplicitEmptyConstructor(Object p) {
-		} // $line-explicitEmptyConstructorWithParameter$
+		} // assertNotCovered()
 	}
 
 	public static void main(String[] args) {
diff --git a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/EnumImplicitMethodsTarget.java b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/EnumImplicitMethodsTarget.java
index ff589f78..9862d0fd 100644
--- a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/EnumImplicitMethodsTarget.java
+++ b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/EnumImplicitMethodsTarget.java
@@ -13,20 +13,20 @@ package org.jacoco.core.test.validation.java5.targets;
 
 import org.jacoco.core.test.validation.targets.Stubs;
 
-public enum EnumImplicitMethodsTarget { // $line-classdef$
+public enum EnumImplicitMethodsTarget { // assertFullyCovered()
 
-	CONST(Stubs.f() ? new Object() : new Object()); // $line-const$
+	CONST(Stubs.f() ? new Object() : new Object()); // assertPartlyCovered(1, 1)
 
 	static {
-	} // $line-staticblock$
+	} // assertFullyCovered()
 
 	/**
-	 * Unlike in {@link ConstructorsTarget regular classes}, even if enum has explicit
-	 * constructor, {@code clinit} method in any case has a reference to the
-	 * line of enum definition.
+	 * Unlike in {@link ConstructorsTarget regular classes}, even if enum has
+	 * explicit constructor, {@code clinit} method in any case has a reference
+	 * to the line of enum definition.
 	 */
-	EnumImplicitMethodsTarget(Object o) { // $line-super$
-	} // $line-constructor$
+	EnumImplicitMethodsTarget(Object o) { // assertFullyCovered()
+	} // assertFullyCovered()
 
 	/**
 	 * This method should not be excluded from analysis unlike implicitly
@@ -34,7 +34,7 @@ public enum EnumImplicitMethodsTarget { // $line-classdef$
 	 * definition in case of javac and to the first line in case of ECJ.
 	 */
 	public void valueOf() {
-	} // $line-customValueOfMethod$
+	} // assertNotCovered()
 
 	/**
 	 * This method should not be excluded from analysis unlike implicitly
@@ -42,7 +42,7 @@ public enum EnumImplicitMethodsTarget { // $line-classdef$
 	 * definition in case of javac and to the first line in case of ECJ.
 	 */
 	public void values(Object o) {
-	} // $line-customValuesMethod$
+	} // assertNotCovered()
 
 	public static void main(String[] args) {
 	}
diff --git a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/EnumSwitchTarget.java b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/EnumSwitchTarget.java
index 47447e5a..d2393bff 100644
--- a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/EnumSwitchTarget.java
+++ b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/EnumSwitchTarget.java
@@ -23,7 +23,7 @@ public class EnumSwitchTarget {
 	}
 
 	private static void example(E e) {
-		switch (e) { // $line-switch$
+		switch (e) { // assertSwitch()
 		case V1:
 			nop("V1");
 			break;
diff --git a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/ExceptionsTarget.java b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/ExceptionsTarget.java
index 1896e64d..3b4e3479 100644
--- a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/ExceptionsTarget.java
+++ b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/ExceptionsTarget.java
@@ -51,92 +51,104 @@ public class ExceptionsTarget {
 		}
 	}
 
+	/**
+	 * Currently no coverage at all, as we don't see when a block aborts
+	 * somewhere in the middle.
+	 */
 	private static void implicitNullPointerException(int[] a) {
-		nop(); // $line-implicitNullPointerException.before$
-		a[0] = 0; // $line-implicitNullPointerException.exception$
-		nop(); // $line-implicitNullPointerException.after$
+		nop(); // assertNotCovered()
+		a[0] = 0; // assertNotCovered()
+		nop(); // assertNotCovered()
 	}
 
+	/**
+	 * For each line with method invocations a extra probe is inserted.
+	 * Therefore the lines before the exception are marked as covered.
+	 */
 	private static void implicitException() {
-		nop(); // $line-implicitException.before$
-		ex(); // $line-implicitException.exception$
-		nop(); // $line-implicitException.after$
+		nop(); // assertFullyCovered()
+		ex(); // assertNotCovered()
+		nop(); // assertNotCovered()
 	}
 
 	private static void explicitException() {
-		nop(); // $line-explicitException.before$
-		throw new StubException(); // $line-explicitException.throw$
+		nop(); // assertFullyCovered()
+		throw new StubException(); // assertFullyCovered()
 	}
 
 	private static void noExceptionTryCatch() {
-		nop(); // $line-noExceptionTryCatch.beforeBlock$
+		nop(); // assertFullyCovered()
 		try {
-			nop(); // $line-noExceptionTryCatch.tryBlock$
-		} catch (StubException e) { // $line-noExceptionTryCatch.catch$
-			nop(); // $line-noExceptionTryCatch.catchBlock$
-		} // $line-noExceptionTryCatch.catchBlockEnd$
-	} // $line-noExceptionTryCatch.afterBlock$
+			nop(); // assertFullyCovered()
+		} catch (StubException e) { // assertCatchNoException()
+			nop(); // assertNotCovered()
+		} // assertCatchBlockEndNoException()
+	} // assertFullyCovered()
 
 	private static void implicitExceptionTryCatch() {
-		nop(); // $line-implicitExceptionTryCatch.beforeBlock$
+		nop(); // assertFullyCovered()
 		try {
-			nop(); // $line-implicitExceptionTryCatch.before$
-			ex(); // $line-implicitExceptionTryCatch.exception$
-			nop(); // $line-implicitExceptionTryCatch.after$
-		} catch (StubException e) { // $line-implicitExceptionTryCatch.catch$
-			nop(); // $line-implicitExceptionTryCatch.catchBlock$
-		} // $line-implicitExceptionTryCatch.catchBlockEnd$
-	} // $line-implicitExceptionTryCatch.afterBlock$
-
+			nop(); // assertFullyCovered()
+			ex(); // assertNotCovered()
+			nop(); // assertNotCovered()
+		} catch (StubException e) { // assertCatchImplicitException()
+			nop(); // assertFullyCovered()
+		} // assertCatchBlockEndImplicitException()
+	} // assertFullyCovered()
+
+	/**
+	 * As the try/catch block is entered at one branch of the condition should
+	 * be marked as executed
+	 */
 	private static void implicitExceptionTryCatchAfterCondition() {
-		if (f()) { // $line-implicitExceptionTryCatchAfterCondition.condition$
+		if (f()) { // assertFullyCovered(1, 1)
 			return;
 		}
 		try {
-			ex(); // $line-implicitExceptionTryCatchAfterCondition.exception$
+			ex(); // assertNotCovered()
 		} catch (StubException e) {
-			nop(); // $line-implicitExceptionTryCatchAfterCondition.catchBlock$
+			nop(); // assertFullyCovered()
 		}
 	}
 
 	private static void explicitExceptionTryCatch() {
-		nop(); // $line-explicitExceptionTryCatch.beforeBlock$
+		nop(); // assertFullyCovered()
 		try {
-			nop(); // $line-explicitExceptionTryCatch.before$
-			throw new StubException(); // $line-explicitExceptionTryCatch.throw$
-		} catch (StubException e) { // $line-explicitExceptionTryCatch.catch$
-			nop(); // $line-explicitExceptionTryCatch.catchBlock$
-		} // $line-explicitExceptionTryCatch.catchBlockEnd$
-	} // $line-explicitExceptionTryCatch.afterBlock$
+			nop(); // assertFullyCovered()
+			throw new StubException(); // assertFullyCovered()
+		} catch (StubException e) { // assertFullyCovered()
+			nop(); // assertFullyCovered()
+		} // assertEmpty()
+	} // assertFullyCovered()
 
 	private static void noExceptionFinally() {
-		nop(); // $line-noExceptionFinally.beforeBlock$
+		nop(); // assertFullyCovered()
 		try {
-			nop(); // $line-noExceptionFinally.tryBlock$
-		} finally { // $line-noExceptionFinally.finally$
-			nop(); // $line-noExceptionFinally.finallyBlock$
-		} // $line-noExceptionFinally.finallyBlockEnd$
-	} // $line-noExceptionFinally.afterBlock$
+			nop(); // assertFullyCovered()
+		} finally { // assertFinally()
+			nop(); // assertFullyCovered()
+		} // assertEmpty()
+	} // assertFullyCovered()
 
 	private static void implicitExceptionFinally() {
-		nop(); // $line-implicitExceptionFinally.beforeBlock$
+		nop(); // assertFullyCovered()
 		try {
-			nop(); // $line-implicitExceptionFinally.before$
-			ex(); // $line-implicitExceptionFinally.exception$
-			nop(); // $line-implicitExceptionFinally.after$
-		} finally { // $line-implicitExceptionFinally.finally$
-			nop(); // $line-implicitExceptionFinally.finallyBlock$
-		} // $line-implicitExceptionFinally.finallyBlockEnd$
-	} // $line-implicitExceptionFinally.afterBlock$
+			nop(); // assertFullyCovered()
+			ex(); // assertNotCovered()
+			nop(); // assertNotCovered()
+		} finally { // assertFinallyImplicitException()
+			nop(); // assertFullyCovered()
+		} // assertEmpty()
+	} // assertNotCovered()
 
 	private static void explicitExceptionFinally() {
-		nop(); // $line-explicitExceptionFinally.beforeBlock$
+		nop(); // assertFullyCovered()
 		try {
-			nop(); // $line-explicitExceptionFinally.before$
-			throw new StubException(); // $line-explicitExceptionFinally.throw$
-		} finally { // $line-explicitExceptionFinally.finally$
-			nop(); // $line-explicitExceptionFinally.finallyBlock$
-		} // $line-explicitExceptionFinally.finallyBlockEnd$
-	} // $line-explicitExceptionFinally.afterBlock$
+			nop(); // assertFullyCovered()
+			throw new StubException(); // assertFullyCovered()
+		} finally { // assertFinally()
+			nop(); // assertFullyCovered()
+		} // assertBlockEndImplicitException()
+	} // assertEmpty()
 
 }
diff --git a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/ExplicitInitialFrameTarget.java b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/ExplicitInitialFrameTarget.java
index bc089fc7..475e01fe 100644
--- a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/ExplicitInitialFrameTarget.java
+++ b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/ExplicitInitialFrameTarget.java
@@ -23,7 +23,7 @@ public class ExplicitInitialFrameTarget {
 	public static void main(String[] args) {
 
 		do {
-			nop(); // $line-dowhilebody$
+			nop(); // assertFullyCovered()
 		} while (f());
 
 	}
diff --git a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/FieldInitializationInTwoConstructorsTarget.java b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/FieldInitializationInTwoConstructorsTarget.java
index 58bf6890..4c8ec8fc 100644
--- a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/FieldInitializationInTwoConstructorsTarget.java
+++ b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/FieldInitializationInTwoConstructorsTarget.java
@@ -17,15 +17,15 @@ package org.jacoco.core.test.validation.java5.targets;
  */
 public class FieldInitializationInTwoConstructorsTarget {
 
-	Object field1 = null; // $line-field1$
+	Object field1 = null; // assertPartlyCovered()
 
-	int field2 = 123; // $line-field2$
+	int field2 = 123; // assertPartlyCovered()
 
 	public FieldInitializationInTwoConstructorsTarget() {
-	} // $line-constr1$
+	} // assertFullyCovered()
 
 	public FieldInitializationInTwoConstructorsTarget(String arg) {
-	} // $line-constr2$
+	} // assertNotCovered()
 
 	public static void main(String[] args) {
 		new FieldInitializationInTwoConstructorsTarget();
diff --git a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/FinallyTarget.java b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/FinallyTarget.java
index 2c317e95..3010786e 100644
--- a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/FinallyTarget.java
+++ b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/FinallyTarget.java
@@ -35,11 +35,11 @@ public class FinallyTarget {
 		Object in = null;
 		try {
 			in = open(t);
-		} finally { // $line-example.0$
-			if (in != null) { // $line-example.1$
-				nop(); // $line-example.2$
-			} // $line-example.3$
-		} // $line-example.4$
+		} finally { // assertFinally() tag("example.0")
+			if (in != null) { // assertFullyCovered(0, 2)
+				nop(); // assertFullyCovered() tag("example.2")
+			} // assertEmpty()
+		} // assertEmpty()
 	}
 
 	private static Object open(boolean t) {
@@ -47,80 +47,93 @@ public class FinallyTarget {
 		return new Object();
 	}
 
+	/**
+	 * GOTO instructions at the end of duplicates of finally block might have
+	 * line number of a last instruction of finally block and hence lead to
+	 * unexpected coverage results, like for example in case of ECJ for
+	 * {@link FinallyTarget#catchNotExecuted()},
+	 * {@link FinallyTarget#emptyCatch()}. So we decided to ignore them, even if
+	 * they can correspond to a real break statement.
+	 * <p>
+	 * See also <a href=
+	 * "https://bugs.openjdk.java.net/browse/JDK-8180141">JDK-8180141</a> and
+	 * <a href=
+	 * "https://bugs.openjdk.java.net/browse/JDK-7008643">JDK-7008643</a>.
+	 */
 	private static void breakStatement() {
-		for (int i = 0; i < 1; i++) { // $line-breakStatement.for$
+		for (int i = 0; i < 1; i++) { // tag("breakStatement.for")
 			try {
 				if (f()) {
-					break; // $line-breakStatement$
+					break; // assertEmpty() tag("breakStatement")
 				}
 			} finally {
-				nop("finally"); // $line-breakStatement.1$
-			} // $line-breakStatement.2$
+				nop("finally"); // assertFullyCovered() tag("breakStatement.1")
+			} // assertEmpty() tag("breakStatement.2")
 		}
 	}
 
 	private static void catchNotExecuted() {
 		try {
 			nop("try");
-		} catch (Exception e) { // $line-catchNotExecuted$
-			nop("catch"); // $line-catchNotExecuted.catch$
-		} finally { // $line-catchNotExecuted.0$
-			nop("finally"); // $line-catchNotExecuted.1$
-		} // $line-catchNotExecuted.2$
+		} catch (Exception e) { // tag("catchNotExecuted")
+			nop("catch"); // assertNotCovered()
+		} finally { // assertEmpty()
+			nop("finally"); // assertFullyCovered() tag("catchNotExecuted.1")
+		} // assertEmpty() tag("catchNotExecuted.2")
 	}
 
 	private static void emptyCatch() {
 		try {
 			nop("try");
-		} catch (Exception e) { // $line-emptyCatch$
-			// empty
-		} finally { // $line-emptyCatch.0$
-			nop("finally"); // $line-emptyCatch.1$
-		} // $line-emptyCatch.2$
+		} catch (Exception e) { // tag("emptyCatch")
+			/* empty */
+		} finally { // assertEmpty()
+			nop("finally"); // assertFullyCovered() tag("emptyCatch.1")
+		} // assertEmpty() tag("emptyCatch.2")
 	}
 
 	private static void twoRegions() {
 		try {
-			// jump to another region associated with same handler:
-			if (t()) { // $line-twoRegions.if$
-				nop(); // $line-twoRegions.region.1$
-				return; // $line-twoRegions.return.1$
+			/* jump to another region associated with same handler: */
+			if (t()) { // assertFullyCovered(1, 1)
+				nop(); // assertFullyCovered()
+				return; // assertTwoRegionsReturn1()
 			} else {
-				nop(); // $line-twoRegions.region.2$
-				return; // $line-twoRegions.return.2$
+				nop(); // assertNotCovered()
+				return; // assertTwoRegionsReturn2()
 			}
-		} finally { // $line-twoRegions.0$
-			nop(); // $line-twoRegions.1$
-		} // $line-twoRegions.2$
+		} finally { // assertEmpty()
+			nop(); // assertTwoRegions1()
+		} // assertEmpty()
 	}
 
 	private static void nested() {
 		try {
 			nop();
-		} finally { // $line-nested.0$
-			try { // $line-nested.1$
-				nop(); // $line-nested.2$
-			} finally { // $line-nested.3$
-				nop(); // $line-nested.4$
-			} // $line-nested.5$
-		} // $line-nested.6$
+		} finally { // assertFinally() tag("nested.0")
+			try { // assertEmpty()
+				nop(); // assertFullyCovered()
+			} finally { // assertFinally() tag("nested.3")
+				nop(); // assertFullyCovered()
+			} // assertEmpty() tag("nested.5")
+		} // assertEmpty() tag("nested.6")
 	}
 
 	private static void emptyTry() {
 		try {
-			// empty
-		} finally { // $line-emptyTry.0$
-			nop(); // $line-emptyTry.1$
-		} // $line-emptyTry.2$
+			/* empty */
+		} finally { // assertEmpty()
+			nop(); // assertEmptyTry1()
+		} // assertEmptyTry2() tag("emptyTry.2")
 	}
 
 	@SuppressWarnings("finally")
 	private static void alwaysCompletesAbruptly() {
 		try {
 			nop();
-		} finally { // $line-alwaysCompletesAbruptly.0$
-			return; // $line-alwaysCompletesAbruptly.1$
-		} // $line-alwaysCompletesAbruptly.2$
+		} finally { // assertAlwaysCompletesAbruptly0()tag("alwaysCompletesAbruptly.0")
+			return; // assertAlwaysCompletesAbruptly1()
+		} // assertEmpty()
 	}
 
 	public static void main(String[] args) {
diff --git a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/ImplicitFieldInitializationTarget.java b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/ImplicitFieldInitializationTarget.java
index 6ddf8cbd..1cdb75e3 100644
--- a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/ImplicitFieldInitializationTarget.java
+++ b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/ImplicitFieldInitializationTarget.java
@@ -14,15 +14,15 @@ package org.jacoco.core.test.validation.java5.targets;
 /**
  * This test target has instance members with implicit initializers.
  */
-public class ImplicitFieldInitializationTarget { // $line-classdef$
+public class ImplicitFieldInitializationTarget { // assertFullyCovered()
 
-	Object field1; // $line-field1$
+	Object field1; // assertEmpty()
 
-	Object field2 = this; // $line-field2$
+	Object field2 = this; // assertFullyCovered()
 
-	int field3; // $line-field3$
+	int field3; // assertEmpty()
 
-	int field4 = 2000; // $line-field4$
+	int field4 = 2000; // assertFullyCovered()
 
 	public static void main(String[] args) {
 		new ImplicitFieldInitializationTarget();
diff --git a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/InterfaceClassInitializerTarget.java b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/InterfaceClassInitializerTarget.java
index 2debf6bd..efcd44ee 100644
--- a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/InterfaceClassInitializerTarget.java
+++ b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/InterfaceClassInitializerTarget.java
@@ -18,16 +18,16 @@ import static org.jacoco.core.test.validation.targets.Stubs.i1;
  */
 public interface InterfaceClassInitializerTarget {
 
-	// No code required to initialize these fields:
+	/* No code required to initialize these fields: */
 
-	static final int CONST1 = 12345; // $line-const1$
+	static final int CONST1 = 12345; // assertEmpty()
 
-	static final String CONST2 = "const"; // $line-const2$
+	static final String CONST2 = "const"; // assertEmpty()
 
-	// These fields are initialized within <clinit>
+	/* These fields are initialized within <clinit> */
 
-	static final int CONST3 = i1(); // $line-const3$
+	static final int CONST3 = i1(); // assertFullyCovered()
 
-	static final Object CONST4 = new Object(); // $line-const4$
+	static final Object CONST4 = new Object(); // assertFullyCovered()
 
 }
diff --git a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/SynchronizedTarget.java b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/SynchronizedTarget.java
index 5bea5758..a8055d69 100644
--- a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/SynchronizedTarget.java
+++ b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/SynchronizedTarget.java
@@ -24,23 +24,24 @@ public class SynchronizedTarget {
 	private static final Object lock = new Object();
 
 	private static void normal() {
-		nop(); // $line-before$
-		synchronized (lock) { // $line-monitorEnter$
-			nop(); // $line-body$
-		} // $line-monitorExit$
-		nop(); // $line-after$
+		nop(); // assertFullyCovered()
+		/* when compiled with ECJ next line covered partly without filter: */
+		synchronized (lock) { // assertFullyCovered()
+			nop(); // assertFullyCovered()
+		} // assertMonitorExit()
+		nop(); // assertFullyCovered()
 	}
 
 	private static void explicitException() {
-		synchronized (lock) { // $line-explicitException.monitorEnter$
-			throw new StubException(); // $line-explicitException.exception$
-		} // $line-explicitException.monitorExit$
+		synchronized (lock) { // assertFullyCovered()
+			throw new StubException(); // assertFullyCovered()
+		} // assertEmpty()
 	}
 
 	private static void implicitException() {
-		synchronized (lock) { // $line-implicitException.monitorEnter$
-			ex(); // $line-implicitException.exception$
-		} // $line-implicitException.monitorExit$
+		synchronized (lock) { // assertMonitorEnterImplicitException()
+			ex(); // assertNotCovered()
+		} // assertMonitorExitImplicitException()
 	}
 
 	public static void main(String[] args) {
diff --git a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/SyntheticTarget.java b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/SyntheticTarget.java
index 79f41b10..14ae3c09 100644
--- a/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/SyntheticTarget.java
+++ b/org.jacoco.core.test.validation.java5/src/org/jacoco/core/test/validation/java5/targets/SyntheticTarget.java
@@ -14,9 +14,9 @@ package org.jacoco.core.test.validation.java5.targets;
 /**
  * This test target results in synthetic methods.
  */
-public class SyntheticTarget { // $line-classdef$
+public class SyntheticTarget { // assertEmpty()
 
-	private static int counter; // $line-field$
+	private static int counter; // assertEmpty()
 
 	/**
 	 * {@link org.jacoco.core.test.validation.java5.targets.ConstructorsTarget
@@ -27,7 +27,7 @@ public class SyntheticTarget { // $line-classdef$
 	private SyntheticTarget() {
 	}
 
-	static class Inner extends SyntheticTarget { // $line-inner.classdef$
+	static class Inner extends SyntheticTarget { // assertEmpty()
 
 		Inner() {
 		}