diff --git a/lib/src/test/java/com/jeantessier/dependency/TestClosureInboundSelector.java b/lib/src/test/java/com/jeantessier/dependency/TestClosureInboundSelector.java
index dcaa5e3c..12d8646d 100644
--- a/lib/src/test/java/com/jeantessier/dependency/TestClosureInboundSelector.java
+++ b/lib/src/test/java/com/jeantessier/dependency/TestClosureInboundSelector.java
@@ -107,14 +107,14 @@ void testOneCopiedNode() {
         selector.traverseNodes(Collections.singleton(b_B_b));
 
         assertEquals(2, localFactory.getPackages().size(), "packages in scope");
-        assertEquals(2, localFactory.getClasses().size(), "classes in scope" );
+        assertEquals(2, localFactory.getClasses().size(), "classes in scope");
         assertEquals(2, localFactory.getFeatures().size(), "features in scope");
 
-        assertEquals(a, localFactory.getPackages().get("a"), "package a in scope"    );
-        assertEquals(a_A, localFactory.getClasses().get("a.A"), "class a.A in scope"    );
+        assertEquals(a, localFactory.getPackages().get("a"), "package a in scope");
+        assertEquals(a_A, localFactory.getClasses().get("a.A"), "class a.A in scope");
         assertEquals(a_A_a, localFactory.getFeatures().get("a.A.a"), "feature a.A.a in scope");
-        assertEquals(b, localFactory.getPackages().get("b"), "package b in scope"    );
-        assertEquals(b_B, localFactory.getClasses().get("b.B"), "class b.B in scope"    );
+        assertEquals(b, localFactory.getPackages().get("b"), "package b in scope");
+        assertEquals(b_B, localFactory.getClasses().get("b.B"), "class b.B in scope");
         assertEquals(b_B_b, localFactory.getFeatures().get("b.B.b"), "feature b.B.b in scope");
 
         assertNotSame(a, localFactory.getPackages().get("a"), "package a in scope");
diff --git a/lib/src/test/java/com/jeantessier/dependency/TestClosureOutboundSelector.java b/lib/src/test/java/com/jeantessier/dependency/TestClosureOutboundSelector.java
index 32866850..30b59f8a 100644
--- a/lib/src/test/java/com/jeantessier/dependency/TestClosureOutboundSelector.java
+++ b/lib/src/test/java/com/jeantessier/dependency/TestClosureOutboundSelector.java
@@ -107,14 +107,14 @@ void testOneCopiedNode() {
         selector.traverseNodes(Collections.singleton(b_B_b));
 
         assertEquals(2, localFactory.getPackages().size(), "packages in scope");
-        assertEquals(2, localFactory.getClasses().size(), "classes in scope" );
+        assertEquals(2, localFactory.getClasses().size(), "classes in scope");
         assertEquals(2, localFactory.getFeatures().size(), "features in scope");
 
-        assertEquals(b, localFactory.getPackages().get("b"), "package b in scope"    );
-        assertEquals(b_B, localFactory.getClasses().get("b.B"), "class b.B in scope"    );
+        assertEquals(b, localFactory.getPackages().get("b"), "package b in scope");
+        assertEquals(b_B, localFactory.getClasses().get("b.B"), "class b.B in scope");
         assertEquals(b_B_b, localFactory.getFeatures().get("b.B.b"), "feature b.B.b in scope");
-        assertEquals(c, localFactory.getPackages().get("c"), "package c in scope"    );
-        assertEquals(c_C, localFactory.getClasses().get("c.C"), "class c.C in scope"    );
+        assertEquals(c, localFactory.getPackages().get("c"), "package c in scope");
+        assertEquals(c_C, localFactory.getClasses().get("c.C"), "class c.C in scope");
         assertEquals(c_C_c, localFactory.getFeatures().get("c.C.c"), "feature c.C.c in scope");
 
         assertNotSame(b, localFactory.getPackages().get("b"), "package b in scope");
diff --git a/lib/src/test/java/com/jeantessier/dependency/TestClosureStartSelector.java b/lib/src/test/java/com/jeantessier/dependency/TestClosureStartSelector.java
index e710c025..1d0b1bc9 100644
--- a/lib/src/test/java/com/jeantessier/dependency/TestClosureStartSelector.java
+++ b/lib/src/test/java/com/jeantessier/dependency/TestClosureStartSelector.java
@@ -32,172 +32,169 @@
 
 package com.jeantessier.dependency;
 
+import org.junit.jupiter.api.*;
+
 import java.util.*;
 
-import junit.framework.*;
-
-public class TestClosureStartSelector extends TestCase {
-    private NodeFactory factory;
-    private NodeFactory localFactory;
-    private RegularExpressionSelectionCriteria localCriteria;
-
-    private PackageNode a;
-    private ClassNode   a_A;
-    private FeatureNode a_A_a;
-    
-    private PackageNode b;
-    private ClassNode   b_B;
-    private FeatureNode b_B_b;
-    
-    private PackageNode c;
-    private ClassNode   c_C;
-    private FeatureNode c_C_c;
-
-    protected void setUp() throws Exception {
-        factory = new NodeFactory();
-        localFactory = new NodeFactory();
-        localCriteria = new RegularExpressionSelectionCriteria();
-
-        a     = factory.createPackage("a");
-        a_A   = factory.createClass("a.A");
-        a_A_a = factory.createFeature("a.A.a");
-        
-        b     = factory.createPackage("b");
-        b_B   = factory.createClass("b.B");
-        b_B_b = factory.createFeature("b.B.b");
-        
-        c     = factory.createPackage("c");
-        c_C   = factory.createClass("c.C");
-        c_C_c = factory.createFeature("c.C.c");
+import static org.junit.jupiter.api.Assertions.*;
+
+public class TestClosureStartSelector {
+    private final NodeFactory factory = new NodeFactory();
+    private final NodeFactory localFactory = new NodeFactory();
+    private final RegularExpressionSelectionCriteria localCriteria = new RegularExpressionSelectionCriteria();
+
+    private final Node a = factory.createPackage("a");
+    private final Node a_A = factory.createClass("a.A");
+    private final Node a_A_a = factory.createFeature("a.A.a");
+
+    private final Node b = factory.createPackage("b");
+    private final Node b_B = factory.createClass("b.B");
+    private final Node b_B_b = factory.createFeature("b.B.b");
+
+    private final Node c = factory.createPackage("c");
+    private final Node c_C = factory.createClass("c.C");
+    private final Node c_C_c = factory.createFeature("c.C.c");
 
+    @BeforeEach
+    void setUp() {
         a_A_a.addDependency(b_B_b);
         b_B_b.addDependency(c_C_c);
     }
 
-    public void testOneSelectedNode() {
+    @Test
+    void testOneSelectedNode() {
         localCriteria.setGlobalIncludes("/b.B.b/");
 
         ClosureStartSelector selector = new ClosureStartSelector(localFactory, localCriteria);
         selector.traverseNodes(factory.getPackages().values());
 
-        assertEquals("nodes in selection", 1, selector.getSelectedNodes().size());
-        assertEquals("b.B.b in selection", b_B_b, selector.getSelectedNodes().iterator().next());
-        assertSame("b.B.b in selection", b_B_b, selector.getSelectedNodes().iterator().next());
+        assertEquals(1, selector.getSelectedNodes().size(), "nodes in selection");
+        assertEquals(b_B_b, selector.getSelectedNodes().iterator().next(), "b.B.b in selection");
+        assertSame(b_B_b, selector.getSelectedNodes().iterator().next(), "b.B.b in selection");
     }
 
-    public void testOneCopiedNode() {
+    @Test
+    void testOneCopiedNode() {
         localCriteria.setGlobalIncludes("/b.B.b/");
 
         ClosureStartSelector selector = new ClosureStartSelector(localFactory, localCriteria);
         selector.traverseNodes(factory.getPackages().values());
 
-        assertEquals("packages in scope", 1, localFactory.getPackages().size());
-        assertEquals("classes in scope" , 1, localFactory.getClasses().size());
-        assertEquals("features in scope", 1, localFactory.getFeatures().size());
+        assertEquals(1, localFactory.getPackages().size(), "packages in scope");
+        assertEquals(1, localFactory.getClasses().size(), "classes in scope");
+        assertEquals(1, localFactory.getFeatures().size(), "features in scope");
 
-        assertEquals("package b in scope"    , b,     localFactory.getPackages().get("b"));
-        assertEquals("class b.B in scope"    , b_B,   localFactory.getClasses().get("b.B"));
-        assertEquals("feature b.B.b in scope", b_B_b, localFactory.getFeatures().get("b.B.b"));
+        assertEquals(b, localFactory.getPackages().get("b"), "package b in scope");
+        assertEquals(b_B, localFactory.getClasses().get("b.B"), "class b.B in scope");
+        assertEquals(b_B_b, localFactory.getFeatures().get("b.B.b"), "feature b.B.b in scope");
 
-        assertNotSame("package b in scope"    , b,     localFactory.getPackages().get("b"));
-        assertNotSame("class b.B in scope"    , b_B,   localFactory.getClasses().get("b.B"));
-        assertNotSame("feature b.B.b in scope", b_B_b, localFactory.getFeatures().get("b.B.b"));
+        assertNotSame(b, localFactory.getPackages().get("b"), "package b in scope");
+        assertNotSame(b_B, localFactory.getClasses().get("b.B"), "class b.B in scope");
+        assertNotSame(b_B_b, localFactory.getFeatures().get("b.B.b"), "feature b.B.b in scope");
 
-        assertEquals("nodes in selection", 1, selector.getCopiedNodes().size());
-        assertEquals("b.B.b in selection", b_B_b, selector.getCopiedNodes().iterator().next());
-        assertNotSame("b.B.b in selection", b_B_b, selector.getCopiedNodes().iterator().next());
-        assertSame("b.B.b in selection", localFactory.getFeatures().get("b.B.b"), selector.getCopiedNodes().iterator().next());
+        assertEquals(1, selector.getCopiedNodes().size(), "nodes in selection");
+        assertEquals(b_B_b, selector.getCopiedNodes().iterator().next(), "b.B.b in selection");
+        assertNotSame(b_B_b, selector.getCopiedNodes().iterator().next(), "b.B.b in selection");
+        assertSame(localFactory.getFeatures().get("b.B.b"), selector.getCopiedNodes().iterator().next(), "b.B.b in selection");
     }
 
-    public void testMultipleSelectedNodes() {
+    @Test
+    void testMultipleSelectedNodes() {
         localCriteria.setGlobalIncludes("/a.A.a/, /^b/");
 
         ClosureStartSelector selector = new ClosureStartSelector(localFactory, localCriteria);
         selector.traverseNodes(factory.getPackages().values());
 
-        assertEquals("nodes in selection", 4, selector.getSelectedNodes().size());
-        assertTrue("a.A.a in selection", selector.getSelectedNodes().contains(a_A_a));
-        assertTrue("b in selection",     selector.getSelectedNodes().contains(b));
-        assertTrue("b.B in selection",   selector.getSelectedNodes().contains(b_B));
-        assertTrue("b.B.b in selection", selector.getSelectedNodes().contains(b_B_b));
+        assertEquals(4, selector.getSelectedNodes().size(), "nodes in selection");
+        assertTrue(selector.getSelectedNodes().contains(a_A_a), "a.A.a in selection");
+        assertTrue(selector.getSelectedNodes().contains(b), "b in selection");
+        assertTrue(selector.getSelectedNodes().contains(b_B), "b.B in selection");
+        assertTrue(selector.getSelectedNodes().contains(b_B_b), "b.B.b in selection");
     }
 
-    public void testMultipleCopiedNodes() {
+    @Test
+    void testMultipleCopiedNodes() {
         localCriteria.setGlobalIncludes("/a.A.a/, /^b/");
 
         ClosureStartSelector selector = new ClosureStartSelector(localFactory, localCriteria);
         selector.traverseNodes(factory.getPackages().values());
 
-        assertEquals("packages in scope", 2, localFactory.getPackages().size());
-        assertEquals("classes in scope" , 2, localFactory.getClasses().size());
-        assertEquals("features in scope", 2, localFactory.getFeatures().size());
-
-        assertEquals("package a in scope"    , a,     localFactory.getPackages().get("a"));
-        assertEquals("class a.A in scope"    , a_A,   localFactory.getClasses().get("a.A"));
-        assertEquals("feature a.A.a in scope", a_A_a, localFactory.getFeatures().get("a.A.a"));
-        assertEquals("package b in scope"    , b,     localFactory.getPackages().get("b"));
-        assertEquals("class b.B in scope"    , b_B,   localFactory.getClasses().get("b.B"));
-        assertEquals("feature b.B.b in scope", b_B_b, localFactory.getFeatures().get("b.B.b"));
-
-        assertNotSame("package a in scope"    , a,     localFactory.getPackages().get("a"));
-        assertNotSame("class a.A in scope"    , a_A,   localFactory.getClasses().get("a.A"));
-        assertNotSame("feature a.A.a in scope", a_A_a, localFactory.getFeatures().get("a.A.a"));
-        assertNotSame("package b in scope"    , b,     localFactory.getPackages().get("b"));
-        assertNotSame("class b.B in scope"    , b_B,   localFactory.getClasses().get("b.B"));
-        assertNotSame("feature b.B.b in scope", b_B_b, localFactory.getFeatures().get("b.B.b"));
-
-        assertEquals("nodes in selection", 4, selector.getCopiedNodes().size());
-        assertTrue("a.A.a in selection", selector.getCopiedNodes().contains(a_A_a));
-        assertTrue("b in selection",     selector.getCopiedNodes().contains(b));
-        assertTrue("b.B in selection",   selector.getCopiedNodes().contains(b_B));
-        assertTrue("b.B.b in selection", selector.getCopiedNodes().contains(b_B_b));
+        assertEquals(2, localFactory.getPackages().size(), "packages in scope");
+        assertEquals(2, localFactory.getClasses().size(), "classes in scope");
+        assertEquals(2, localFactory.getFeatures().size(), "features in scope");
+
+        assertEquals(a, localFactory.getPackages().get("a"), "package a in scope");
+        assertEquals(a_A, localFactory.getClasses().get("a.A"), "class a.A in scope");
+        assertEquals(a_A_a, localFactory.getFeatures().get("a.A.a"), "feature a.A.a in scope");
+        assertEquals(b, localFactory.getPackages().get("b"), "package b in scope");
+        assertEquals(b_B, localFactory.getClasses().get("b.B"), "class b.B in scope");
+        assertEquals(b_B_b, localFactory.getFeatures().get("b.B.b"), "feature b.B.b in scope");
+
+        assertNotSame(a, localFactory.getPackages().get("a"), "package a in scope");
+        assertNotSame(a_A, localFactory.getClasses().get("a.A"), "class a.A in scope");
+        assertNotSame(a_A_a, localFactory.getFeatures().get("a.A.a"), "feature a.A.a in scope");
+        assertNotSame(b, localFactory.getPackages().get("b"), "package b in scope");
+        assertNotSame(b_B, localFactory.getClasses().get("b.B"), "class b.B in scope");
+        assertNotSame(b_B_b, localFactory.getFeatures().get("b.B.b"), "feature b.B.b in scope");
+
+        assertEquals(4, selector.getCopiedNodes().size(), "nodes in selection");
+        assertTrue(selector.getCopiedNodes().contains(a_A_a), "a.A.a in selection");
+        assertTrue(selector.getCopiedNodes().contains(b), "b in selection");
+        assertTrue(selector.getCopiedNodes().contains(b_B), "b.B in selection");
+        assertTrue(selector.getCopiedNodes().contains(b_B_b), "b.B.b in selection");
     }
 
-    public void testVisitInferredPackage() {
+    @Test
+    void testVisitInferredPackage() {
         ClosureStartSelector selector = new ClosureStartSelector(localFactory, new ComprehensiveSelectionCriteria());
         selector.traverseNodes(Collections.singleton(b));
 
-        assertEquals("package.isConfirmed()", b.isConfirmed(), localFactory.getPackages().get(b.getName()).isConfirmed());
+        assertEquals(b.isConfirmed(), localFactory.getPackages().get(b.getName()).isConfirmed(), "package.isConfirmed()");
     }
 
-    public void testVisitConfirmedPackage() {
+    @Test
+    void testVisitConfirmedPackage() {
         b.setConfirmed(true);
         
         ClosureStartSelector selector = new ClosureStartSelector(localFactory, new ComprehensiveSelectionCriteria());
         selector.traverseNodes(Collections.singleton(b));
 
-        assertEquals("package.isConfirmed()", b.isConfirmed(), localFactory.getPackages().get(b.getName()).isConfirmed());
+        assertEquals(b.isConfirmed(), localFactory.getPackages().get(b.getName()).isConfirmed(), "package.isConfirmed()");
     }
 
-    public void testVisitInferredClass() {
+    @Test
+    void testVisitInferredClass() {
         ClosureStartSelector selector = new ClosureStartSelector(localFactory, new ComprehensiveSelectionCriteria());
         selector.traverseNodes(Collections.singleton(b_B));
 
-        assertEquals("class.isConfirmed()", b_B.isConfirmed(), localFactory.getClasses().get(b_B.getName()).isConfirmed());
+        assertEquals(b_B.isConfirmed(), localFactory.getClasses().get(b_B.getName()).isConfirmed(), "class.isConfirmed()");
     }
 
-    public void testVisitConfirmedClass() {
+    @Test
+    void testVisitConfirmedClass() {
         b_B.setConfirmed(true);
         
         ClosureStartSelector selector = new ClosureStartSelector(localFactory, new ComprehensiveSelectionCriteria());
         selector.traverseNodes(Collections.singleton(b_B));
 
-        assertEquals("class.isConfirmed()", b_B.isConfirmed(), localFactory.getClasses().get(b_B.getName()).isConfirmed());
+        assertEquals(b_B.isConfirmed(), localFactory.getClasses().get(b_B.getName()).isConfirmed(), "class.isConfirmed()");
     }
 
-    public void testVisitInferredFeature() {
+    @Test
+    void testVisitInferredFeature() {
         ClosureStartSelector selector = new ClosureStartSelector(localFactory, new ComprehensiveSelectionCriteria());
         selector.traverseNodes(Collections.singleton(b_B_b));
 
-        assertEquals("feature.isConfirmed()", b_B_b.isConfirmed(), localFactory.getFeatures().get(b_B_b.getName()).isConfirmed());
+        assertEquals(b_B_b.isConfirmed(), localFactory.getFeatures().get(b_B_b.getName()).isConfirmed(), "feature.isConfirmed()");
     }
 
-    public void testVisitConfirmedFeature() {
+    @Test
+    void testVisitConfirmedFeature() {
         b_B_b.setConfirmed(true);
         
         ClosureStartSelector selector = new ClosureStartSelector(localFactory, new ComprehensiveSelectionCriteria());
         selector.traverseNodes(Collections.singleton(b_B_b));
 
-        assertEquals("feature.isConfirmed()", b_B_b.isConfirmed(), localFactory.getFeatures().get(b_B_b.getName()).isConfirmed());
+        assertEquals(b_B_b.isConfirmed(), localFactory.getFeatures().get(b_B_b.getName()).isConfirmed(), "feature.isConfirmed()");
     }
 }
diff --git a/lib/src/test/java/com/jeantessier/dependency/TestClosureStopSelector.java b/lib/src/test/java/com/jeantessier/dependency/TestClosureStopSelector.java
index ba5e3bcf..98ba7cf6 100644
--- a/lib/src/test/java/com/jeantessier/dependency/TestClosureStopSelector.java
+++ b/lib/src/test/java/com/jeantessier/dependency/TestClosureStopSelector.java
@@ -32,81 +32,61 @@
 
 package com.jeantessier.dependency;
 
+import org.junit.jupiter.api.*;
+
 import java.util.*;
 
-import junit.framework.*;
-
-public class TestClosureStopSelector extends TestCase {
-    private PackageNode a;
-    private ClassNode a_A;
-    private FeatureNode a_A_a;
-    
-    private PackageNode b;
-    private ClassNode b_B;
-    private FeatureNode b_B_b;
-    
-    private PackageNode c;
-    private ClassNode c_C;
-    private FeatureNode c_C_c;
-
-    protected void setUp() throws Exception {
-        super.setUp();
-        
-        var factory = new NodeFactory();
-
-        a = factory.createPackage("a");
-        a_A = factory.createClass("a.A");
-        a_A_a = factory.createFeature("a.A.a");
-        
-        b = factory.createPackage("b");
-        b_B = factory.createClass("b.B");
-        b_B_b = factory.createFeature("b.B.b");
-        
-        c = factory.createPackage("c");
-        c_C = factory.createClass("c.C");
-        c_C_c = factory.createFeature("c.C.c");
+import static org.junit.jupiter.api.Assertions.*;
+
+public class TestClosureStopSelector {
+    private final NodeFactory factory = new NodeFactory();
+    private final RegularExpressionSelectionCriteria localCriteria = new RegularExpressionSelectionCriteria();
+
+    private final Node a_A_a = factory.createFeature("a.A.a");
+    private final Node b_B_b = factory.createFeature("b.B.b");
+    private final Node c_C_c = factory.createFeature("c.C.c");
+
+    private final ClosureStopSelector selector = new ClosureStopSelector(localCriteria);
 
+    @BeforeEach
+    void setUp() {
         a_A_a.addDependency(b_B_b);
         b_B_b.addDependency(c_C_c);
     }
 
-    public void testEmpty() {
-        RegularExpressionSelectionCriteria localCriteria = new RegularExpressionSelectionCriteria();
+    @Test
+    void testEmpty() {
         localCriteria.setGlobalIncludes("/b.B.b/");
 
-        ClosureStopSelector selector = new ClosureStopSelector(localCriteria);
-        selector.traverseNodes(Collections.emptySet());
+        selector.traverseNodes(List.of());
 
-        assertTrue("Failed to recognize empty collection", selector.isDone());
+        assertTrue(selector.isDone(), "Failed to recognize empty collection");
     }
 
-    public void testPositive() {
-        RegularExpressionSelectionCriteria localCriteria = new RegularExpressionSelectionCriteria();
+    @Test
+    void testPositive() {
         localCriteria.setGlobalIncludes("/b.B.b/");
 
-        ClosureStopSelector selector = new ClosureStopSelector(localCriteria);
-        selector.traverseNodes(Collections.singleton(b_B_b));
+        selector.traverseNodes(List.of(b_B_b));
 
-        assertTrue("Failed to recognize target", selector.isDone());
+        assertTrue(selector.isDone(), "Failed to recognize target");
     }
 
-    public void testNegative() {
-        RegularExpressionSelectionCriteria localCriteria = new RegularExpressionSelectionCriteria();
+    @Test
+    void testNegative() {
         localCriteria.setGlobalIncludes("/b.B.b/");
 
-        ClosureStopSelector selector = new ClosureStopSelector(localCriteria);
-        selector.traverseNodes(Collections.singleton(a_A_a));
+        selector.traverseNodes(List.of(a_A_a));
 
-        assertFalse("Failed to ignore non-target", selector.isDone());
+        assertFalse(selector.isDone(), "Failed to ignore non-target");
     }
 
-    public void testMultiple() {
-        RegularExpressionSelectionCriteria localCriteria = new RegularExpressionSelectionCriteria();
+    @Test
+    void testMultiple() {
         localCriteria.setGlobalIncludes("/b.B.b/");
 
-        ClosureStopSelector selector = new ClosureStopSelector(localCriteria);
         selector.traverseNodes(List.of(a_A_a, b_B_b));
 
-        assertTrue("Failed to recognize target", selector.isDone());
+        assertTrue(selector.isDone(), "Failed to recognize target");
     }
 }
diff --git a/lib/src/test/java/com/jeantessier/dependency/TestCollectionSelectionCriteria.java b/lib/src/test/java/com/jeantessier/dependency/TestCollectionSelectionCriteria.java
index fd34a6a7..c5fd4836 100644
--- a/lib/src/test/java/com/jeantessier/dependency/TestCollectionSelectionCriteria.java
+++ b/lib/src/test/java/com/jeantessier/dependency/TestCollectionSelectionCriteria.java
@@ -32,151 +32,150 @@
 
 package com.jeantessier.dependency;
 
+import org.junit.jupiter.api.*;
+
 import java.util.*;
 
-import junit.framework.*;
+import static org.junit.jupiter.api.Assertions.*;
 
-public class TestCollectionSelectionCriteria extends TestCase {
-    private Collection<String> include;
-    private Collection<String> exclude;
-    private CollectionSelectionCriteria criteria;
+public class TestCollectionSelectionCriteria {
+    private final NodeFactory factory = new NodeFactory();
 
-    private PackageNode a;
-    private ClassNode   a_A;
-    private FeatureNode a_A_a;
+    private final PackageNode a = factory.createPackage("a");
+    private final ClassNode a_A = factory.createClass("a.A");
+    private final FeatureNode a_A_a = factory.createFeature("a.A.a");
     
-    private PackageNode b;
-    private ClassNode   b_B;
-    private FeatureNode b_B_b;
-
-    protected void setUp() throws Exception {
-        include = new HashSet<>();
-        exclude = new HashSet<>();
-        criteria = new CollectionSelectionCriteria(include, exclude);
-
-        var factory = new NodeFactory();
-
-        a     = factory.createPackage("a");
-        a_A   = factory.createClass("a.A");
-        a_A_a = factory.createFeature("a.A.a");
-        
-        b     = factory.createPackage("b");
-        b_B   = factory.createClass("b.B");
-        b_B_b = factory.createFeature("b.B.b");
-    }
+    private final PackageNode b = factory.createPackage("b");
+    private final ClassNode b_B = factory.createClass("b.B");
+    private final FeatureNode b_B_b = factory.createFeature("b.B.b");
+
+    private final Collection<String> include = new HashSet<>();
+    private final Collection<String> exclude = new HashSet<>();
+
+    private CollectionSelectionCriteria criteria = new CollectionSelectionCriteria(include, exclude);
 
-    public void testEmptyInclude() {
-        assertFalse("a",     criteria.matches(a));
-        assertFalse("a.A",   criteria.matches(a_A));
-        assertFalse("a.A.a", criteria.matches(a_A_a));
+    @Test
+    void testEmptyInclude() {
+        assertFalse(criteria.matches(a), "a");
+        assertFalse(criteria.matches(a_A), "a.A");
+        assertFalse(criteria.matches(a_A_a), "a.A.a");
 
-        assertFalse("b",     criteria.matches(b));
-        assertFalse("b.B",   criteria.matches(b_B));
-        assertFalse("b.B.b", criteria.matches(b_B_b));
+        assertFalse(criteria.matches(b), "b");
+        assertFalse(criteria.matches(b_B), "b.B");
+        assertFalse(criteria.matches(b_B_b), "b.B.b");
     }
 
-    public void testNullInclude() {
+    @Test
+    void testNullInclude() {
         criteria = new CollectionSelectionCriteria(null, exclude);
 
-        assertTrue("a",     criteria.matches(a));
-        assertTrue("a.A",   criteria.matches(a_A));
-        assertTrue("a.A.a", criteria.matches(a_A_a));
+        assertTrue(criteria.matches(a), "a");
+        assertTrue(criteria.matches(a_A), "a.A");
+        assertTrue(criteria.matches(a_A_a), "a.A.a");
 
-        assertTrue("b",     criteria.matches(b));
-        assertTrue("b.B",   criteria.matches(b_B));
-        assertTrue("b.B.b", criteria.matches(b_B_b));
+        assertTrue(criteria.matches(b), "b");
+        assertTrue(criteria.matches(b_B), "b.B");
+        assertTrue(criteria.matches(b_B_b), "b.B.b");
     }
 
-    public void testMatchPackageNode() {
+    @Test
+    void testMatchPackageNode() {
         include.add("a");
 
-        assertTrue("a",      criteria.matches(a));
-        assertFalse("a.A",   criteria.matches(a_A));
-        assertFalse("a.A.a", criteria.matches(a_A_a));
+        assertTrue(criteria.matches(a), "a");
+        assertFalse(criteria.matches(a_A), "a.A");
+        assertFalse(criteria.matches(a_A_a), "a.A.a");
 
-        assertFalse("b",     criteria.matches(b));
-        assertFalse("b.B",   criteria.matches(b_B));
-        assertFalse("b.B.b", criteria.matches(b_B_b));
+        assertFalse(criteria.matches(b), "b");
+        assertFalse(criteria.matches(b_B), "b.B");
+        assertFalse(criteria.matches(b_B_b), "b.B.b");
     }
 
-    public void testMatchClassNode() {
+    @Test
+    void testMatchClassNode() {
         include.add("a.A");
 
-        assertFalse("a",     criteria.matches(a));
-        assertTrue("a.A",    criteria.matches(a_A));
-        assertFalse("a.A.a", criteria.matches(a_A_a));
+        assertFalse(criteria.matches(a), "a");
+        assertTrue(criteria.matches(a_A), "a.A");
+        assertFalse(criteria.matches(a_A_a), "a.A.a");
 
-        assertFalse("b",     criteria.matches(b));
-        assertFalse("b.B",   criteria.matches(b_B));
-        assertFalse("b.B.b", criteria.matches(b_B_b));
+        assertFalse(criteria.matches(b), "b");
+        assertFalse(criteria.matches(b_B), "b.B");
+        assertFalse(criteria.matches(b_B_b), "b.B.b");
     }
 
-    public void testMatchFeatureNode() {
+    @Test
+    void testMatchFeatureNode() {
         include.add("a.A.a");
 
-        assertFalse("a",     criteria.matches(a));
-        assertFalse("a.A",   criteria.matches(a_A));
-        assertTrue("a.A.a",  criteria.matches(a_A_a));
+        assertFalse(criteria.matches(a), "a");
+        assertFalse(criteria.matches(a_A), "a.A");
+        assertTrue(criteria.matches(a_A_a), "a.A.a");
 
-        assertFalse("b",     criteria.matches(b));
-        assertFalse("b.B",   criteria.matches(b_B));
-        assertFalse("b.B.b", criteria.matches(b_B_b));
+        assertFalse(criteria.matches(b), "b");
+        assertFalse(criteria.matches(b_B), "b.B");
+        assertFalse(criteria.matches(b_B_b), "b.B.b");
     }
 
-    public void testMatchPackageName() {
+    @Test
+    void testMatchPackageName() {
         include.add("a");
 
-        assertTrue("a",      criteria.matchesPackageName("a"));
-        assertFalse("a.A",   criteria.matchesClassName("a.A"));
-        assertFalse("a.A.a", criteria.matchesFeatureName("a.A.a"));
+        assertTrue(criteria.matchesPackageName("a"), "a");
+        assertFalse(criteria.matchesClassName("a.A"), "a.A");
+        assertFalse(criteria.matchesFeatureName("a.A.a"), "a.A.a");
 
-        assertFalse("b",     criteria.matchesPackageName("b"));
-        assertFalse("b.B",   criteria.matchesClassName("b.B"));
-        assertFalse("b.B.b", criteria.matchesFeatureName("b.B.b"));
+        assertFalse(criteria.matchesPackageName("b"), "b");
+        assertFalse(criteria.matchesClassName("b.B"), "b.B");
+        assertFalse(criteria.matchesFeatureName("b.B.b"), "b.B.b");
     }
 
-    public void testMatchClassName() {
+    @Test
+    void testMatchClassName() {
         include.add("a.A");
 
-        assertFalse("a",     criteria.matchesPackageName("a"));
-        assertTrue("a.A",    criteria.matchesClassName("a.A"));
-        assertFalse("a.A.a", criteria.matchesFeatureName("a.A.a"));
+        assertFalse(criteria.matchesPackageName("a"), "a");
+        assertTrue(criteria.matchesClassName("a.A"), "a.A");
+        assertFalse(criteria.matchesFeatureName("a.A.a"), "a.A.a");
 
-        assertFalse("b",     criteria.matchesPackageName("b"));
-        assertFalse("b.B",   criteria.matchesClassName("b.B"));
-        assertFalse("b.B.b", criteria.matchesFeatureName("b.B.b"));
+        assertFalse(criteria.matchesPackageName("b"), "b");
+        assertFalse(criteria.matchesClassName("b.B"), "b.B");
+        assertFalse(criteria.matchesFeatureName("b.B.b"), "b.B.b");
     }
 
-    public void testMatchFeatureName() {
+    @Test
+    void testMatchFeatureName() {
         include.add("a.A.a");
 
-        assertFalse("a",     criteria.matchesPackageName("a"));
-        assertFalse("a.A",   criteria.matchesClassName("a.A"));
-        assertTrue("a.A.a",  criteria.matchesFeatureName("a.A.a"));
+        assertFalse(criteria.matchesPackageName("a"), "a");
+        assertFalse(criteria.matchesClassName("a.A"), "a.A");
+        assertTrue(criteria.matchesFeatureName("a.A.a"), "a.A.a");
 
-        assertFalse("b",     criteria.matchesPackageName("b"));
-        assertFalse("b.B",   criteria.matchesClassName("b.B"));
-        assertFalse("b.B.b", criteria.matchesFeatureName("b.B.b"));
+        assertFalse(criteria.matchesPackageName("b"), "b");
+        assertFalse(criteria.matchesClassName("b.B"), "b.B");
+        assertFalse(criteria.matchesFeatureName("b.B.b"), "b.B.b");
     }
 
-    public void testExclude() {
+    @Test
+    void testExclude() {
         include.add("a");
         include.add("a.A");
         include.add("a.A.a");
         exclude.add("a.A.a");
 
-        assertTrue("a",      criteria.matches(a));
-        assertTrue("a.A",    criteria.matches(a_A));
-        assertFalse("a.A.a", criteria.matches(a_A_a));
+        assertTrue(criteria.matches(a), "a");
+        assertTrue(criteria.matches(a_A), "a.A");
+        assertFalse(criteria.matches(a_A_a), "a.A.a");
     }
 
-    public void testExcludeOnly() {
+    @Test
+    void testExcludeOnly() {
         exclude.add("a.A.a");
 
         criteria = new CollectionSelectionCriteria(null, exclude);
 
-        assertTrue("a",      criteria.matches(a));
-        assertTrue("a.A",    criteria.matches(a_A));
-        assertFalse("a.A.a", criteria.matches(a_A_a));
+        assertTrue(criteria.matches(a), "a");
+        assertTrue(criteria.matches(a_A), "a.A");
+        assertFalse(criteria.matches(a_A_a), "a.A.a");
     }
 }
diff --git a/lib/src/test/java/com/jeantessier/dependency/TestComprehensiveSelectionCriteria.java b/lib/src/test/java/com/jeantessier/dependency/TestComprehensiveSelectionCriteria.java
index f3c0efd8..4d46db7b 100644
--- a/lib/src/test/java/com/jeantessier/dependency/TestComprehensiveSelectionCriteria.java
+++ b/lib/src/test/java/com/jeantessier/dependency/TestComprehensiveSelectionCriteria.java
@@ -32,50 +32,37 @@
 
 package com.jeantessier.dependency;
 
-import junit.framework.*;
+import org.junit.jupiter.api.*;
 
-public class TestComprehensiveSelectionCriteria extends TestCase {
-    private ComprehensiveSelectionCriteria criteria;
-    private NodeFactory factory;
+import static org.junit.jupiter.api.Assertions.*;
 
-    private PackageNode a;
-    private ClassNode a_A;
-    private FeatureNode a_A_a;
-    
-    private PackageNode b;
-    private ClassNode b_B;
-    private FeatureNode b_B_b;
-    
-    private PackageNode c;
-    private ClassNode c_C;
-    private FeatureNode c_C_c;
+public class TestComprehensiveSelectionCriteria {
+    private final NodeFactory factory = new NodeFactory();
 
-    protected void setUp() throws Exception {
-        criteria = new ComprehensiveSelectionCriteria();
-        factory = new NodeFactory();
+    private final PackageNode a     = factory.createPackage("a");
+    private final ClassNode a_A   = factory.createClass("a.A");
+    private final FeatureNode a_A_a = factory.createFeature("a.A.a");
 
-        a     = factory.createPackage("a");
-        a_A   = factory.createClass("a.A");
-        a_A_a = factory.createFeature("a.A.a");
-        
-        b     = factory.createPackage("b");
-        b_B   = factory.createClass("b.B");
-        b_B_b = factory.createFeature("b.B.b");
-        
-        c     = factory.createPackage("c");
-        c_C   = factory.createClass("c.C");
-        c_C_c = factory.createFeature("c.C.c");
-    }
-    
-    public void testMatch() {
-        assertTrue("a not in package scope",     criteria.matches(a));
-        assertTrue("a.A not in package scope",   criteria.matches(a_A));
-        assertTrue("a.A.a not in package scope", criteria.matches(a_A_a));
-        assertTrue("b not in package scope",     criteria.matches(b));
-        assertTrue("b.B not in package scope",   criteria.matches(b_B));
-        assertTrue("b.B.b not in package scope", criteria.matches(b_B_b));
-        assertTrue("c not in package scope",     criteria.matches(c));
-        assertTrue("c.C not in package scope",   criteria.matches(c_C));
-        assertTrue("c.C.c not in package scope", criteria.matches(c_C_c));
+    private final PackageNode b     = factory.createPackage("b");
+    private final ClassNode b_B   = factory.createClass("b.B");
+    private final FeatureNode b_B_b = factory.createFeature("b.B.b");
+
+    private final PackageNode c     = factory.createPackage("c");
+    private final ClassNode c_C   = factory.createClass("c.C");
+    private final FeatureNode c_C_c = factory.createFeature("c.C.c");
+
+    private final ComprehensiveSelectionCriteria criteria = new ComprehensiveSelectionCriteria();
+
+    @Test
+    void testMatch() {
+        assertTrue(criteria.matches(a), "a not in package scope");
+        assertTrue(criteria.matches(a_A), "a.A not in package scope");
+        assertTrue(criteria.matches(a_A_a), "a.A.a not in package scope");
+        assertTrue(criteria.matches(b), "b not in package scope");
+        assertTrue(criteria.matches(b_B), "b.B not in package scope");
+        assertTrue(criteria.matches(b_B_b), "b.B.b not in package scope");
+        assertTrue(criteria.matches(c), "c not in package scope");
+        assertTrue(criteria.matches(c_C), "c.C not in package scope");
+        assertTrue(criteria.matches(c_C_c), "c.C.c not in package scope");
     }
 }
diff --git a/lib/src/test/java/com/jeantessier/dependency/TestDeletingVisitor.java b/lib/src/test/java/com/jeantessier/dependency/TestDeletingVisitor.java
index 3e279198..79dcd796 100644
--- a/lib/src/test/java/com/jeantessier/dependency/TestDeletingVisitor.java
+++ b/lib/src/test/java/com/jeantessier/dependency/TestDeletingVisitor.java
@@ -32,21 +32,17 @@
 
 package com.jeantessier.dependency;
 
-import junit.framework.*;
+import org.junit.jupiter.api.*;
 
-public class TestDeletingVisitor extends TestCase {
-    private NodeFactory factory;
-    private DeletingVisitor visitor;
+import static org.junit.jupiter.api.Assertions.*;
 
-    protected void setUp() throws Exception {
-        super.setUp();
+public class TestDeletingVisitor {
+    private final NodeFactory factory = new NodeFactory();
+    private final DeletingVisitor visitor = new DeletingVisitor(factory);
 
-        factory = new NodeFactory();
-        visitor = new DeletingVisitor(factory);
-    }
-
-    public void testCreation() {
-        assertSame("factory", factory, visitor.getFactory());
+    @Test
+    void testCreation() {
+        assertSame(factory, visitor.getFactory(), "factory");
     }
     
     /**
@@ -58,18 +54,19 @@ public void testCreation() {
      *
      *  <p>becomes:</p>
      */
-    public void testAcceptEmptyPackage() {
-        PackageNode node = factory.createPackage("a", true);
+    @Test
+    void testAcceptEmptyPackage() {
+        var node = factory.createPackage("a", true);
         
-        assertTrue("Missing package key", factory.getPackages().containsKey("a"));
-        assertTrue("Missing package value", factory.getPackages().containsValue(node));
-        assertTrue("Package not concrete", node.isConfirmed());
+        assertTrue(factory.getPackages().containsKey("a"), "Missing package key");
+        assertTrue(factory.getPackages().containsValue(node), "Missing package value");
+        assertTrue(node.isConfirmed(), "Package not concrete");
 
         node.accept(visitor);
         
-        assertFalse("Did not remove package key", factory.getPackages().containsKey("a"));
-        assertFalse("Did not remove package value", factory.getPackages().containsValue(node));
-        assertFalse("Package is still concrete", node.isConfirmed());
+        assertFalse(factory.getPackages().containsKey("a"), "Did not remove package key");
+        assertFalse(factory.getPackages().containsValue(node), "Did not remove package value");
+        assertFalse(node.isConfirmed(), "Package is still concrete");
     }
 
     /**
@@ -82,28 +79,29 @@ public void testAcceptEmptyPackage() {
      *
      *  <p>becomes:</p>
      */
-    public void testAcceptPackageWithClasses() {
-        ClassNode node = factory.createClass("a.A", true);
+    @Test
+    void testAcceptPackageWithClasses() {
+        var node = factory.createClass("a.A", true);
         
-        assertTrue("Missing package key", factory.getPackages().containsKey("a"));
-        assertTrue("Missing package value", factory.getPackages().containsValue(node.getPackageNode()));
-        assertTrue("Package not concrete", node.getPackageNode().isConfirmed());
-        assertTrue("Package node does not contain class node", node.getPackageNode().getClasses().contains(node));
+        assertTrue(factory.getPackages().containsKey("a"), "Missing package key");
+        assertTrue(factory.getPackages().containsValue(node.getPackageNode()), "Missing package value");
+        assertTrue(node.getPackageNode().isConfirmed(), "Package not concrete");
+        assertTrue(node.getPackageNode().getClasses().contains(node), "Package node does not contain class node");
         
-        assertTrue("Missing class key", factory.getClasses().containsKey("a.A"));
-        assertTrue("Missing class value", factory.getClasses().containsValue(node));
-        assertTrue("Class not concrete", node.isConfirmed());
+        assertTrue(factory.getClasses().containsKey("a.A"), "Missing class key");
+        assertTrue(factory.getClasses().containsValue(node), "Missing class value");
+        assertTrue(node.isConfirmed(), "Class not concrete");
 
         node.getPackageNode().accept(visitor);
         
-        assertFalse("Did not remove package key", factory.getPackages().containsKey("a"));
-        assertFalse("Did not remove package value", factory.getPackages().containsValue(node.getPackageNode()));
-        assertFalse("Package is still concrete", node.getPackageNode().isConfirmed());
-        assertFalse("Package node still contains class node", node.getPackageNode().getClasses().contains(node));
+        assertFalse(factory.getPackages().containsKey("a"), "Did not remove package key");
+        assertFalse(factory.getPackages().containsValue(node.getPackageNode()), "Did not remove package value");
+        assertFalse(node.getPackageNode().isConfirmed(), "Package is still concrete");
+        assertFalse(node.getPackageNode().getClasses().contains(node), "Package node still contains class node");
 
-        assertFalse("Did not remove class key", factory.getClasses().containsKey("a.A"));
-        assertFalse("Did not remove class value", factory.getClasses().containsValue(node));
-        assertFalse("Class is still concrete", node.isConfirmed());
+        assertFalse(factory.getClasses().containsKey("a.A"), "Did not remove class key");
+        assertFalse(factory.getClasses().containsValue(node), "Did not remove class value");
+        assertFalse(node.isConfirmed(), "Class is still concrete");
     }
 
     /**
@@ -122,33 +120,34 @@ public void testAcceptPackageWithClasses() {
      *  +-- B
      *  </pre>
      */
-    public void testAcceptEmptyClass() {
-        ClassNode node1 = factory.createClass("a.A", true);
-        ClassNode node2 = factory.createClass("a.B", true);
-        
-        assertTrue("Missing package key", factory.getPackages().containsKey("a"));
-        assertTrue("Missing package value", factory.getPackages().containsValue(node1.getPackageNode()));
-        assertTrue("Package not concrete", node1.getPackageNode().isConfirmed());
-        assertTrue("Package node does not contain class node", node1.getPackageNode().getClasses().contains(node1));
-        assertTrue("Package node does not contain class node", node2.getPackageNode().getClasses().contains(node2));
-        assertSame("Classes have different package", node1.getPackageNode(), node2.getPackageNode());
-        
-        assertTrue("Missing class key", factory.getClasses().containsKey("a.A"));
-        assertTrue("Missing class value", factory.getClasses().containsValue(node1));
-        assertTrue("Class not concrete", node1.isConfirmed());
+    @Test
+    void testAcceptEmptyClass() {
+        var node1 = factory.createClass("a.A", true);
+        var node2 = factory.createClass("a.B", true);
+        
+        assertTrue(factory.getPackages().containsKey("a"), "Missing package key");
+        assertTrue(factory.getPackages().containsValue(node1.getPackageNode()), "Missing package value");
+        assertTrue(node1.getPackageNode().isConfirmed(), "Package not concrete");
+        assertTrue(node1.getPackageNode().getClasses().contains(node1), "Package node does not contain class node");
+        assertTrue(node2.getPackageNode().getClasses().contains(node2), "Package node does not contain class node");
+        assertSame(node1.getPackageNode(), node2.getPackageNode(), "Classes have different package");
+        
+        assertTrue(factory.getClasses().containsKey("a.A"), "Missing class key");
+        assertTrue(factory.getClasses().containsValue(node1), "Missing class value");
+        assertTrue(node1.isConfirmed(), "Class not concrete");
 
         node1.accept(visitor);
         
-        assertTrue("Missing package key", factory.getPackages().containsKey("a"));
-        assertTrue("Missing package value", factory.getPackages().containsValue(node1.getPackageNode()));
-        assertTrue("Package not concrete", node1.getPackageNode().isConfirmed());
-        assertFalse("Package node still contains class node", node1.getPackageNode().getClasses().contains(node1));
-        assertTrue("Package node does not contain class node", node2.getPackageNode().getClasses().contains(node2));
-        assertSame("Classes have different package", node1.getPackageNode(), node2.getPackageNode());
+        assertTrue(factory.getPackages().containsKey("a"), "Missing package key");
+        assertTrue(factory.getPackages().containsValue(node1.getPackageNode()), "Missing package value");
+        assertTrue(node1.getPackageNode().isConfirmed(), "Package not concrete");
+        assertFalse(node1.getPackageNode().getClasses().contains(node1), "Package node still contains class node");
+        assertTrue(node2.getPackageNode().getClasses().contains(node2), "Package node does not contain class node");
+        assertSame(node1.getPackageNode(), node2.getPackageNode(), "Classes have different package");
 
-        assertFalse("Did not remove class key", factory.getClasses().containsKey("a.A"));
-        assertFalse("Did not remove class value", factory.getClasses().containsValue(node1));
-        assertFalse("Class is still concrete", node1.isConfirmed());
+        assertFalse(factory.getClasses().containsKey("a.A"), "Did not remove class key");
+        assertFalse(factory.getClasses().containsValue(node1), "Did not remove class value");
+        assertFalse(node1.isConfirmed(), "Class is still concrete");
     }
 
     /**
@@ -161,28 +160,29 @@ public void testAcceptEmptyClass() {
      *
      *  <p>becomes:</p>
      */
-    public void testAcceptSingleEmptyClass() {
-        ClassNode node = factory.createClass("a.A", true);
+    @Test
+    void testAcceptSingleEmptyClass() {
+        var node = factory.createClass("a.A", true);
         
-        assertTrue("Missing package key", factory.getPackages().containsKey("a"));
-        assertTrue("Missing package value", factory.getPackages().containsValue(node.getPackageNode()));
-        assertTrue("Package not concrete", node.getPackageNode().isConfirmed());
-        assertTrue("Package node does not contain class node", node.getPackageNode().getClasses().contains(node));
+        assertTrue(factory.getPackages().containsKey("a"), "Missing package key");
+        assertTrue(factory.getPackages().containsValue(node.getPackageNode()), "Missing package value");
+        assertTrue(node.getPackageNode().isConfirmed(), "Package not concrete");
+        assertTrue(node.getPackageNode().getClasses().contains(node), "Package node does not contain class node");
         
-        assertTrue("Missing class key", factory.getClasses().containsKey("a.A"));
-        assertTrue("Missing class value", factory.getClasses().containsValue(node));
-        assertTrue("Class not concrete", node.isConfirmed());
+        assertTrue(factory.getClasses().containsKey("a.A"), "Missing class key");
+        assertTrue(factory.getClasses().containsValue(node), "Missing class value");
+        assertTrue(node.isConfirmed(), "Class not concrete");
 
         node.accept(visitor);
         
-        assertFalse("Did not remove package key", factory.getPackages().containsKey("a"));
-        assertFalse("Did not remove package value", factory.getPackages().containsValue(node.getPackageNode()));
-        assertFalse("Package is still concrete", node.getPackageNode().isConfirmed());
-        assertFalse("Package node still contains class node", node.getPackageNode().getClasses().contains(node));
+        assertFalse(factory.getPackages().containsKey("a"), "Did not remove package key");
+        assertFalse(factory.getPackages().containsValue(node.getPackageNode()), "Did not remove package value");
+        assertFalse(node.getPackageNode().isConfirmed(), "Package is still concrete");
+        assertFalse(node.getPackageNode().getClasses().contains(node), "Package node still contains class node");
 
-        assertFalse("Did not remove class key", factory.getClasses().containsKey("a.A"));
-        assertFalse("Did not remove class value", factory.getClasses().containsValue(node));
-        assertFalse("Class is still concrete", node.isConfirmed());
+        assertFalse(factory.getClasses().containsKey("a.A"), "Did not remove class key");
+        assertFalse(factory.getClasses().containsValue(node), "Did not remove class value");
+        assertFalse(node.isConfirmed(), "Class is still concrete");
     }
 
     /**
@@ -202,41 +202,42 @@ public void testAcceptSingleEmptyClass() {
      *  +-- B
      *  </pre>
      */
-    public void testAcceptClassWithFeature() {
-        FeatureNode node1 = factory.createFeature("a.A.a", true);
-        ClassNode   node2 = factory.createClass("a.B", true);
-        
-        assertTrue("Missing package key", factory.getPackages().containsKey("a"));
-        assertTrue("Missing package value", factory.getPackages().containsValue(node1.getClassNode().getPackageNode()));
-        assertTrue("Package not concrete", node1.getClassNode().getPackageNode().isConfirmed());
-        assertTrue("Package node does not contain class node", node1.getClassNode().getPackageNode().getClasses().contains(node1.getClassNode()));
-        assertTrue("Package node does not contain class node", node2.getPackageNode().getClasses().contains(node2));
-
-        assertTrue("Missing class key", factory.getClasses().containsKey("a.A"));
-        assertTrue("Missing class value", factory.getClasses().containsValue(node1.getClassNode()));
-        assertTrue("Class not concrete", node1.getClassNode().isConfirmed());
-        assertTrue("Class node does not contain feature node", node1.getClassNode().getFeatures().contains(node1));
-        
-        assertTrue("Missing feature key", factory.getFeatures().containsKey("a.A.a"));
-        assertTrue("Missing feature value", factory.getFeatures().containsValue(node1));
-        assertTrue("Feature not concrete", node1.isConfirmed());
+    @Test
+    void testAcceptClassWithFeature() {
+        var node1 = factory.createFeature("a.A.a", true);
+        var node2 = factory.createClass("a.B", true);
+        
+        assertTrue(factory.getPackages().containsKey("a"), "Missing package key");
+        assertTrue(factory.getPackages().containsValue(node1.getClassNode().getPackageNode()), "Missing package value");
+        assertTrue(node1.getClassNode().getPackageNode().isConfirmed(), "Package not concrete");
+        assertTrue(node1.getClassNode().getPackageNode().getClasses().contains(node1.getClassNode()), "Package node does not contain class node");
+        assertTrue(node2.getPackageNode().getClasses().contains(node2), "Package node does not contain class node");
+
+        assertTrue(factory.getClasses().containsKey("a.A"), "Missing class key");
+        assertTrue(factory.getClasses().containsValue(node1.getClassNode()), "Missing class value");
+        assertTrue(node1.getClassNode().isConfirmed(), "Class not concrete");
+        assertTrue(node1.getClassNode().getFeatures().contains(node1), "Class node does not contain feature node");
+        
+        assertTrue(factory.getFeatures().containsKey("a.A.a"), "Missing feature key");
+        assertTrue(factory.getFeatures().containsValue(node1), "Missing feature value");
+        assertTrue(node1.isConfirmed(), "Feature not concrete");
 
         node1.getClassNode().accept(visitor);
         
-        assertTrue("Missing package key", factory.getPackages().containsKey("a"));
-        assertTrue("Missing package value", factory.getPackages().containsValue(node1.getClassNode().getPackageNode()));
-        assertTrue("Package not concrete", node1.getClassNode().getPackageNode().isConfirmed());
-        assertFalse("Package node still contains class node", node1.getClassNode().getPackageNode().getClasses().contains(node1));
-        assertTrue("Package node does not contain class node", node2.getPackageNode().getClasses().contains(node2));
+        assertTrue(factory.getPackages().containsKey("a"), "Missing package key");
+        assertTrue(factory.getPackages().containsValue(node1.getClassNode().getPackageNode()), "Missing package value");
+        assertTrue(node1.getClassNode().getPackageNode().isConfirmed(), "Package not concrete");
+        assertFalse(node1.getClassNode().getPackageNode().getClasses().contains(node1), "Package node still contains class node");
+        assertTrue(node2.getPackageNode().getClasses().contains(node2), "Package node does not contain class node");
 
-        assertFalse("Did not remove class key", factory.getClasses().containsKey("a.A"));
-        assertFalse("Did not remove class value", factory.getClasses().containsValue(node1.getClassNode()));
-        assertFalse("Class is still concrete", node1.getClassNode().isConfirmed());
-        assertFalse("Class node still contains feature node", node1.getClassNode().getFeatures().contains(node1));
+        assertFalse(factory.getClasses().containsKey("a.A"), "Did not remove class key");
+        assertFalse(factory.getClasses().containsValue(node1.getClassNode()), "Did not remove class value");
+        assertFalse(node1.getClassNode().isConfirmed(), "Class is still concrete");
+        assertFalse(node1.getClassNode().getFeatures().contains(node1), "Class node still contains feature node");
 
-        assertFalse("Did not remove feature key", factory.getFeatures().containsKey("a.A.a"));
-        assertFalse("Did not remove feature value", factory.getFeatures().containsValue(node1));
-        assertFalse("Feature is still concrete", node1.isConfirmed());
+        assertFalse(factory.getFeatures().containsKey("a.A.a"), "Did not remove feature key");
+        assertFalse(factory.getFeatures().containsValue(node1), "Did not remove feature value");
+        assertFalse(node1.isConfirmed(), "Feature is still concrete");
     }
 
     /**
@@ -250,38 +251,39 @@ public void testAcceptClassWithFeature() {
      *
      *  <p>becomes:</p>
      */
-    public void testAcceptSingleClassWithFeature() {
-        FeatureNode node1 = factory.createFeature("a.A.a", true);
+    @Test
+    void testAcceptSingleClassWithFeature() {
+        var node1 = factory.createFeature("a.A.a", true);
         
-        assertTrue("Missing package key", factory.getPackages().containsKey("a"));
-        assertTrue("Missing package value", factory.getPackages().containsValue(node1.getClassNode().getPackageNode()));
-        assertTrue("Package not concrete", node1.getClassNode().getPackageNode().isConfirmed());
-        assertTrue("Package node does not contain class node", node1.getClassNode().getPackageNode().getClasses().contains(node1.getClassNode()));
+        assertTrue(factory.getPackages().containsKey("a"), "Missing package key");
+        assertTrue(factory.getPackages().containsValue(node1.getClassNode().getPackageNode()), "Missing package value");
+        assertTrue(node1.getClassNode().getPackageNode().isConfirmed(), "Package not concrete");
+        assertTrue(node1.getClassNode().getPackageNode().getClasses().contains(node1.getClassNode()), "Package node does not contain class node");
 
-        assertTrue("Missing class key", factory.getClasses().containsKey("a.A"));
-        assertTrue("Missing class value", factory.getClasses().containsValue(node1.getClassNode()));
-        assertTrue("Class not concrete", node1.getClassNode().isConfirmed());
-        assertTrue("Class node does not contain feature node", node1.getClassNode().getFeatures().contains(node1));
+        assertTrue(factory.getClasses().containsKey("a.A"), "Missing class key");
+        assertTrue(factory.getClasses().containsValue(node1.getClassNode()), "Missing class value");
+        assertTrue(node1.getClassNode().isConfirmed(), "Class not concrete");
+        assertTrue(node1.getClassNode().getFeatures().contains(node1), "Class node does not contain feature node");
         
-        assertTrue("Missing feature key", factory.getFeatures().containsKey("a.A.a"));
-        assertTrue("Missing feature value", factory.getFeatures().containsValue(node1));
-        assertTrue("Feature not concrete", node1.isConfirmed());
+        assertTrue(factory.getFeatures().containsKey("a.A.a"), "Missing feature key");
+        assertTrue(factory.getFeatures().containsValue(node1), "Missing feature value");
+        assertTrue(node1.isConfirmed(), "Feature not concrete");
 
         node1.getClassNode().accept(visitor);
         
-        assertFalse("Did not remove package key", factory.getPackages().containsKey("a"));
-        assertFalse("Did not remove package value", factory.getPackages().containsValue(node1.getClassNode().getPackageNode()));
-        assertFalse("Package is still concrete", node1.getClassNode().getPackageNode().isConfirmed());
-        assertFalse("Package node still contains class node", node1.getClassNode().getPackageNode().getClasses().contains(node1));
+        assertFalse(factory.getPackages().containsKey("a"), "Did not remove package key");
+        assertFalse(factory.getPackages().containsValue(node1.getClassNode().getPackageNode()), "Did not remove package value");
+        assertFalse(node1.getClassNode().getPackageNode().isConfirmed(), "Package is still concrete");
+        assertFalse(node1.getClassNode().getPackageNode().getClasses().contains(node1), "Package node still contains class node");
 
-        assertFalse("Did not remove class key", factory.getClasses().containsKey("a.A"));
-        assertFalse("Did not remove class value", factory.getClasses().containsValue(node1.getClassNode()));
-        assertFalse("Class is still concrete", node1.getClassNode().isConfirmed());
-        assertFalse("Class node still contains feature node", node1.getClassNode().getFeatures().contains(node1));
+        assertFalse(factory.getClasses().containsKey("a.A"), "Did not remove class key");
+        assertFalse(factory.getClasses().containsValue(node1.getClassNode()), "Did not remove class value");
+        assertFalse(node1.getClassNode().isConfirmed(), "Class is still concrete");
+        assertFalse(node1.getClassNode().getFeatures().contains(node1), "Class node still contains feature node");
 
-        assertFalse("Did not remove feature key", factory.getFeatures().containsKey("a.A.a"));
-        assertFalse("Did not remove feature value", factory.getFeatures().containsValue(node1));
-        assertFalse("Feature is still concrete", node1.isConfirmed());
+        assertFalse(factory.getFeatures().containsKey("a.A.a"), "Did not remove feature key");
+        assertFalse(factory.getFeatures().containsValue(node1), "Did not remove feature value");
+        assertFalse(node1.isConfirmed(), "Feature is still concrete");
     }
 
     /**
@@ -302,43 +304,44 @@ public void testAcceptSingleClassWithFeature() {
      *      +-- b
      *  </pre>
      */
-    public void testAcceptEmptyFeature() {
-        FeatureNode node1 = factory.createFeature("a.A.a", true);
-        FeatureNode node2 = factory.createFeature("a.A.b", true);
-        
-        assertTrue("Missing package key", factory.getPackages().containsKey("a"));
-        assertTrue("Missing package value", factory.getPackages().containsValue(node1.getClassNode().getPackageNode()));
-        assertTrue("Package not concrete", node1.getClassNode().getPackageNode().isConfirmed());
-        assertTrue("Package node does not contain class node", node1.getClassNode().getPackageNode().getClasses().contains(node1.getClassNode()));
-        
-        assertTrue("Missing class key", factory.getClasses().containsKey("a.A"));
-        assertTrue("Missing class value", factory.getClasses().containsValue(node1.getClassNode()));
-        assertTrue("Class not concrete", node1.getClassNode().isConfirmed());
-        assertTrue("Class node does not contain feature node", node1.getClassNode().getFeatures().contains(node1));
-        assertTrue("Class node does not contain feature node", node2.getClassNode().getFeatures().contains(node2));
-        assertSame("Features have different class", node1.getClassNode(), node2.getClassNode());
-        
-        assertTrue("Missing feature key", factory.getFeatures().containsKey("a.A.a"));
-        assertTrue("Missing feature value", factory.getFeatures().containsValue(node1));
-        assertTrue("Feature not concrete", node1.isConfirmed());
+    @Test
+    void testAcceptEmptyFeature() {
+        var node1 = factory.createFeature("a.A.a", true);
+        var node2 = factory.createFeature("a.A.b", true);
+        
+        assertTrue(factory.getPackages().containsKey("a"), "Missing package key");
+        assertTrue(factory.getPackages().containsValue(node1.getClassNode().getPackageNode()), "Missing package value");
+        assertTrue(node1.getClassNode().getPackageNode().isConfirmed(), "Package not concrete");
+        assertTrue(node1.getClassNode().getPackageNode().getClasses().contains(node1.getClassNode()), "Package node does not contain class node");
+        
+        assertTrue(factory.getClasses().containsKey("a.A"), "Missing class key");
+        assertTrue(factory.getClasses().containsValue(node1.getClassNode()), "Missing class value");
+        assertTrue(node1.getClassNode().isConfirmed(), "Class not concrete");
+        assertTrue(node1.getClassNode().getFeatures().contains(node1), "Class node does not contain feature node");
+        assertTrue(node2.getClassNode().getFeatures().contains(node2), "Class node does not contain feature node");
+        assertSame(node1.getClassNode(), node2.getClassNode(), "Features have different class");
+        
+        assertTrue(factory.getFeatures().containsKey("a.A.a"), "Missing feature key");
+        assertTrue(factory.getFeatures().containsValue(node1), "Missing feature value");
+        assertTrue(node1.isConfirmed(), "Feature not concrete");
 
         node1.accept(visitor);
         
-        assertTrue("Missing package key", factory.getPackages().containsKey("a"));
-        assertTrue("Missing package value", factory.getPackages().containsValue(node1.getClassNode().getPackageNode()));
-        assertTrue("Package not concrete", node1.getClassNode().getPackageNode().isConfirmed());
-        assertTrue("Package node does not contain class node", node1.getClassNode().getPackageNode().getClasses().contains(node1.getClassNode()));
-
-        assertTrue("Missing class key", factory.getClasses().containsKey("a.A"));
-        assertTrue("Missing class value", factory.getClasses().containsValue(node1.getClassNode()));
-        assertTrue("Class not concrete", node1.getClassNode().isConfirmed());
-        assertFalse("Class node still contains feature node", node1.getClassNode().getFeatures().contains(node1));
-        assertTrue("Class node does not contain feature node", node2.getClassNode().getFeatures().contains(node2));
-        assertSame("Features have different class", node1.getClassNode(), node2.getClassNode());
-
-        assertFalse("Did not remove feature key", factory.getFeatures().containsKey("a.A.a"));
-        assertFalse("Did not remove feature value", factory.getFeatures().containsValue(node1));
-        assertFalse("Feature is still concrete", node1.isConfirmed());
+        assertTrue(factory.getPackages().containsKey("a"), "Missing package key");
+        assertTrue(factory.getPackages().containsValue(node1.getClassNode().getPackageNode()), "Missing package value");
+        assertTrue(node1.getClassNode().getPackageNode().isConfirmed(), "Package not concrete");
+        assertTrue(node1.getClassNode().getPackageNode().getClasses().contains(node1.getClassNode()), "Package node does not contain class node");
+
+        assertTrue(factory.getClasses().containsKey("a.A"), "Missing class key");
+        assertTrue(factory.getClasses().containsValue(node1.getClassNode()), "Missing class value");
+        assertTrue(node1.getClassNode().isConfirmed(), "Class not concrete");
+        assertFalse(node1.getClassNode().getFeatures().contains(node1), "Class node still contains feature node");
+        assertTrue(node2.getClassNode().getFeatures().contains(node2), "Class node does not contain feature node");
+        assertSame(node1.getClassNode(), node2.getClassNode(), "Features have different class");
+
+        assertFalse(factory.getFeatures().containsKey("a.A.a"), "Did not remove feature key");
+        assertFalse(factory.getFeatures().containsValue(node1), "Did not remove feature value");
+        assertFalse(node1.isConfirmed(), "Feature is still concrete");
     }
 
     /**
@@ -357,38 +360,39 @@ public void testAcceptEmptyFeature() {
      *  +-- A
      *  </pre>
      */
-    public void testAcceptSingleEmptyFeature() {
-        FeatureNode node = factory.createFeature("a.A.a", true);
+    @Test
+    void testAcceptSingleEmptyFeature() {
+        var node = factory.createFeature("a.A.a", true);
         
-        assertTrue("Missing package key", factory.getPackages().containsKey("a"));
-        assertTrue("Missing package value", factory.getPackages().containsValue(node.getClassNode().getPackageNode()));
-        assertTrue("Package not concrete", node.getClassNode().getPackageNode().isConfirmed());
-        assertTrue("Package node does not contain class node", node.getClassNode().getPackageNode().getClasses().contains(node.getClassNode()));
+        assertTrue(factory.getPackages().containsKey("a"), "Missing package key");
+        assertTrue(factory.getPackages().containsValue(node.getClassNode().getPackageNode()), "Missing package value");
+        assertTrue(node.getClassNode().getPackageNode().isConfirmed(), "Package not concrete");
+        assertTrue(node.getClassNode().getPackageNode().getClasses().contains(node.getClassNode()), "Package node does not contain class node");
         
-        assertTrue("Missing class key", factory.getClasses().containsKey("a.A"));
-        assertTrue("Missing class value", factory.getClasses().containsValue(node.getClassNode()));
-        assertTrue("Class not concrete", node.getClassNode().isConfirmed());
-        assertTrue("Class node does not contain feature node", node.getClassNode().getFeatures().contains(node));
+        assertTrue(factory.getClasses().containsKey("a.A"), "Missing class key");
+        assertTrue(factory.getClasses().containsValue(node.getClassNode()), "Missing class value");
+        assertTrue(node.getClassNode().isConfirmed(), "Class not concrete");
+        assertTrue(node.getClassNode().getFeatures().contains(node), "Class node does not contain feature node");
         
-        assertTrue("Missing feature key", factory.getFeatures().containsKey("a.A.a"));
-        assertTrue("Missing feature value", factory.getFeatures().containsValue(node));
-        assertTrue("Feature not concrete", node.isConfirmed());
+        assertTrue(factory.getFeatures().containsKey("a.A.a"), "Missing feature key");
+        assertTrue(factory.getFeatures().containsValue(node), "Missing feature value");
+        assertTrue(node.isConfirmed(), "Feature not concrete");
 
         node.accept(visitor);
         
-        assertTrue("Removed package key", factory.getPackages().containsKey("a"));
-        assertTrue("Removed package value", factory.getPackages().containsValue(node.getClassNode().getPackageNode()));
-        assertTrue("Package is no longer concrete", node.getClassNode().getPackageNode().isConfirmed());
-        assertTrue("Package node no longer contains class node", node.getClassNode().getPackageNode().getClasses().contains(node.getClassNode()));
+        assertTrue(factory.getPackages().containsKey("a"), "Removed package key");
+        assertTrue(factory.getPackages().containsValue(node.getClassNode().getPackageNode()), "Removed package value");
+        assertTrue(node.getClassNode().getPackageNode().isConfirmed(), "Package is no longer concrete");
+        assertTrue(node.getClassNode().getPackageNode().getClasses().contains(node.getClassNode()), "Package node no longer contains class node");
 
-        assertTrue("Removed class key", factory.getClasses().containsKey("a.A"));
-        assertTrue("Removed class value", factory.getClasses().containsValue(node.getClassNode()));
-        assertTrue("Class is no longer concrete", node.getClassNode().isConfirmed());
-        assertFalse("Class node still contains feature node", node.getClassNode().getFeatures().contains(node));
+        assertTrue(factory.getClasses().containsKey("a.A"), "Removed class key");
+        assertTrue(factory.getClasses().containsValue(node.getClassNode()), "Removed class value");
+        assertTrue(node.getClassNode().isConfirmed(), "Class is no longer concrete");
+        assertFalse(node.getClassNode().getFeatures().contains(node), "Class node still contains feature node");
 
-        assertFalse("Did not remove feature key", factory.getFeatures().containsKey("a.A.a"));
-        assertFalse("Did not remove feature value", factory.getFeatures().containsValue(node));
-        assertFalse("Feature is still concrete", node.isConfirmed());
+        assertFalse(factory.getFeatures().containsKey("a.A.a"), "Did not remove feature key");
+        assertFalse(factory.getFeatures().containsValue(node), "Did not remove feature value");
+        assertFalse(node.isConfirmed(), "Feature is still concrete");
     }
 
     /**
@@ -407,33 +411,34 @@ public void testAcceptSingleEmptyFeature() {
      *  b
      *  </pre>
      */
-    public void testAcceptPackageWithDependencyOnConcretePackage() {
-        PackageNode a = factory.createPackage("a", true);
-        PackageNode b = factory.createPackage("b", true);
+    @Test
+    void testAcceptPackageWithDependencyOnConcretePackage() {
+        var a = factory.createPackage("a", true);
+        var b = factory.createPackage("b", true);
 
         a.addDependency(b);
 
-        assertTrue("Missing package key a", factory.getPackages().containsKey("a"));
-        assertTrue("Missing package value a", factory.getPackages().containsValue(a));
-        assertTrue("Package a not concrete", a.isConfirmed());
-        assertTrue("a --> b is missing", a.getOutboundDependencies().contains(b));
+        assertTrue(factory.getPackages().containsKey("a"), "Missing package key a");
+        assertTrue(factory.getPackages().containsValue(a), "Missing package value a");
+        assertTrue(a.isConfirmed(), "Package a not concrete");
+        assertTrue(a.getOutboundDependencies().contains(b), "a --> b is missing");
 
-        assertTrue("Missing package key b", factory.getPackages().containsKey("b"));
-        assertTrue("Missing package value b", factory.getPackages().containsValue(b));
-        assertTrue("Package b not concrete", b.isConfirmed());
-        assertTrue("b <-- a is missing", b.getInboundDependencies().contains(a));
+        assertTrue(factory.getPackages().containsKey("b"), "Missing package key b");
+        assertTrue(factory.getPackages().containsValue(b), "Missing package value b");
+        assertTrue(b.isConfirmed(), "Package b not concrete");
+        assertTrue(b.getInboundDependencies().contains(a), "b <-- a is missing");
 
         a.accept(visitor);
         
-        assertFalse("Did not remove package key a", factory.getPackages().containsKey("a"));
-        assertFalse("Did not remove package value a", factory.getPackages().containsValue(a));
-        assertFalse("Package a is still concrete", a.isConfirmed());
-        assertFalse("Did not remove a --> b", a.getOutboundDependencies().contains(b));
+        assertFalse(factory.getPackages().containsKey("a"), "Did not remove package key a");
+        assertFalse(factory.getPackages().containsValue(a), "Did not remove package value a");
+        assertFalse(a.isConfirmed(), "Package a is still concrete");
+        assertFalse(a.getOutboundDependencies().contains(b), "Did not remove a --> b");
         
-        assertTrue("Removed package key b", factory.getPackages().containsKey("b"));
-        assertTrue("Removed package value b", factory.getPackages().containsValue(b));
-        assertTrue("Package b is no longer concrete", b.isConfirmed());
-        assertFalse("Did not remove b <-- a", b.getInboundDependencies().contains(a));
+        assertTrue(factory.getPackages().containsKey("b"), "Removed package key b");
+        assertTrue(factory.getPackages().containsValue(b), "Removed package value b");
+        assertTrue(b.isConfirmed(), "Package b is no longer concrete");
+        assertFalse(b.getInboundDependencies().contains(a), "Did not remove b <-- a");
     }
 
     /**
@@ -448,33 +453,34 @@ public void testAcceptPackageWithDependencyOnConcretePackage() {
      *
      *  <p>becomes:</p>
      */
-    public void testAcceptPackageWithDependencyOnNonConcretePackage() {
-        PackageNode a = factory.createPackage("a", true);
-        PackageNode b = factory.createPackage("b", false);
+    @Test
+    void testAcceptPackageWithDependencyOnNonConcretePackage() {
+        var a = factory.createPackage("a", true);
+        var b = factory.createPackage("b", false);
 
         a.addDependency(b);
 
-        assertTrue("Missing package key a", factory.getPackages().containsKey("a"));
-        assertTrue("Missing package value a", factory.getPackages().containsValue(a));
-        assertTrue("Package a not concrete", a.isConfirmed());
-        assertTrue("a --> b is missing", a.getOutboundDependencies().contains(b));
+        assertTrue(factory.getPackages().containsKey("a"), "Missing package key a");
+        assertTrue(factory.getPackages().containsValue(a), "Missing package value a");
+        assertTrue(a.isConfirmed(), "Package a not concrete");
+        assertTrue(a.getOutboundDependencies().contains(b), "a --> b is missing");
 
-        assertTrue("Missing package key b", factory.getPackages().containsKey("b"));
-        assertTrue("Missing package value b", factory.getPackages().containsValue(b));
-        assertFalse("Package b is concrete", b.isConfirmed());
-        assertTrue("b <-- a is missing", b.getInboundDependencies().contains(a));
+        assertTrue(factory.getPackages().containsKey("b"), "Missing package key b");
+        assertTrue(factory.getPackages().containsValue(b), "Missing package value b");
+        assertFalse(b.isConfirmed(), "Package b is concrete");
+        assertTrue(b.getInboundDependencies().contains(a), "b <-- a is missing");
 
         a.accept(visitor);
         
-        assertFalse("Did not remove package key a", factory.getPackages().containsKey("a"));
-        assertFalse("Did not remove package value a", factory.getPackages().containsValue(a));
-        assertFalse("Package a is still concrete", a.isConfirmed());
-        assertFalse("Did not remove a --> b", a.getOutboundDependencies().contains(b));
+        assertFalse(factory.getPackages().containsKey("a"), "Did not remove package key a");
+        assertFalse(factory.getPackages().containsValue(a), "Did not remove package value a");
+        assertFalse(a.isConfirmed(), "Package a is still concrete");
+        assertFalse(a.getOutboundDependencies().contains(b), "Did not remove a --> b");
         
-        assertFalse("Did not remove package key b", factory.getPackages().containsKey("b"));
-        assertFalse("Did not remove package value b", factory.getPackages().containsValue(b));
-        assertFalse("Package b became concrete", b.isConfirmed());
-        assertFalse("Did not remove b <-- a", b.getInboundDependencies().contains(a));
+        assertFalse(factory.getPackages().containsKey("b"), "Did not remove package key b");
+        assertFalse(factory.getPackages().containsValue(b), "Did not remove package value b");
+        assertFalse(b.isConfirmed(), "Package b became concrete");
+        assertFalse(b.getInboundDependencies().contains(a), "Did not remove b <-- a");
     }
 
     /**
@@ -496,45 +502,46 @@ public void testAcceptPackageWithDependencyOnNonConcretePackage() {
      *  +-- B
      *  </pre>
      */
-    public void testAcceptClassWithDependencyOnConcreteClass() {
-        ClassNode a_A = factory.createClass("a.A", true);
-        ClassNode b_B = factory.createClass("b.B", true);
+    @Test
+    void testAcceptClassWithDependencyOnConcreteClass() {
+        var a_A = factory.createClass("a.A", true);
+        var b_B = factory.createClass("b.B", true);
 
         a_A.addDependency(b_B);
 
-        assertTrue("Missing package key a", factory.getPackages().containsKey("a"));
-        assertTrue("Missing package value a", factory.getPackages().containsValue(a_A.getPackageNode()));
-        assertTrue("Package a not concrete", a_A.getPackageNode().isConfirmed());
-        assertTrue("Missing class key a.A", factory.getClasses().containsKey("a.A"));
-        assertTrue("Missing class value a.A", factory.getClasses().containsValue(a_A));
-        assertTrue("Class a.A not concrete", a_A.isConfirmed());
-        assertTrue("a.A --> b.B is missing", a_A.getOutboundDependencies().contains(b_B));
-
-        assertTrue("Missing package key b", factory.getPackages().containsKey("b"));
-        assertTrue("Missing package value b", factory.getPackages().containsValue(b_B.getPackageNode()));
-        assertTrue("Package b not concrete", b_B.getPackageNode().isConfirmed());
-        assertTrue("Missing class key b.B", factory.getClasses().containsKey("b.B"));
-        assertTrue("Missing class value b.B", factory.getClasses().containsValue(b_B));
-        assertTrue("Class b.B not concrete", b_B.isConfirmed());
-        assertTrue("b.B <-- a.A is missing", b_B.getInboundDependencies().contains(a_A));
+        assertTrue(factory.getPackages().containsKey("a"), "Missing package key a");
+        assertTrue(factory.getPackages().containsValue(a_A.getPackageNode()), "Missing package value a");
+        assertTrue(a_A.getPackageNode().isConfirmed(), "Package a not concrete");
+        assertTrue(factory.getClasses().containsKey("a.A"), "Missing class key a.A");
+        assertTrue(factory.getClasses().containsValue(a_A), "Missing class value a.A");
+        assertTrue(a_A.isConfirmed(), "Class a.A not concrete");
+        assertTrue(a_A.getOutboundDependencies().contains(b_B), "a.A --> b.B is missing");
+
+        assertTrue(factory.getPackages().containsKey("b"), "Missing package key b");
+        assertTrue(factory.getPackages().containsValue(b_B.getPackageNode()), "Missing package value b");
+        assertTrue(b_B.getPackageNode().isConfirmed(), "Package b not concrete");
+        assertTrue(factory.getClasses().containsKey("b.B"), "Missing class key b.B");
+        assertTrue(factory.getClasses().containsValue(b_B), "Missing class value b.B");
+        assertTrue(b_B.isConfirmed(), "Class b.B not concrete");
+        assertTrue(b_B.getInboundDependencies().contains(a_A), "b.B <-- a.A is missing");
 
         a_A.accept(visitor);
         
-        assertFalse("Did not remove package key a", factory.getPackages().containsKey("a"));
-        assertFalse("Did not remove package value a", factory.getPackages().containsValue(a_A.getPackageNode()));
-        assertFalse("Package a is still concrete", a_A.getPackageNode().isConfirmed());
-        assertFalse("Did not remove class key a.A", factory.getClasses().containsKey("a.A"));
-        assertFalse("Did not remove class value a.A", factory.getClasses().containsValue(a_A));
-        assertFalse("Class a.A is still concrete", a_A.isConfirmed());
-        assertFalse("Did not remove a.A --> b.B", a_A.getOutboundDependencies().contains(b_B));
-        
-        assertTrue("Removed package key b", factory.getPackages().containsKey("b"));
-        assertTrue("Removed package value b", factory.getPackages().containsValue(b_B.getPackageNode()));
-        assertTrue("Package b is no longer concrete", b_B.isConfirmed());
-        assertTrue("Removed class key b.B", factory.getClasses().containsKey("b.B"));
-        assertTrue("Removed class value b.B", factory.getClasses().containsValue(b_B));
-        assertTrue("Class b.B is no longer concrete", b_B.isConfirmed());
-        assertFalse("Did not remove b.B <-- a.A", b_B.getInboundDependencies().contains(a_A));
+        assertFalse(factory.getPackages().containsKey("a"), "Did not remove package key a");
+        assertFalse(factory.getPackages().containsValue(a_A.getPackageNode()), "Did not remove package value a");
+        assertFalse(a_A.getPackageNode().isConfirmed(), "Package a is still concrete");
+        assertFalse(factory.getClasses().containsKey("a.A"), "Did not remove class key a.A");
+        assertFalse(factory.getClasses().containsValue(a_A), "Did not remove class value a.A");
+        assertFalse(a_A.isConfirmed(), "Class a.A is still concrete");
+        assertFalse(a_A.getOutboundDependencies().contains(b_B), "Did not remove a.A --> b.B");
+        
+        assertTrue(factory.getPackages().containsKey("b"), "Removed package key b");
+        assertTrue(factory.getPackages().containsValue(b_B.getPackageNode()), "Removed package value b");
+        assertTrue(b_B.isConfirmed(), "Package b is no longer concrete");
+        assertTrue(factory.getClasses().containsKey("b.B"), "Removed class key b.B");
+        assertTrue(factory.getClasses().containsValue(b_B), "Removed class value b.B");
+        assertTrue(b_B.isConfirmed(), "Class b.B is no longer concrete");
+        assertFalse(b_B.getInboundDependencies().contains(a_A), "Did not remove b.B <-- a.A");
     }
 
     /**
@@ -551,45 +558,46 @@ public void testAcceptClassWithDependencyOnConcreteClass() {
      *
      *  <p>becomes:</p>
      */
-    public void testAcceptClassWithDependencyOnReferencedClass() {
-        ClassNode a_A = factory.createClass("a.A", true);
-        ClassNode b_B = factory.createClass("b.B", false);
+    @Test
+    void testAcceptClassWithDependencyOnReferencedClass() {
+        var a_A = factory.createClass("a.A", true);
+        var b_B = factory.createClass("b.B", false);
 
         a_A.addDependency(b_B);
 
-        assertTrue("Missing package key a", factory.getPackages().containsKey("a"));
-        assertTrue("Missing package value a", factory.getPackages().containsValue(a_A.getPackageNode()));
-        assertTrue("Package a not concrete", a_A.getPackageNode().isConfirmed());
-        assertTrue("Missing class key a.A", factory.getClasses().containsKey("a.A"));
-        assertTrue("Missing class value a.A", factory.getClasses().containsValue(a_A));
-        assertTrue("Class a.A not concrete", a_A.isConfirmed());
-        assertTrue("a.A --> b.B is missing", a_A.getOutboundDependencies().contains(b_B));
-
-        assertTrue("Missing package key b", factory.getPackages().containsKey("b"));
-        assertTrue("Missing package value b", factory.getPackages().containsValue(b_B.getPackageNode()));
-        assertFalse("Package b is concrete", b_B.getPackageNode().isConfirmed());
-        assertTrue("Missing class key b.B", factory.getClasses().containsKey("b.B"));
-        assertTrue("Missing class value b.B", factory.getClasses().containsValue(b_B));
-        assertFalse("Class b.B is concrete", b_B.isConfirmed());
-        assertTrue("b.B <-- a.A is missing", b_B.getInboundDependencies().contains(a_A));
+        assertTrue(factory.getPackages().containsKey("a"), "Missing package key a");
+        assertTrue(factory.getPackages().containsValue(a_A.getPackageNode()), "Missing package value a");
+        assertTrue(a_A.getPackageNode().isConfirmed(), "Package a not concrete");
+        assertTrue(factory.getClasses().containsKey("a.A"), "Missing class key a.A");
+        assertTrue(factory.getClasses().containsValue(a_A), "Missing class value a.A");
+        assertTrue(a_A.isConfirmed(), "Class a.A not concrete");
+        assertTrue(a_A.getOutboundDependencies().contains(b_B), "a.A --> b.B is missing");
+
+        assertTrue(factory.getPackages().containsKey("b"), "Missing package key b");
+        assertTrue(factory.getPackages().containsValue(b_B.getPackageNode()), "Missing package value b");
+        assertFalse(b_B.getPackageNode().isConfirmed(), "Package b is concrete");
+        assertTrue(factory.getClasses().containsKey("b.B"), "Missing class key b.B");
+        assertTrue(factory.getClasses().containsValue(b_B), "Missing class value b.B");
+        assertFalse(b_B.isConfirmed(), "Class b.B is concrete");
+        assertTrue(b_B.getInboundDependencies().contains(a_A), "b.B <-- a.A is missing");
 
         a_A.accept(visitor);
         
-        assertFalse("Did not remove package key a", factory.getPackages().containsKey("a"));
-        assertFalse("Did not remove package value a", factory.getPackages().containsValue(a_A.getPackageNode()));
-        assertFalse("Package a is still concrete", a_A.getPackageNode().isConfirmed());
-        assertFalse("Did not remove class key a.A", factory.getClasses().containsKey("a.A"));
-        assertFalse("Did not remove class value a.A", factory.getClasses().containsValue(a_A));
-        assertFalse("Class a.A is still concrete", a_A.isConfirmed());
-        assertFalse("Did not remove a.A --> b.B", a_A.getOutboundDependencies().contains(b_B));
-        
-        assertFalse("Did not remove package key b", factory.getPackages().containsKey("b"));
-        assertFalse("Did not remove package value b", factory.getPackages().containsValue(b_B.getPackageNode()));
-        assertFalse("Package b is now concrete", b_B.getPackageNode().isConfirmed());
-        assertFalse("Did not remove class key b.B", factory.getClasses().containsKey("b.B"));
-        assertFalse("Did not remove class value b.B", factory.getClasses().containsValue(b_B));
-        assertFalse("Class b.B is now concrete", b_B.isConfirmed());
-        assertFalse("Did not remove b.B <-- a.A", b_B.getInboundDependencies().contains(a_A));
+        assertFalse(factory.getPackages().containsKey("a"), "Did not remove package key a");
+        assertFalse(factory.getPackages().containsValue(a_A.getPackageNode()), "Did not remove package value a");
+        assertFalse(a_A.getPackageNode().isConfirmed(), "Package a is still concrete");
+        assertFalse(factory.getClasses().containsKey("a.A"), "Did not remove class key a.A");
+        assertFalse(factory.getClasses().containsValue(a_A), "Did not remove class value a.A");
+        assertFalse(a_A.isConfirmed(), "Class a.A is still concrete");
+        assertFalse(a_A.getOutboundDependencies().contains(b_B), "Did not remove a.A --> b.B");
+        
+        assertFalse(factory.getPackages().containsKey("b"), "Did not remove package key b");
+        assertFalse(factory.getPackages().containsValue(b_B.getPackageNode()), "Did not remove package value b");
+        assertFalse(b_B.getPackageNode().isConfirmed(), "Package b is now concrete");
+        assertFalse(factory.getClasses().containsKey("b.B"), "Did not remove class key b.B");
+        assertFalse(factory.getClasses().containsValue(b_B), "Did not remove class value b.B");
+        assertFalse(b_B.isConfirmed(), "Class b.B is now concrete");
+        assertFalse(b_B.getInboundDependencies().contains(a_A), "Did not remove b.B <-- a.A");
     }
 
     /**
@@ -614,57 +622,58 @@ public void testAcceptClassWithDependencyOnReferencedClass() {
      *      +-- b
      *  </pre>
      */
-    public void testAcceptClassWithFeatureWithDependencyOnConcreteFeature() {
-        FeatureNode a_A_a = factory.createFeature("a.A.a", true);
-        FeatureNode b_B_b = factory.createFeature("b.B.b", true);
+    @Test
+    void testAcceptClassWithFeatureWithDependencyOnConcreteFeature() {
+        var a_A_a = factory.createFeature("a.A.a", true);
+        var b_B_b = factory.createFeature("b.B.b", true);
 
         a_A_a.addDependency(b_B_b);
 
-        assertTrue("Missing package key a", factory.getPackages().containsKey("a"));
-        assertTrue("Missing package value a", factory.getPackages().containsValue(a_A_a.getClassNode().getPackageNode()));
-        assertTrue("Package a not concrete", a_A_a.getClassNode().getPackageNode().isConfirmed());
-        assertTrue("Missing class key a.A", factory.getClasses().containsKey("a.A"));
-        assertTrue("Missing class value a.A", factory.getClasses().containsValue(a_A_a.getClassNode()));
-        assertTrue("Class a.A not concrete", a_A_a.getClassNode().isConfirmed());
-        assertTrue("Missing feature key a.A.a", factory.getFeatures().containsKey("a.A.a"));
-        assertTrue("Missing feature value a.A.a", factory.getFeatures().containsValue(a_A_a));
-        assertTrue("Feature a.A.a not concrete", a_A_a.isConfirmed());
-        assertTrue("a.A.a --> b.B.b is missing", a_A_a.getOutboundDependencies().contains(b_B_b));
-
-        assertTrue("Missing package key b", factory.getPackages().containsKey("b"));
-        assertTrue("Missing package value b", factory.getPackages().containsValue(b_B_b.getClassNode().getPackageNode()));
-        assertTrue("Package b not concrete", b_B_b.getClassNode().getPackageNode().isConfirmed());
-        assertTrue("Missing class key b.B", factory.getClasses().containsKey("b.B"));
-        assertTrue("Missing class value b.B", factory.getClasses().containsValue(b_B_b.getClassNode()));
-        assertTrue("Class b.B not concrete", b_B_b.getClassNode().isConfirmed());
-        assertTrue("Missing feature key b.B.b", factory.getFeatures().containsKey("b.B.b"));
-        assertTrue("Missing feature value b.B.b", factory.getFeatures().containsValue(b_B_b));
-        assertTrue("Feature b.B.b not concrete", b_B_b.isConfirmed());
-        assertTrue("b.B <-- a.A is missing", b_B_b.getInboundDependencies().contains(a_A_a));
+        assertTrue(factory.getPackages().containsKey("a"), "Missing package key a");
+        assertTrue(factory.getPackages().containsValue(a_A_a.getClassNode().getPackageNode()), "Missing package value a");
+        assertTrue(a_A_a.getClassNode().getPackageNode().isConfirmed(), "Package a not concrete");
+        assertTrue(factory.getClasses().containsKey("a.A"), "Missing class key a.A");
+        assertTrue(factory.getClasses().containsValue(a_A_a.getClassNode()), "Missing class value a.A");
+        assertTrue(a_A_a.getClassNode().isConfirmed(), "Class a.A not concrete");
+        assertTrue(factory.getFeatures().containsKey("a.A.a"), "Missing feature key a.A.a");
+        assertTrue(factory.getFeatures().containsValue(a_A_a), "Missing feature value a.A.a");
+        assertTrue(a_A_a.isConfirmed(), "Feature a.A.a not concrete");
+        assertTrue(a_A_a.getOutboundDependencies().contains(b_B_b), "a.A.a --> b.B.b is missing");
+
+        assertTrue(factory.getPackages().containsKey("b"), "Missing package key b");
+        assertTrue(factory.getPackages().containsValue(b_B_b.getClassNode().getPackageNode()), "Missing package value b");
+        assertTrue(b_B_b.getClassNode().getPackageNode().isConfirmed(), "Package b not concrete");
+        assertTrue(factory.getClasses().containsKey("b.B"), "Missing class key b.B");
+        assertTrue(factory.getClasses().containsValue(b_B_b.getClassNode()), "Missing class value b.B");
+        assertTrue(b_B_b.getClassNode().isConfirmed(), "Class b.B not concrete");
+        assertTrue(factory.getFeatures().containsKey("b.B.b"), "Missing feature key b.B.b");
+        assertTrue(factory.getFeatures().containsValue(b_B_b), "Missing feature value b.B.b");
+        assertTrue(b_B_b.isConfirmed(), "Feature b.B.b not concrete");
+        assertTrue(b_B_b.getInboundDependencies().contains(a_A_a), "b.B <-- a.A is missing");
 
         a_A_a.getClassNode().accept(visitor);
         
-        assertFalse("Did not remove package key a", factory.getPackages().containsKey("a"));
-        assertFalse("Did not remove package value a", factory.getPackages().containsValue(a_A_a.getClassNode().getPackageNode()));
-        assertFalse("Package a is still concrete", a_A_a.getClassNode().getPackageNode().isConfirmed());
-        assertFalse("Did not remove class key a.A", factory.getClasses().containsKey("a.A"));
-        assertFalse("Did not remove class value a.A", factory.getClasses().containsValue(a_A_a.getClassNode()));
-        assertFalse("Class a.A is still concrete", a_A_a.getClassNode().isConfirmed());
-        assertFalse("Did not remove feature key a.A.a", factory.getFeatures().containsKey("a.A.a"));
-        assertFalse("Did not remove feature value a.A.a", factory.getFeatures().containsValue(a_A_a));
-        assertFalse("Feature a.A.a is still concrete", a_A_a.isConfirmed());
-        assertFalse("Did not remove a.A --> b.B", a_A_a.getOutboundDependencies().contains(b_B_b));
-        
-        assertTrue("Removed package key b", factory.getPackages().containsKey("b"));
-        assertTrue("Removed package value b", factory.getPackages().containsValue(b_B_b.getClassNode().getPackageNode()));
-        assertTrue("Package b is no longer concrete", b_B_b.getClassNode().getPackageNode().isConfirmed());
-        assertTrue("Removed class key b.B", factory.getClasses().containsKey("b.B"));
-        assertTrue("Removed class value b.B", factory.getClasses().containsValue(b_B_b.getClassNode()));
-        assertTrue("Class b.B is no longer concrete", b_B_b.getClassNode().isConfirmed());
-        assertTrue("Removed feature key b.B.b", factory.getFeatures().containsKey("b.B.b"));
-        assertTrue("Removed feature value b.B.b", factory.getFeatures().containsValue(b_B_b));
-        assertTrue("Feature b.B.b is no longer concrete", b_B_b.isConfirmed());
-        assertFalse("Did not remove b.B <-- a.A", b_B_b.getInboundDependencies().contains(a_A_a));
+        assertFalse(factory.getPackages().containsKey("a"), "Did not remove package key a");
+        assertFalse(factory.getPackages().containsValue(a_A_a.getClassNode().getPackageNode()), "Did not remove package value a");
+        assertFalse(a_A_a.getClassNode().getPackageNode().isConfirmed(), "Package a is still concrete");
+        assertFalse(factory.getClasses().containsKey("a.A"), "Did not remove class key a.A");
+        assertFalse(factory.getClasses().containsValue(a_A_a.getClassNode()), "Did not remove class value a.A");
+        assertFalse(a_A_a.getClassNode().isConfirmed(), "Class a.A is still concrete");
+        assertFalse(factory.getFeatures().containsKey("a.A.a"), "Did not remove feature key a.A.a");
+        assertFalse(factory.getFeatures().containsValue(a_A_a), "Did not remove feature value a.A.a");
+        assertFalse(a_A_a.isConfirmed(), "Feature a.A.a is still concrete");
+        assertFalse(a_A_a.getOutboundDependencies().contains(b_B_b), "Did not remove a.A --> b.B");
+        
+        assertTrue(factory.getPackages().containsKey("b"), "Removed package key b");
+        assertTrue(factory.getPackages().containsValue(b_B_b.getClassNode().getPackageNode()), "Removed package value b");
+        assertTrue(b_B_b.getClassNode().getPackageNode().isConfirmed(), "Package b is no longer concrete");
+        assertTrue(factory.getClasses().containsKey("b.B"), "Removed class key b.B");
+        assertTrue(factory.getClasses().containsValue(b_B_b.getClassNode()), "Removed class value b.B");
+        assertTrue(b_B_b.getClassNode().isConfirmed(), "Class b.B is no longer concrete");
+        assertTrue(factory.getFeatures().containsKey("b.B.b"), "Removed feature key b.B.b");
+        assertTrue(factory.getFeatures().containsValue(b_B_b), "Removed feature value b.B.b");
+        assertTrue(b_B_b.isConfirmed(), "Feature b.B.b is no longer concrete");
+        assertFalse(b_B_b.getInboundDependencies().contains(a_A_a), "Did not remove b.B <-- a.A");
     }
 
     /**
@@ -692,57 +701,58 @@ public void testAcceptClassWithFeatureWithDependencyOnConcreteFeature() {
      *      +-- b
      *  </pre>
      */
-    public void testAcceptFeatureWithDependencyOnConcreteFeature() {
-        FeatureNode a_A_a = factory.createFeature("a.A.a", true);
-        FeatureNode b_B_b = factory.createFeature("b.B.b", true);
+    @Test
+    void testAcceptFeatureWithDependencyOnConcreteFeature() {
+        var a_A_a = factory.createFeature("a.A.a", true);
+        var b_B_b = factory.createFeature("b.B.b", true);
 
         a_A_a.addDependency(b_B_b);
 
-        assertTrue("Missing package key a", factory.getPackages().containsKey("a"));
-        assertTrue("Missing package value a", factory.getPackages().containsValue(a_A_a.getClassNode().getPackageNode()));
-        assertTrue("Package a not concrete", a_A_a.getClassNode().getPackageNode().isConfirmed());
-        assertTrue("Missing class key a.A", factory.getClasses().containsKey("a.A"));
-        assertTrue("Missing class value a.A", factory.getClasses().containsValue(a_A_a.getClassNode()));
-        assertTrue("Class a.A not concrete", a_A_a.getClassNode().isConfirmed());
-        assertTrue("Missing feature key a.A.a", factory.getFeatures().containsKey("a.A.a"));
-        assertTrue("Missing feature value a.A.a", factory.getFeatures().containsValue(a_A_a));
-        assertTrue("Feature a.A.a not concrete", a_A_a.isConfirmed());
-        assertTrue("a.A.a --> b.B.b is missing", a_A_a.getOutboundDependencies().contains(b_B_b));
-
-        assertTrue("Missing package key b", factory.getPackages().containsKey("b"));
-        assertTrue("Missing package value b", factory.getPackages().containsValue(b_B_b.getClassNode().getPackageNode()));
-        assertTrue("Package b not concrete", b_B_b.getClassNode().getPackageNode().isConfirmed());
-        assertTrue("Missing class key b.B", factory.getClasses().containsKey("b.B"));
-        assertTrue("Missing class value b.B", factory.getClasses().containsValue(b_B_b.getClassNode()));
-        assertTrue("Class b.B not concrete", b_B_b.getClassNode().isConfirmed());
-        assertTrue("Missing feature key b.B.b", factory.getFeatures().containsKey("b.B.b"));
-        assertTrue("Missing feature value b.B.b", factory.getFeatures().containsValue(b_B_b));
-        assertTrue("Feature b.B.b not concrete", b_B_b.isConfirmed());
-        assertTrue("b.B <-- a.A is missing", b_B_b.getInboundDependencies().contains(a_A_a));
+        assertTrue(factory.getPackages().containsKey("a"), "Missing package key a");
+        assertTrue(factory.getPackages().containsValue(a_A_a.getClassNode().getPackageNode()), "Missing package value a");
+        assertTrue(a_A_a.getClassNode().getPackageNode().isConfirmed(), "Package a not concrete");
+        assertTrue(factory.getClasses().containsKey("a.A"), "Missing class key a.A");
+        assertTrue(factory.getClasses().containsValue(a_A_a.getClassNode()), "Missing class value a.A");
+        assertTrue(a_A_a.getClassNode().isConfirmed(), "Class a.A not concrete");
+        assertTrue(factory.getFeatures().containsKey("a.A.a"), "Missing feature key a.A.a");
+        assertTrue(factory.getFeatures().containsValue(a_A_a), "Missing feature value a.A.a");
+        assertTrue(a_A_a.isConfirmed(), "Feature a.A.a not concrete");
+        assertTrue(a_A_a.getOutboundDependencies().contains(b_B_b), "a.A.a --> b.B.b is missing");
+
+        assertTrue(factory.getPackages().containsKey("b"), "Missing package key b");
+        assertTrue(factory.getPackages().containsValue(b_B_b.getClassNode().getPackageNode()), "Missing package value b");
+        assertTrue(b_B_b.getClassNode().getPackageNode().isConfirmed(), "Package b not concrete");
+        assertTrue(factory.getClasses().containsKey("b.B"), "Missing class key b.B");
+        assertTrue(factory.getClasses().containsValue(b_B_b.getClassNode()), "Missing class value b.B");
+        assertTrue(b_B_b.getClassNode().isConfirmed(), "Class b.B not concrete");
+        assertTrue(factory.getFeatures().containsKey("b.B.b"), "Missing feature key b.B.b");
+        assertTrue(factory.getFeatures().containsValue(b_B_b), "Missing feature value b.B.b");
+        assertTrue(b_B_b.isConfirmed(), "Feature b.B.b not concrete");
+        assertTrue(b_B_b.getInboundDependencies().contains(a_A_a), "b.B <-- a.A is missing");
 
         a_A_a.accept(visitor);
         
-        assertTrue("Removed package key a", factory.getPackages().containsKey("a"));
-        assertTrue("Removed package value a", factory.getPackages().containsValue(a_A_a.getClassNode().getPackageNode()));
-        assertTrue("Package a is no longer concrete", a_A_a.getClassNode().getPackageNode().isConfirmed());
-        assertTrue("Removed class key a.A", factory.getClasses().containsKey("a.A"));
-        assertTrue("Removed class value a.A", factory.getClasses().containsValue(a_A_a.getClassNode()));
-        assertTrue("Class a.A is no longer concrete", a_A_a.getClassNode().isConfirmed());
-        assertFalse("Did not remove feature key a.A.a", factory.getFeatures().containsKey("a.A.a"));
-        assertFalse("Did not remove feature value a.A.a", factory.getFeatures().containsValue(a_A_a));
-        assertFalse("Feature a.A.a is still concrete", a_A_a.isConfirmed());
-        assertFalse("Did not remove a.A --> b.B", a_A_a.getOutboundDependencies().contains(b_B_b));
-        
-        assertTrue("Removed package key b", factory.getPackages().containsKey("b"));
-        assertTrue("Removed package value b", factory.getPackages().containsValue(b_B_b.getClassNode().getPackageNode()));
-        assertTrue("Package b is no longer concrete", b_B_b.getClassNode().getPackageNode().isConfirmed());
-        assertTrue("Removed class key b.B", factory.getClasses().containsKey("b.B"));
-        assertTrue("Removed class value b.B", factory.getClasses().containsValue(b_B_b.getClassNode()));
-        assertTrue("Class b.B is no longer concrete", b_B_b.getClassNode().isConfirmed());
-        assertTrue("Removed feature key b.B.b", factory.getFeatures().containsKey("b.B.b"));
-        assertTrue("Removed feature value b.B.b", factory.getFeatures().containsValue(b_B_b));
-        assertTrue("Feature b.B.b is no longer concrete", b_B_b.isConfirmed());
-        assertFalse("Did not remove b.B <-- a.A", b_B_b.getInboundDependencies().contains(a_A_a));
+        assertTrue(factory.getPackages().containsKey("a"), "Removed package key a");
+        assertTrue(factory.getPackages().containsValue(a_A_a.getClassNode().getPackageNode()), "Removed package value a");
+        assertTrue(a_A_a.getClassNode().getPackageNode().isConfirmed(), "Package a is no longer concrete");
+        assertTrue(factory.getClasses().containsKey("a.A"), "Removed class key a.A");
+        assertTrue(factory.getClasses().containsValue(a_A_a.getClassNode()), "Removed class value a.A");
+        assertTrue(a_A_a.getClassNode().isConfirmed(), "Class a.A is no longer concrete");
+        assertFalse(factory.getFeatures().containsKey("a.A.a"), "Did not remove feature key a.A.a");
+        assertFalse(factory.getFeatures().containsValue(a_A_a), "Did not remove feature value a.A.a");
+        assertFalse(a_A_a.isConfirmed(), "Feature a.A.a is still concrete");
+        assertFalse(a_A_a.getOutboundDependencies().contains(b_B_b), "Did not remove a.A --> b.B");
+        
+        assertTrue(factory.getPackages().containsKey("b"), "Removed package key b");
+        assertTrue(factory.getPackages().containsValue(b_B_b.getClassNode().getPackageNode()), "Removed package value b");
+        assertTrue(b_B_b.getClassNode().getPackageNode().isConfirmed(), "Package b is no longer concrete");
+        assertTrue(factory.getClasses().containsKey("b.B"), "Removed class key b.B");
+        assertTrue(factory.getClasses().containsValue(b_B_b.getClassNode()), "Removed class value b.B");
+        assertTrue(b_B_b.getClassNode().isConfirmed(), "Class b.B is no longer concrete");
+        assertTrue(factory.getFeatures().containsKey("b.B.b"), "Removed feature key b.B.b");
+        assertTrue(factory.getFeatures().containsValue(b_B_b), "Removed feature value b.B.b");
+        assertTrue(b_B_b.isConfirmed(), "Feature b.B.b is no longer concrete");
+        assertFalse(b_B_b.getInboundDependencies().contains(a_A_a), "Did not remove b.B <-- a.A");
     }
 
     /**
@@ -761,57 +771,58 @@ public void testAcceptFeatureWithDependencyOnConcreteFeature() {
      *
      *  <p>becomes:</p>
      */
-    public void testAcceptClassWithFeatureWithDependencyOnReferencedFeature() {
-        FeatureNode a_A_a = factory.createFeature("a.A.a", true);
-        FeatureNode b_B_b = factory.createFeature("b.B.b", false);
+    @Test
+    void testAcceptClassWithFeatureWithDependencyOnReferencedFeature() {
+        var a_A_a = factory.createFeature("a.A.a", true);
+        var b_B_b = factory.createFeature("b.B.b", false);
 
         a_A_a.addDependency(b_B_b);
 
-        assertTrue("Missing package key a", factory.getPackages().containsKey("a"));
-        assertTrue("Missing package value a", factory.getPackages().containsValue(a_A_a.getClassNode().getPackageNode()));
-        assertTrue("Package a not concrete", a_A_a.getClassNode().getPackageNode().isConfirmed());
-        assertTrue("Missing class key a.A", factory.getClasses().containsKey("a.A"));
-        assertTrue("Missing class value a.A", factory.getClasses().containsValue(a_A_a.getClassNode()));
-        assertTrue("Class a.A not concrete", a_A_a.getClassNode().isConfirmed());
-        assertTrue("Missing feature key a.A.a", factory.getFeatures().containsKey("a.A.a"));
-        assertTrue("Missing feature value a.A.a", factory.getFeatures().containsValue(a_A_a));
-        assertTrue("Feature a.A.a not concrete", a_A_a.isConfirmed());
-        assertTrue("a.A.a --> b.B.b is missing", a_A_a.getOutboundDependencies().contains(b_B_b));
-
-        assertTrue("Missing package key b", factory.getPackages().containsKey("b"));
-        assertTrue("Missing package value b", factory.getPackages().containsValue(b_B_b.getClassNode().getPackageNode()));
-        assertFalse("Package b is concrete", b_B_b.getClassNode().getPackageNode().isConfirmed());
-        assertTrue("Missing class key b.B", factory.getClasses().containsKey("b.B"));
-        assertTrue("Missing class value b.B", factory.getClasses().containsValue(b_B_b.getClassNode()));
-        assertFalse("Class b.B is concrete", b_B_b.getClassNode().isConfirmed());
-        assertTrue("Missing feature key b.B.b", factory.getFeatures().containsKey("b.B.b"));
-        assertTrue("Missing feature value b.B.b", factory.getFeatures().containsValue(b_B_b));
-        assertFalse("Feature b.B.b is concrete", b_B_b.isConfirmed());
-        assertTrue("b.B <-- a.A is missing", b_B_b.getInboundDependencies().contains(a_A_a));
+        assertTrue(factory.getPackages().containsKey("a"), "Missing package key a");
+        assertTrue(factory.getPackages().containsValue(a_A_a.getClassNode().getPackageNode()), "Missing package value a");
+        assertTrue(a_A_a.getClassNode().getPackageNode().isConfirmed(), "Package a not concrete");
+        assertTrue(factory.getClasses().containsKey("a.A"), "Missing class key a.A");
+        assertTrue(factory.getClasses().containsValue(a_A_a.getClassNode()), "Missing class value a.A");
+        assertTrue(a_A_a.getClassNode().isConfirmed(), "Class a.A not concrete");
+        assertTrue(factory.getFeatures().containsKey("a.A.a"), "Missing feature key a.A.a");
+        assertTrue(factory.getFeatures().containsValue(a_A_a), "Missing feature value a.A.a");
+        assertTrue(a_A_a.isConfirmed(), "Feature a.A.a not concrete");
+        assertTrue(a_A_a.getOutboundDependencies().contains(b_B_b), "a.A.a --> b.B.b is missing");
+
+        assertTrue(factory.getPackages().containsKey("b"), "Missing package key b");
+        assertTrue(factory.getPackages().containsValue(b_B_b.getClassNode().getPackageNode()), "Missing package value b");
+        assertFalse(b_B_b.getClassNode().getPackageNode().isConfirmed(), "Package b is concrete");
+        assertTrue(factory.getClasses().containsKey("b.B"), "Missing class key b.B");
+        assertTrue(factory.getClasses().containsValue(b_B_b.getClassNode()), "Missing class value b.B");
+        assertFalse(b_B_b.getClassNode().isConfirmed(), "Class b.B is concrete");
+        assertTrue(factory.getFeatures().containsKey("b.B.b"), "Missing feature key b.B.b");
+        assertTrue(factory.getFeatures().containsValue(b_B_b), "Missing feature value b.B.b");
+        assertFalse(b_B_b.isConfirmed(), "Feature b.B.b is concrete");
+        assertTrue(b_B_b.getInboundDependencies().contains(a_A_a), "b.B <-- a.A is missing");
 
         a_A_a.getClassNode().accept(visitor);
         
-        assertFalse("Did not remove package key a", factory.getPackages().containsKey("a"));
-        assertFalse("Did not remove package value a", factory.getPackages().containsValue(a_A_a.getClassNode().getPackageNode()));
-        assertFalse("Package a is still concrete", a_A_a.getClassNode().getPackageNode().isConfirmed());
-        assertFalse("Did not remove class key a.A", factory.getClasses().containsKey("a.A"));
-        assertFalse("Did not remove class value a.A", factory.getClasses().containsValue(a_A_a.getClassNode()));
-        assertFalse("Class a.A is still concrete", a_A_a.getClassNode().isConfirmed());
-        assertFalse("Did not remove feature key a.A.a", factory.getFeatures().containsKey("a.A.a"));
-        assertFalse("Did not remove feature value a.A.a", factory.getFeatures().containsValue(a_A_a));
-        assertFalse("Feature a.A.a is still concrete", a_A_a.isConfirmed());
-        assertFalse("Did not remove a.A --> b.B", a_A_a.getOutboundDependencies().contains(b_B_b));
-        
-        assertFalse("Did not remove package key b", factory.getPackages().containsKey("b"));
-        assertFalse("Did not remove package value b", factory.getPackages().containsValue(b_B_b.getClassNode().getPackageNode()));
-        assertFalse("Package b is now concrete", b_B_b.getClassNode().getPackageNode().isConfirmed());
-        assertFalse("Did not remove class key b.B", factory.getClasses().containsKey("b.B"));
-        assertFalse("Did not remove class value b.B", factory.getClasses().containsValue(b_B_b.getClassNode()));
-        assertFalse("Class b.B is now concrete", b_B_b.getClassNode().isConfirmed());
-        assertFalse("Did not remove feature key b.B.b", factory.getFeatures().containsKey("b.B.b"));
-        assertFalse("Did not remove feature value b.B.b", factory.getFeatures().containsValue(b_B_b));
-        assertFalse("Feature b.B.b is now concrete", b_B_b.isConfirmed());
-        assertFalse("Did not remove b.B <-- a.A", b_B_b.getInboundDependencies().contains(a_A_a));
+        assertFalse(factory.getPackages().containsKey("a"), "Did not remove package key a");
+        assertFalse(factory.getPackages().containsValue(a_A_a.getClassNode().getPackageNode()), "Did not remove package value a");
+        assertFalse(a_A_a.getClassNode().getPackageNode().isConfirmed(), "Package a is still concrete");
+        assertFalse(factory.getClasses().containsKey("a.A"), "Did not remove class key a.A");
+        assertFalse(factory.getClasses().containsValue(a_A_a.getClassNode()), "Did not remove class value a.A");
+        assertFalse(a_A_a.getClassNode().isConfirmed(), "Class a.A is still concrete");
+        assertFalse(factory.getFeatures().containsKey("a.A.a"), "Did not remove feature key a.A.a");
+        assertFalse(factory.getFeatures().containsValue(a_A_a), "Did not remove feature value a.A.a");
+        assertFalse(a_A_a.isConfirmed(), "Feature a.A.a is still concrete");
+        assertFalse(a_A_a.getOutboundDependencies().contains(b_B_b), "Did not remove a.A --> b.B");
+        
+        assertFalse(factory.getPackages().containsKey("b"), "Did not remove package key b");
+        assertFalse(factory.getPackages().containsValue(b_B_b.getClassNode().getPackageNode()), "Did not remove package value b");
+        assertFalse(b_B_b.getClassNode().getPackageNode().isConfirmed(), "Package b is now concrete");
+        assertFalse(factory.getClasses().containsKey("b.B"), "Did not remove class key b.B");
+        assertFalse(factory.getClasses().containsValue(b_B_b.getClassNode()), "Did not remove class value b.B");
+        assertFalse(b_B_b.getClassNode().isConfirmed(), "Class b.B is now concrete");
+        assertFalse(factory.getFeatures().containsKey("b.B.b"), "Did not remove feature key b.B.b");
+        assertFalse(factory.getFeatures().containsValue(b_B_b), "Did not remove feature value b.B.b");
+        assertFalse(b_B_b.isConfirmed(), "Feature b.B.b is now concrete");
+        assertFalse(b_B_b.getInboundDependencies().contains(a_A_a), "Did not remove b.B <-- a.A");
     }
 
     /**
@@ -835,623 +846,641 @@ public void testAcceptClassWithFeatureWithDependencyOnReferencedFeature() {
      *  +-- A
      *  </pre>
      */
-    public void testAcceptFeatureWithDependencyOnReferencedFeature() {
-        FeatureNode a_A_a = factory.createFeature("a.A.a", true);
-        FeatureNode b_B_b = factory.createFeature("b.B.b", false);
+    @Test
+    void testAcceptFeatureWithDependencyOnReferencedFeature() {
+        var a_A_a = factory.createFeature("a.A.a", true);
+        var b_B_b = factory.createFeature("b.B.b", false);
 
         a_A_a.addDependency(b_B_b);
 
-        assertTrue("Missing package key a", factory.getPackages().containsKey("a"));
-        assertTrue("Missing package value a", factory.getPackages().containsValue(a_A_a.getClassNode().getPackageNode()));
-        assertTrue("Package a not concrete", a_A_a.getClassNode().getPackageNode().isConfirmed());
-        assertTrue("Missing class key a.A", factory.getClasses().containsKey("a.A"));
-        assertTrue("Missing class value a.A", factory.getClasses().containsValue(a_A_a.getClassNode()));
-        assertTrue("Class a.A not concrete", a_A_a.getClassNode().isConfirmed());
-        assertTrue("Missing feature key a.A.a", factory.getFeatures().containsKey("a.A.a"));
-        assertTrue("Missing feature value a.A.a", factory.getFeatures().containsValue(a_A_a));
-        assertTrue("Feature a.A.a not concrete", a_A_a.isConfirmed());
-        assertTrue("a.A.a --> b.B.b is missing", a_A_a.getOutboundDependencies().contains(b_B_b));
-
-        assertTrue("Missing package key b", factory.getPackages().containsKey("b"));
-        assertTrue("Missing package value b", factory.getPackages().containsValue(b_B_b.getClassNode().getPackageNode()));
-        assertFalse("Package b is concrete", b_B_b.getClassNode().getPackageNode().isConfirmed());
-        assertTrue("Missing class key b.B", factory.getClasses().containsKey("b.B"));
-        assertTrue("Missing class value b.B", factory.getClasses().containsValue(b_B_b.getClassNode()));
-        assertFalse("Class b.B is concrete", b_B_b.getClassNode().isConfirmed());
-        assertTrue("Missing feature key b.B.b", factory.getFeatures().containsKey("b.B.b"));
-        assertTrue("Missing feature value b.B.b", factory.getFeatures().containsValue(b_B_b));
-        assertFalse("Feature b.B.b is concrete", b_B_b.isConfirmed());
-        assertTrue("b.B <-- a.A is missing", b_B_b.getInboundDependencies().contains(a_A_a));
+        assertTrue(factory.getPackages().containsKey("a"), "Missing package key a");
+        assertTrue(factory.getPackages().containsValue(a_A_a.getClassNode().getPackageNode()), "Missing package value a");
+        assertTrue(a_A_a.getClassNode().getPackageNode().isConfirmed(), "Package a not concrete");
+        assertTrue(factory.getClasses().containsKey("a.A"), "Missing class key a.A");
+        assertTrue(factory.getClasses().containsValue(a_A_a.getClassNode()), "Missing class value a.A");
+        assertTrue(a_A_a.getClassNode().isConfirmed(), "Class a.A not concrete");
+        assertTrue(factory.getFeatures().containsKey("a.A.a"), "Missing feature key a.A.a");
+        assertTrue(factory.getFeatures().containsValue(a_A_a), "Missing feature value a.A.a");
+        assertTrue(a_A_a.isConfirmed(), "Feature a.A.a not concrete");
+        assertTrue(a_A_a.getOutboundDependencies().contains(b_B_b), "a.A.a --> b.B.b is missing");
+
+        assertTrue(factory.getPackages().containsKey("b"), "Missing package key b");
+        assertTrue(factory.getPackages().containsValue(b_B_b.getClassNode().getPackageNode()), "Missing package value b");
+        assertFalse(b_B_b.getClassNode().getPackageNode().isConfirmed(), "Package b is concrete");
+        assertTrue(factory.getClasses().containsKey("b.B"), "Missing class key b.B");
+        assertTrue(factory.getClasses().containsValue(b_B_b.getClassNode()), "Missing class value b.B");
+        assertFalse(b_B_b.getClassNode().isConfirmed(), "Class b.B is concrete");
+        assertTrue(factory.getFeatures().containsKey("b.B.b"), "Missing feature key b.B.b");
+        assertTrue(factory.getFeatures().containsValue(b_B_b), "Missing feature value b.B.b");
+        assertFalse(b_B_b.isConfirmed(), "Feature b.B.b is concrete");
+        assertTrue(b_B_b.getInboundDependencies().contains(a_A_a), "b.B <-- a.A is missing");
 
         a_A_a.accept(visitor);
         
-        assertTrue("Removed package key a", factory.getPackages().containsKey("a"));
-        assertTrue("Removed package value a", factory.getPackages().containsValue(a_A_a.getClassNode().getPackageNode()));
-        assertTrue("Package a is no longer concrete", a_A_a.getClassNode().getPackageNode().isConfirmed());
-        assertTrue("Removed class key a.A", factory.getClasses().containsKey("a.A"));
-        assertTrue("Removed class value a.A", factory.getClasses().containsValue(a_A_a.getClassNode()));
-        assertTrue("Class a.A is no longer concrete", a_A_a.getClassNode().isConfirmed());
-        assertFalse("Did not remove feature key a.A.a", factory.getFeatures().containsKey("a.A.a"));
-        assertFalse("Did not remove feature value a.A.a", factory.getFeatures().containsValue(a_A_a));
-        assertFalse("Feature a.A.a is still concrete", a_A_a.isConfirmed());
-        assertFalse("Did not remove a.A --> b.B", a_A_a.getOutboundDependencies().contains(b_B_b));
-        
-        assertFalse("Did not remove package key b", factory.getPackages().containsKey("b"));
-        assertFalse("Did not remove package value b", factory.getPackages().containsValue(b_B_b.getClassNode().getPackageNode()));
-        assertFalse("Package b is now concrete", b_B_b.getClassNode().getPackageNode().isConfirmed());
-        assertFalse("Did not remove class key b.B", factory.getClasses().containsKey("b.B"));
-        assertFalse("Did not remove class value b.B", factory.getClasses().containsValue(b_B_b.getClassNode()));
-        assertFalse("Class b.B is now concrete", b_B_b.getClassNode().isConfirmed());
-        assertFalse("Did not remove feature key b.B.b", factory.getFeatures().containsKey("b.B.b"));
-        assertFalse("Did not remove feature value b.B.b", factory.getFeatures().containsValue(b_B_b));
-        assertFalse("Feature b.B.b is now concrete", b_B_b.isConfirmed());
-        assertFalse("Did not remove b.B <-- a.A", b_B_b.getInboundDependencies().contains(a_A_a));
+        assertTrue(factory.getPackages().containsKey("a"), "Removed package key a");
+        assertTrue(factory.getPackages().containsValue(a_A_a.getClassNode().getPackageNode()), "Removed package value a");
+        assertTrue(a_A_a.getClassNode().getPackageNode().isConfirmed(), "Package a is no longer concrete");
+        assertTrue(factory.getClasses().containsKey("a.A"), "Removed class key a.A");
+        assertTrue(factory.getClasses().containsValue(a_A_a.getClassNode()), "Removed class value a.A");
+        assertTrue(a_A_a.getClassNode().isConfirmed(), "Class a.A is no longer concrete");
+        assertFalse(factory.getFeatures().containsKey("a.A.a"), "Did not remove feature key a.A.a");
+        assertFalse(factory.getFeatures().containsValue(a_A_a), "Did not remove feature value a.A.a");
+        assertFalse(a_A_a.isConfirmed(), "Feature a.A.a is still concrete");
+        assertFalse(a_A_a.getOutboundDependencies().contains(b_B_b), "Did not remove a.A --> b.B");
+        
+        assertFalse(factory.getPackages().containsKey("b"), "Did not remove package key b");
+        assertFalse(factory.getPackages().containsValue(b_B_b.getClassNode().getPackageNode()), "Did not remove package value b");
+        assertFalse(b_B_b.getClassNode().getPackageNode().isConfirmed(), "Package b is now concrete");
+        assertFalse(factory.getClasses().containsKey("b.B"), "Did not remove class key b.B");
+        assertFalse(factory.getClasses().containsValue(b_B_b.getClassNode()), "Did not remove class value b.B");
+        assertFalse(b_B_b.getClassNode().isConfirmed(), "Class b.B is now concrete");
+        assertFalse(factory.getFeatures().containsKey("b.B.b"), "Did not remove feature key b.B.b");
+        assertFalse(factory.getFeatures().containsValue(b_B_b), "Did not remove feature value b.B.b");
+        assertFalse(b_B_b.isConfirmed(), "Feature b.B.b is now concrete");
+        assertFalse(b_B_b.getInboundDependencies().contains(a_A_a), "Did not remove b.B <-- a.A");
     }
 
-    public void testAcceptOutboundConcretePackage() {
-        PackageNode node = factory.createPackage("a", true);
+    @Test
+    void testAcceptOutboundConcretePackage() {
+        var node = factory.createPackage("a", true);
 
-        assertTrue("Missing package key a", factory.getPackages().containsKey("a"));
-        assertTrue("Missing package value a", factory.getPackages().containsValue(node));
-        assertTrue("Package a not concrete", node.isConfirmed());
+        assertTrue(factory.getPackages().containsKey("a"), "Missing package key a");
+        assertTrue(factory.getPackages().containsValue(node), "Missing package value a");
+        assertTrue(node.isConfirmed(), "Package a not concrete");
 
         node.acceptOutbound(visitor);
         
-        assertTrue("Removed package key a", factory.getPackages().containsKey("a"));
-        assertTrue("Removed package value a", factory.getPackages().containsValue(node));
-        assertTrue("Package a is no longer concrete", node.isConfirmed());
+        assertTrue(factory.getPackages().containsKey("a"), "Removed package key a");
+        assertTrue(factory.getPackages().containsValue(node), "Removed package value a");
+        assertTrue(node.isConfirmed(), "Package a is no longer concrete");
     }
 
-    public void testAcceptOutboundConcreteClass() {
-        ClassNode node = factory.createClass("a.A", true);
+    @Test
+    void testAcceptOutboundConcreteClass() {
+        var node = factory.createClass("a.A", true);
 
-        assertTrue("Missing package key a", factory.getPackages().containsKey("a"));
-        assertTrue("Missing package value a", factory.getPackages().containsValue(node.getPackageNode()));
-        assertTrue("Package a not concrete", node.getPackageNode().isConfirmed());
-        assertTrue("Package node does not contain class node", node.getPackageNode().getClasses().contains(node));
+        assertTrue(factory.getPackages().containsKey("a"), "Missing package key a");
+        assertTrue(factory.getPackages().containsValue(node.getPackageNode()), "Missing package value a");
+        assertTrue(node.getPackageNode().isConfirmed(), "Package a not concrete");
+        assertTrue(node.getPackageNode().getClasses().contains(node), "Package node does not contain class node");
         
-        assertTrue("Missing class key", factory.getClasses().containsKey("a.A"));
-        assertTrue("Missing class value", factory.getClasses().containsValue(node));
-        assertTrue("Class not concrete", node.isConfirmed());
+        assertTrue(factory.getClasses().containsKey("a.A"), "Missing class key");
+        assertTrue(factory.getClasses().containsValue(node), "Missing class value");
+        assertTrue(node.isConfirmed(), "Class not concrete");
 
         node.acceptOutbound(visitor);
         
-        assertTrue("Removed package key a", factory.getPackages().containsKey("a"));
-        assertTrue("Removed package value a", factory.getPackages().containsValue(node.getPackageNode()));
-        assertTrue("Package a is no longer concrete", node.getPackageNode().isConfirmed());
-        assertTrue("Package node no longer contains class node", node.getPackageNode().getClasses().contains(node));
+        assertTrue(factory.getPackages().containsKey("a"), "Removed package key a");
+        assertTrue(factory.getPackages().containsValue(node.getPackageNode()), "Removed package value a");
+        assertTrue(node.getPackageNode().isConfirmed(), "Package a is no longer concrete");
+        assertTrue(node.getPackageNode().getClasses().contains(node), "Package node no longer contains class node");
         
-        assertTrue("Removed class key", factory.getClasses().containsKey("a.A"));
-        assertTrue("Removed class value", factory.getClasses().containsValue(node));
-        assertTrue("Class a.A is no longer concrete", node.isConfirmed());
+        assertTrue(factory.getClasses().containsKey("a.A"), "Removed class key");
+        assertTrue(factory.getClasses().containsValue(node), "Removed class value");
+        assertTrue(node.isConfirmed(), "Class a.A is no longer concrete");
     }
 
-    public void testAcceptOutboundConcreteFeature() {
-        FeatureNode node = factory.createFeature("a.A.a", true);
+    @Test
+    void testAcceptOutboundConcreteFeature() {
+        var node = factory.createFeature("a.A.a", true);
 
-        assertTrue("Missing package key a", factory.getPackages().containsKey("a"));
-        assertTrue("Missing package value a", factory.getPackages().containsValue(node.getClassNode().getPackageNode()));
-        assertTrue("Package a not concrete", node.getClassNode().getPackageNode().isConfirmed());
-        assertTrue("Package node does not contain class node", node.getClassNode().getPackageNode().getClasses().contains(node.getClassNode()));
+        assertTrue(factory.getPackages().containsKey("a"), "Missing package key a");
+        assertTrue(factory.getPackages().containsValue(node.getClassNode().getPackageNode()), "Missing package value a");
+        assertTrue(node.getClassNode().getPackageNode().isConfirmed(), "Package a not concrete");
+        assertTrue(node.getClassNode().getPackageNode().getClasses().contains(node.getClassNode()), "Package node does not contain class node");
         
-        assertTrue("Missing class key", factory.getClasses().containsKey("a.A"));
-        assertTrue("Missing class value", factory.getClasses().containsValue(node.getClassNode()));
-        assertTrue("Class not concrete", node.getClassNode().isConfirmed());
-        assertTrue("Class node does not contain feature node", node.getClassNode().getFeatures().contains(node));
+        assertTrue(factory.getClasses().containsKey("a.A"), "Missing class key");
+        assertTrue(factory.getClasses().containsValue(node.getClassNode()), "Missing class value");
+        assertTrue(node.getClassNode().isConfirmed(), "Class not concrete");
+        assertTrue(node.getClassNode().getFeatures().contains(node), "Class node does not contain feature node");
         
-        assertTrue("Missing feature key", factory.getFeatures().containsKey("a.A.a"));
-        assertTrue("Missing feature value", factory.getFeatures().containsValue(node));
-        assertTrue("Feature not concrete", node.isConfirmed());
+        assertTrue(factory.getFeatures().containsKey("a.A.a"), "Missing feature key");
+        assertTrue(factory.getFeatures().containsValue(node), "Missing feature value");
+        assertTrue(node.isConfirmed(), "Feature not concrete");
 
         node.acceptOutbound(visitor);
         
-        assertTrue("Removed package key a", factory.getPackages().containsKey("a"));
-        assertTrue("Removed package value a", factory.getPackages().containsValue(node.getClassNode().getPackageNode()));
-        assertTrue("Package a is no longer concrete", node.getClassNode().getPackageNode().isConfirmed());
-        assertTrue("Package node no longer contains class node", node.getClassNode().getPackageNode().getClasses().contains(node.getClassNode()));
+        assertTrue(factory.getPackages().containsKey("a"), "Removed package key a");
+        assertTrue(factory.getPackages().containsValue(node.getClassNode().getPackageNode()), "Removed package value a");
+        assertTrue(node.getClassNode().getPackageNode().isConfirmed(), "Package a is no longer concrete");
+        assertTrue(node.getClassNode().getPackageNode().getClasses().contains(node.getClassNode()), "Package node no longer contains class node");
         
-        assertTrue("Removed class key", factory.getClasses().containsKey("a.A"));
-        assertTrue("Removed class value", factory.getClasses().containsValue(node.getClassNode()));
-        assertTrue("Class a.A is no longer concrete", node.getClassNode().isConfirmed());
-        assertTrue("Class node no longer contains feature node", node.getClassNode().getFeatures().contains(node));
+        assertTrue(factory.getClasses().containsKey("a.A"), "Removed class key");
+        assertTrue(factory.getClasses().containsValue(node.getClassNode()), "Removed class value");
+        assertTrue(node.getClassNode().isConfirmed(), "Class a.A is no longer concrete");
+        assertTrue(node.getClassNode().getFeatures().contains(node), "Class node no longer contains feature node");
         
-        assertTrue("Removed feature key", factory.getFeatures().containsKey("a.A.a"));
-        assertTrue("Removed feature value", factory.getFeatures().containsValue(node));
-        assertTrue("Feature a.A.a is no longer concrete", node.isConfirmed());
+        assertTrue(factory.getFeatures().containsKey("a.A.a"), "Removed feature key");
+        assertTrue(factory.getFeatures().containsValue(node), "Removed feature value");
+        assertTrue(node.isConfirmed(), "Feature a.A.a is no longer concrete");
     }
 
-    public void testAcceptOutboundEmptyNonConcretePackage() {
-        PackageNode node = factory.createPackage("a", false);
+    @Test
+    void testAcceptOutboundEmptyNonConcretePackage() {
+        var node = factory.createPackage("a", false);
 
-        assertTrue("Missing package key a", factory.getPackages().containsKey("a"));
-        assertTrue("Missing package value a", factory.getPackages().containsValue(node));
-        assertFalse("Package a concrete", node.isConfirmed());
+        assertTrue(factory.getPackages().containsKey("a"), "Missing package key a");
+        assertTrue(factory.getPackages().containsValue(node), "Missing package value a");
+        assertFalse(node.isConfirmed(), "Package a concrete");
 
         node.acceptOutbound(visitor);
         
-        assertFalse("Did not remove package key a", factory.getPackages().containsKey("a"));
-        assertFalse("Did not remove package value a", factory.getPackages().containsValue(node));
-        assertFalse("Package a is now concrete", node.isConfirmed());
+        assertFalse(factory.getPackages().containsKey("a"), "Did not remove package key a");
+        assertFalse(factory.getPackages().containsValue(node), "Did not remove package value a");
+        assertFalse(node.isConfirmed(), "Package a is now concrete");
     }
 
-    public void testAcceptOutboundEmptyNonConcreteClass() {
-        ClassNode node = factory.createClass("a.A", false);
+    @Test
+    void testAcceptOutboundEmptyNonConcreteClass() {
+        var node = factory.createClass("a.A", false);
 
-        assertTrue("Missing package key a", factory.getPackages().containsKey("a"));
-        assertTrue("Missing package value a", factory.getPackages().containsValue(node.getPackageNode()));
-        assertFalse("Package a is concrete", node.getPackageNode().isConfirmed());
-        assertTrue("Package node does not contain class node", node.getPackageNode().getClasses().contains(node));
+        assertTrue(factory.getPackages().containsKey("a"), "Missing package key a");
+        assertTrue(factory.getPackages().containsValue(node.getPackageNode()), "Missing package value a");
+        assertFalse(node.getPackageNode().isConfirmed(), "Package a is concrete");
+        assertTrue(node.getPackageNode().getClasses().contains(node), "Package node does not contain class node");
         
-        assertTrue("Missing class key", factory.getClasses().containsKey("a.A"));
-        assertTrue("Missing class value", factory.getClasses().containsValue(node));
-        assertFalse("Class a.A is concrete", node.isConfirmed());
+        assertTrue(factory.getClasses().containsKey("a.A"), "Missing class key");
+        assertTrue(factory.getClasses().containsValue(node), "Missing class value");
+        assertFalse(node.isConfirmed(), "Class a.A is concrete");
 
         node.acceptOutbound(visitor);
         
-        assertFalse("Did not remove package key a", factory.getPackages().containsKey("a"));
-        assertFalse("Did not remove package value a", factory.getPackages().containsValue(node.getPackageNode()));
-        assertFalse("Package a is now concrete", node.getPackageNode().isConfirmed());
-        assertFalse("Package node still contains class node", node.getPackageNode().getClasses().contains(node));
+        assertFalse(factory.getPackages().containsKey("a"), "Did not remove package key a");
+        assertFalse(factory.getPackages().containsValue(node.getPackageNode()), "Did not remove package value a");
+        assertFalse(node.getPackageNode().isConfirmed(), "Package a is now concrete");
+        assertFalse(node.getPackageNode().getClasses().contains(node), "Package node still contains class node");
         
-        assertFalse("Did not remove class key", factory.getClasses().containsKey("a.A"));
-        assertFalse("Did not remove class value", factory.getClasses().containsValue(node));
-        assertFalse("Class a.A is now concrete", node.isConfirmed());
+        assertFalse(factory.getClasses().containsKey("a.A"), "Did not remove class key");
+        assertFalse(factory.getClasses().containsValue(node), "Did not remove class value");
+        assertFalse(node.isConfirmed(), "Class a.A is now concrete");
     }
 
-    public void testAcceptOutboundEmptyNonConcreteFeature() {
-        FeatureNode node = factory.createFeature("a.A.a", false);
+    @Test
+    void testAcceptOutboundEmptyNonConcreteFeature() {
+        var node = factory.createFeature("a.A.a", false);
 
-        assertTrue("Missing package key a", factory.getPackages().containsKey("a"));
-        assertTrue("Missing package value a", factory.getPackages().containsValue(node.getClassNode().getPackageNode()));
-        assertFalse("Package a is concrete", node.getClassNode().getPackageNode().isConfirmed());
-        assertTrue("Package node does not contain class node", node.getClassNode().getPackageNode().getClasses().contains(node.getClassNode()));
+        assertTrue(factory.getPackages().containsKey("a"), "Missing package key a");
+        assertTrue(factory.getPackages().containsValue(node.getClassNode().getPackageNode()), "Missing package value a");
+        assertFalse(node.getClassNode().getPackageNode().isConfirmed(), "Package a is concrete");
+        assertTrue(node.getClassNode().getPackageNode().getClasses().contains(node.getClassNode()), "Package node does not contain class node");
         
-        assertTrue("Missing class key", factory.getClasses().containsKey("a.A"));
-        assertTrue("Missing class value", factory.getClasses().containsValue(node.getClassNode()));
-        assertFalse("Class a.A is concrete", node.getClassNode().isConfirmed());
-        assertTrue("Class node does not contain feature node", node.getClassNode().getFeatures().contains(node));
+        assertTrue(factory.getClasses().containsKey("a.A"), "Missing class key");
+        assertTrue(factory.getClasses().containsValue(node.getClassNode()), "Missing class value");
+        assertFalse(node.getClassNode().isConfirmed(), "Class a.A is concrete");
+        assertTrue(node.getClassNode().getFeatures().contains(node), "Class node does not contain feature node");
         
-        assertTrue("Missing feature key", factory.getFeatures().containsKey("a.A.a"));
-        assertTrue("Missing feature value", factory.getFeatures().containsValue(node));
-        assertFalse("Feature a.A.a is concrete", node.isConfirmed());
+        assertTrue(factory.getFeatures().containsKey("a.A.a"), "Missing feature key");
+        assertTrue(factory.getFeatures().containsValue(node), "Missing feature value");
+        assertFalse(node.isConfirmed(), "Feature a.A.a is concrete");
 
         node.acceptOutbound(visitor);
         
-        assertFalse("Did not remove package key a", factory.getPackages().containsKey("a"));
-        assertFalse("Did not remove package value a", factory.getPackages().containsValue(node.getClassNode().getPackageNode()));
-        assertFalse("Package a is now concrete", node.getClassNode().getPackageNode().isConfirmed());
-        assertFalse("Package node still contains class node", node.getClassNode().getPackageNode().getClasses().contains(node.getClassNode()));
+        assertFalse(factory.getPackages().containsKey("a"), "Did not remove package key a");
+        assertFalse(factory.getPackages().containsValue(node.getClassNode().getPackageNode()), "Did not remove package value a");
+        assertFalse(node.getClassNode().getPackageNode().isConfirmed(), "Package a is now concrete");
+        assertFalse(node.getClassNode().getPackageNode().getClasses().contains(node.getClassNode()), "Package node still contains class node");
         
-        assertFalse("Did not remove class key", factory.getClasses().containsKey("a.A"));
-        assertFalse("Did not remove class value", factory.getClasses().containsValue(node.getClassNode()));
-        assertFalse("Class a.A is now concrete", node.getClassNode().isConfirmed());
-        assertFalse("Class node still contains feature node", node.getClassNode().getFeatures().contains(node));
+        assertFalse(factory.getClasses().containsKey("a.A"), "Did not remove class key");
+        assertFalse(factory.getClasses().containsValue(node.getClassNode()), "Did not remove class value");
+        assertFalse(node.getClassNode().isConfirmed(), "Class a.A is now concrete");
+        assertFalse(node.getClassNode().getFeatures().contains(node), "Class node still contains feature node");
         
-        assertFalse("Did not remove feature key", factory.getFeatures().containsKey("a.A.a"));
-        assertFalse("Did not remove feature value", factory.getFeatures().containsValue(node));
-        assertFalse("Feature a.A.a is now concrete", node.isConfirmed());
+        assertFalse(factory.getFeatures().containsKey("a.A.a"), "Did not remove feature key");
+        assertFalse(factory.getFeatures().containsValue(node), "Did not remove feature value");
+        assertFalse(node.isConfirmed(), "Feature a.A.a is now concrete");
     }
 
-    public void testAcceptOutboundEmptyNonConcretePackageWithInboundDependency() {
-        PackageNode node1 = factory.createPackage("a", true);
-        PackageNode node2 = factory.createPackage("b", false);
+    @Test
+    void testAcceptOutboundEmptyNonConcretePackageWithInboundDependency() {
+        var node1 = factory.createPackage("a", true);
+        var node2 = factory.createPackage("b", false);
 
         node1.addDependency(node2);
         
-        assertTrue("Missing package key a", factory.getPackages().containsKey("a"));
-        assertTrue("Missing package value a", factory.getPackages().containsValue(node1));
-        assertTrue("Package a is not concrete", node1.isConfirmed());
-        assertTrue("a --> b is missing", node1.getOutboundDependencies().contains(node2));
+        assertTrue(factory.getPackages().containsKey("a"), "Missing package key a");
+        assertTrue(factory.getPackages().containsValue(node1), "Missing package value a");
+        assertTrue(node1.isConfirmed(), "Package a is not concrete");
+        assertTrue(node1.getOutboundDependencies().contains(node2), "a --> b is missing");
         
-        assertTrue("Missing package key b", factory.getPackages().containsKey("b"));
-        assertTrue("Missing package value b", factory.getPackages().containsValue(node2));
-        assertFalse("Package b is concrete", node2.isConfirmed());
-        assertTrue("b <-- a is missing", node2.getInboundDependencies().contains(node1));
+        assertTrue(factory.getPackages().containsKey("b"), "Missing package key b");
+        assertTrue(factory.getPackages().containsValue(node2), "Missing package value b");
+        assertFalse(node2.isConfirmed(), "Package b is concrete");
+        assertTrue(node2.getInboundDependencies().contains(node1), "b <-- a is missing");
 
         node2.acceptOutbound(visitor);
         
-        assertTrue("Removed package key a", factory.getPackages().containsKey("a"));
-        assertTrue("Removed package value a", factory.getPackages().containsValue(node1));
-        assertTrue("Package a is no longer concrete", node1.isConfirmed());
-        assertTrue("Removed a --> b", node1.getOutboundDependencies().contains(node2));
+        assertTrue(factory.getPackages().containsKey("a"), "Removed package key a");
+        assertTrue(factory.getPackages().containsValue(node1), "Removed package value a");
+        assertTrue(node1.isConfirmed(), "Package a is no longer concrete");
+        assertTrue(node1.getOutboundDependencies().contains(node2), "Removed a --> b");
 
-        assertTrue("Removed package key b", factory.getPackages().containsKey("b"));
-        assertTrue("Removed package value b", factory.getPackages().containsValue(node2));
-        assertFalse("Package b is now concrete", node2.isConfirmed());
-        assertTrue("Removed b <-- a", node2.getInboundDependencies().contains(node1));
+        assertTrue(factory.getPackages().containsKey("b"), "Removed package key b");
+        assertTrue(factory.getPackages().containsValue(node2), "Removed package value b");
+        assertFalse(node2.isConfirmed(), "Package b is now concrete");
+        assertTrue(node2.getInboundDependencies().contains(node1), "Removed b <-- a");
     }
 
-    public void testAcceptOutboundEmptyNonConcreteClassWithInboundDependency() {
-        ClassNode node1 = factory.createClass("a.A", true);
-        ClassNode node2 = factory.createClass("a.B", false);
+    @Test
+    void testAcceptOutboundEmptyNonConcreteClassWithInboundDependency() {
+        var node1 = factory.createClass("a.A", true);
+        var node2 = factory.createClass("a.B", false);
 
         node1.addDependency(node2);
 
-        assertTrue("Missing package key a", factory.getPackages().containsKey("a"));
-        assertTrue("Missing package value a", factory.getPackages().containsValue(node1.getPackageNode()));
-        assertTrue("Package a is not concrete", node1.getPackageNode().isConfirmed());
-        assertTrue("Package node does not contain class node a.A", node1.getPackageNode().getClasses().contains(node1));
-        assertTrue("Package node does not contain class node a.B", node2.getPackageNode().getClasses().contains(node2));
+        assertTrue(factory.getPackages().containsKey("a"), "Missing package key a");
+        assertTrue(factory.getPackages().containsValue(node1.getPackageNode()), "Missing package value a");
+        assertTrue(node1.getPackageNode().isConfirmed(), "Package a is not concrete");
+        assertTrue(node1.getPackageNode().getClasses().contains(node1), "Package node does not contain class node a.A");
+        assertTrue(node2.getPackageNode().getClasses().contains(node2), "Package node does not contain class node a.B");
 
-        assertTrue("Missing class key", factory.getClasses().containsKey("a.A"));
-        assertTrue("Missing class value", factory.getClasses().containsValue(node1));
-        assertTrue("Class a.A is not concrete", node1.isConfirmed());
-        assertTrue("a.A --> a.B is missing", node1.getOutboundDependencies().contains(node2));
+        assertTrue(factory.getClasses().containsKey("a.A"), "Missing class key");
+        assertTrue(factory.getClasses().containsValue(node1), "Missing class value");
+        assertTrue(node1.isConfirmed(), "Class a.A is not concrete");
+        assertTrue(node1.getOutboundDependencies().contains(node2), "a.A --> a.B is missing");
 
-        assertTrue("Missing class key", factory.getClasses().containsKey("a.B"));
-        assertTrue("Missing class value", factory.getClasses().containsValue(node2));
-        assertFalse("Class a.B is concrete", node2.isConfirmed());
-        assertTrue("a.B <-- a.A is missing", node2.getInboundDependencies().contains(node1));
+        assertTrue(factory.getClasses().containsKey("a.B"), "Missing class key");
+        assertTrue(factory.getClasses().containsValue(node2), "Missing class value");
+        assertFalse(node2.isConfirmed(), "Class a.B is concrete");
+        assertTrue(node2.getInboundDependencies().contains(node1), "a.B <-- a.A is missing");
 
         node2.acceptOutbound(visitor);
         
-        assertTrue("Removed package key a", factory.getPackages().containsKey("a"));
-        assertTrue("Removed package value a", factory.getPackages().containsValue(node1.getPackageNode()));
-        assertTrue("Package a is no longer concrete", node1.getPackageNode().isConfirmed());
-        assertTrue("Package node no longer contains class node a.A", node1.getPackageNode().getClasses().contains(node1));
-        assertTrue("Package node no longer contains class node a.B", node2.getPackageNode().getClasses().contains(node2));
-
-        assertTrue("Removed class key a.A", factory.getClasses().containsKey("a.A"));
-        assertTrue("Removed class value a.A", factory.getClasses().containsValue(node1));
-        assertTrue("Class a.A is no longer concrete", node1.isConfirmed());
-        assertTrue("Removed a.A --> a.B", node1.getOutboundDependencies().contains(node2));
-
-        assertTrue("Removed class key a.B", factory.getClasses().containsKey("a.B"));
-        assertTrue("Removed class value a.B", factory.getClasses().containsValue(node2));
-        assertFalse("Class a.B is now concrete", node2.isConfirmed());
-        assertTrue("Removed a.B <-- a.A", node2.getInboundDependencies().contains(node1));
+        assertTrue(factory.getPackages().containsKey("a"), "Removed package key a");
+        assertTrue(factory.getPackages().containsValue(node1.getPackageNode()), "Removed package value a");
+        assertTrue(node1.getPackageNode().isConfirmed(), "Package a is no longer concrete");
+        assertTrue(node1.getPackageNode().getClasses().contains(node1), "Package node no longer contains class node a.A");
+        assertTrue(node2.getPackageNode().getClasses().contains(node2), "Package node no longer contains class node a.B");
+
+        assertTrue(factory.getClasses().containsKey("a.A"), "Removed class key a.A");
+        assertTrue(factory.getClasses().containsValue(node1), "Removed class value a.A");
+        assertTrue(node1.isConfirmed(), "Class a.A is no longer concrete");
+        assertTrue(node1.getOutboundDependencies().contains(node2), "Removed a.A --> a.B");
+
+        assertTrue(factory.getClasses().containsKey("a.B"), "Removed class key a.B");
+        assertTrue(factory.getClasses().containsValue(node2), "Removed class value a.B");
+        assertFalse(node2.isConfirmed(), "Class a.B is now concrete");
+        assertTrue(node2.getInboundDependencies().contains(node1), "Removed a.B <-- a.A");
     }
 
-    public void testAcceptOutboundEmptyNonConcreteFeatureWithInboundDependency() {
-        FeatureNode node1 = factory.createFeature("a.A.a", true);
-        FeatureNode node2 = factory.createFeature("a.A.b", false);
+    @Test
+    void testAcceptOutboundEmptyNonConcreteFeatureWithInboundDependency() {
+        var node1 = factory.createFeature("a.A.a", true);
+        var node2 = factory.createFeature("a.A.b", false);
 
         node1.addDependency(node2);
 
-        assertTrue("Missing package key a", factory.getPackages().containsKey("a"));
-        assertTrue("Missing package value a", factory.getPackages().containsValue(node1.getClassNode().getPackageNode()));
-        assertTrue("Package a is not concrete", node1.getClassNode().getPackageNode().isConfirmed());
-        assertTrue("Package node does not contain class node", node1.getClassNode().getPackageNode().getClasses().contains(node1.getClassNode()));
+        assertTrue(factory.getPackages().containsKey("a"), "Missing package key a");
+        assertTrue(factory.getPackages().containsValue(node1.getClassNode().getPackageNode()), "Missing package value a");
+        assertTrue(node1.getClassNode().getPackageNode().isConfirmed(), "Package a is not concrete");
+        assertTrue(node1.getClassNode().getPackageNode().getClasses().contains(node1.getClassNode()), "Package node does not contain class node");
         
-        assertTrue("Missing class key", factory.getClasses().containsKey("a.A"));
-        assertTrue("Missing class value", factory.getClasses().containsValue(node1.getClassNode()));
-        assertTrue("Class a.A is not concrete", node1.getClassNode().isConfirmed());
-        assertTrue("Class node does not contain feature node a.A.a", node1.getClassNode().getFeatures().contains(node1));
-        assertTrue("Class node does not contain feature node a.A.b", node2.getClassNode().getFeatures().contains(node2));
+        assertTrue(factory.getClasses().containsKey("a.A"), "Missing class key");
+        assertTrue(factory.getClasses().containsValue(node1.getClassNode()), "Missing class value");
+        assertTrue(node1.getClassNode().isConfirmed(), "Class a.A is not concrete");
+        assertTrue(node1.getClassNode().getFeatures().contains(node1), "Class node does not contain feature node a.A.a");
+        assertTrue(node2.getClassNode().getFeatures().contains(node2), "Class node does not contain feature node a.A.b");
         
-        assertTrue("Missing feature key", factory.getFeatures().containsKey("a.A.a"));
-        assertTrue("Missing feature value", factory.getFeatures().containsValue(node1));
-        assertTrue("Feature a.A.a is not concrete", node1.isConfirmed());
-        assertTrue("a.A.a --> a.A.b is missing", node1.getOutboundDependencies().contains(node2));
+        assertTrue(factory.getFeatures().containsKey("a.A.a"), "Missing feature key");
+        assertTrue(factory.getFeatures().containsValue(node1), "Missing feature value");
+        assertTrue(node1.isConfirmed(), "Feature a.A.a is not concrete");
+        assertTrue(node1.getOutboundDependencies().contains(node2), "a.A.a --> a.A.b is missing");
         
-        assertTrue("Missing feature key", factory.getFeatures().containsKey("a.A.b"));
-        assertTrue("Missing feature value", factory.getFeatures().containsValue(node2));
-        assertFalse("Feature a.A.b is concrete", node2.isConfirmed());
-        assertTrue("a.A.b <-- a.A.a is missing", node2.getInboundDependencies().contains(node1));
+        assertTrue(factory.getFeatures().containsKey("a.A.b"), "Missing feature key");
+        assertTrue(factory.getFeatures().containsValue(node2), "Missing feature value");
+        assertFalse(node2.isConfirmed(), "Feature a.A.b is concrete");
+        assertTrue(node2.getInboundDependencies().contains(node1), "a.A.b <-- a.A.a is missing");
 
         node2.acceptOutbound(visitor);
         
-        assertTrue("Removed package key a", factory.getPackages().containsKey("a"));
-        assertTrue("Removed package value a", factory.getPackages().containsValue(node1.getClassNode().getPackageNode()));
-        assertTrue("Package a is no longer concrete", node1.getClassNode().getPackageNode().isConfirmed());
-        assertTrue("Package node no longer contains class node", node1.getClassNode().getPackageNode().getClasses().contains(node1.getClassNode()));
-        
-        assertTrue("Did not remove class key", factory.getClasses().containsKey("a.A"));
-        assertTrue("Did not remove class value", factory.getClasses().containsValue(node1.getClassNode()));
-        assertTrue("Class a.A is no longer concrete", node1.getClassNode().isConfirmed());
-        assertTrue("Class node no longer contains feature node a.A.a", node1.getClassNode().getFeatures().contains(node1));
-        assertTrue("Class node no longer contains feature node a.A.b", node2.getClassNode().getFeatures().contains(node2));
-        
-        assertTrue("Remove feature key", factory.getFeatures().containsKey("a.A.a"));
-        assertTrue("Remove feature value", factory.getFeatures().containsValue(node1));
-        assertTrue("Feature a.A.a is no longer concrete", node1.isConfirmed());
-        assertTrue("Removed a.A.a --> a.A.b", node1.getOutboundDependencies().contains(node2));
-        
-        assertTrue("Remove feature key", factory.getFeatures().containsKey("a.A.b"));
-        assertTrue("Remove feature value", factory.getFeatures().containsValue(node2));
-        assertFalse("Feature a.A.b is now concrete", node2.isConfirmed());
-        assertTrue("Removed a.A.b <-- a.A.a", node2.getInboundDependencies().contains(node1));
+        assertTrue(factory.getPackages().containsKey("a"), "Removed package key a");
+        assertTrue(factory.getPackages().containsValue(node1.getClassNode().getPackageNode()), "Removed package value a");
+        assertTrue(node1.getClassNode().getPackageNode().isConfirmed(), "Package a is no longer concrete");
+        assertTrue(node1.getClassNode().getPackageNode().getClasses().contains(node1.getClassNode()), "Package node no longer contains class node");
+        
+        assertTrue(factory.getClasses().containsKey("a.A"), "Did not remove class key");
+        assertTrue(factory.getClasses().containsValue(node1.getClassNode()), "Did not remove class value");
+        assertTrue(node1.getClassNode().isConfirmed(), "Class a.A is no longer concrete");
+        assertTrue(node1.getClassNode().getFeatures().contains(node1), "Class node no longer contains feature node a.A.a");
+        assertTrue(node2.getClassNode().getFeatures().contains(node2), "Class node no longer contains feature node a.A.b");
+        
+        assertTrue(factory.getFeatures().containsKey("a.A.a"), "Remove feature key");
+        assertTrue(factory.getFeatures().containsValue(node1), "Remove feature value");
+        assertTrue(node1.isConfirmed(), "Feature a.A.a is no longer concrete");
+        assertTrue(node1.getOutboundDependencies().contains(node2), "Removed a.A.a --> a.A.b");
+        
+        assertTrue(factory.getFeatures().containsKey("a.A.b"), "Remove feature key");
+        assertTrue(factory.getFeatures().containsValue(node2), "Remove feature value");
+        assertFalse(node2.isConfirmed(), "Feature a.A.b is now concrete");
+        assertTrue(node2.getInboundDependencies().contains(node1), "Removed a.A.b <-- a.A.a");
     }
 
-    public void testAcceptEmptyNonConcretePackageWithInboundDependency() {
-        PackageNode node1 = factory.createPackage("a", true);
-        PackageNode node2 = factory.createPackage("b", false);
+    @Test
+    void testAcceptEmptyNonConcretePackageWithInboundDependency() {
+        var node1 = factory.createPackage("a", true);
+        var node2 = factory.createPackage("b", false);
 
         node1.addDependency(node2);
         
-        assertTrue("Missing package key a", factory.getPackages().containsKey("a"));
-        assertTrue("Missing package value a", factory.getPackages().containsValue(node1));
-        assertTrue("Package a is not concrete", node1.isConfirmed());
-        assertTrue("a --> b is missing", node1.getOutboundDependencies().contains(node2));
+        assertTrue(factory.getPackages().containsKey("a"), "Missing package key a");
+        assertTrue(factory.getPackages().containsValue(node1), "Missing package value a");
+        assertTrue(node1.isConfirmed(), "Package a is not concrete");
+        assertTrue(node1.getOutboundDependencies().contains(node2), "a --> b is missing");
         
-        assertTrue("Missing package key b", factory.getPackages().containsKey("b"));
-        assertTrue("Missing package value b", factory.getPackages().containsValue(node2));
-        assertFalse("Package b is concrete", node2.isConfirmed());
-        assertTrue("b <-- a is missing", node2.getInboundDependencies().contains(node1));
+        assertTrue(factory.getPackages().containsKey("b"), "Missing package key b");
+        assertTrue(factory.getPackages().containsValue(node2), "Missing package value b");
+        assertFalse(node2.isConfirmed(), "Package b is concrete");
+        assertTrue(node2.getInboundDependencies().contains(node1), "b <-- a is missing");
 
         node2.accept(visitor);
         
-        assertTrue("Removed package key a", factory.getPackages().containsKey("a"));
-        assertTrue("Removed package value a", factory.getPackages().containsValue(node1));
-        assertTrue("Package a is no longer concrete", node1.isConfirmed());
-        assertTrue("Removed a --> b", node1.getOutboundDependencies().contains(node2));
+        assertTrue(factory.getPackages().containsKey("a"), "Removed package key a");
+        assertTrue(factory.getPackages().containsValue(node1), "Removed package value a");
+        assertTrue(node1.isConfirmed(), "Package a is no longer concrete");
+        assertTrue(node1.getOutboundDependencies().contains(node2), "Removed a --> b");
 
-        assertTrue("Removed package key b", factory.getPackages().containsKey("b"));
-        assertTrue("Removed package value b", factory.getPackages().containsValue(node2));
-        assertFalse("Package b is now concrete", node2.isConfirmed());
-        assertTrue("Removed b <-- a", node2.getInboundDependencies().contains(node1));
+        assertTrue(factory.getPackages().containsKey("b"), "Removed package key b");
+        assertTrue(factory.getPackages().containsValue(node2), "Removed package value b");
+        assertFalse(node2.isConfirmed(), "Package b is now concrete");
+        assertTrue(node2.getInboundDependencies().contains(node1), "Removed b <-- a");
     }
 
-    public void testAcceptEmptyNonConcreteClassWithInboundDependency() {
-        ClassNode node1 = factory.createClass("a.A", true);
-        ClassNode node2 = factory.createClass("a.B", false);
+    @Test
+    void testAcceptEmptyNonConcreteClassWithInboundDependency() {
+        var node1 = factory.createClass("a.A", true);
+        var node2 = factory.createClass("a.B", false);
 
         node1.addDependency(node2);
 
-        assertTrue("Missing package key a", factory.getPackages().containsKey("a"));
-        assertTrue("Missing package value a", factory.getPackages().containsValue(node1.getPackageNode()));
-        assertTrue("Package a is not concrete", node1.getPackageNode().isConfirmed());
-        assertTrue("Package node does not contain class node a.A", node1.getPackageNode().getClasses().contains(node1));
-        assertTrue("Package node does not contain class node a.B", node2.getPackageNode().getClasses().contains(node2));
+        assertTrue(factory.getPackages().containsKey("a"), "Missing package key a");
+        assertTrue(factory.getPackages().containsValue(node1.getPackageNode()), "Missing package value a");
+        assertTrue(node1.getPackageNode().isConfirmed(), "Package a is not concrete");
+        assertTrue(node1.getPackageNode().getClasses().contains(node1), "Package node does not contain class node a.A");
+        assertTrue(node2.getPackageNode().getClasses().contains(node2), "Package node does not contain class node a.B");
 
-        assertTrue("Missing class key", factory.getClasses().containsKey("a.A"));
-        assertTrue("Missing class value", factory.getClasses().containsValue(node1));
-        assertTrue("Class a.A is not concrete", node1.isConfirmed());
-        assertTrue("a.A --> a.B is missing", node1.getOutboundDependencies().contains(node2));
+        assertTrue(factory.getClasses().containsKey("a.A"), "Missing class key");
+        assertTrue(factory.getClasses().containsValue(node1), "Missing class value");
+        assertTrue(node1.isConfirmed(), "Class a.A is not concrete");
+        assertTrue(node1.getOutboundDependencies().contains(node2), "a.A --> a.B is missing");
 
-        assertTrue("Missing class key", factory.getClasses().containsKey("a.B"));
-        assertTrue("Missing class value", factory.getClasses().containsValue(node2));
-        assertFalse("Class a.B is concrete", node2.isConfirmed());
-        assertTrue("a.B <-- a.A is missing", node2.getInboundDependencies().contains(node1));
+        assertTrue(factory.getClasses().containsKey("a.B"), "Missing class key");
+        assertTrue(factory.getClasses().containsValue(node2), "Missing class value");
+        assertFalse(node2.isConfirmed(), "Class a.B is concrete");
+        assertTrue(node2.getInboundDependencies().contains(node1), "a.B <-- a.A is missing");
 
         node2.accept(visitor);
         
-        assertTrue("Removed package key a", factory.getPackages().containsKey("a"));
-        assertTrue("Removed package value a", factory.getPackages().containsValue(node1.getPackageNode()));
-        assertTrue("Package a is no longer concrete", node1.getPackageNode().isConfirmed());
-        assertTrue("Package node no longer contains class node a.A", node1.getPackageNode().getClasses().contains(node1));
-        assertTrue("Package node no longer contains class node a.B", node2.getPackageNode().getClasses().contains(node2));
-
-        assertTrue("Removed class key a.A", factory.getClasses().containsKey("a.A"));
-        assertTrue("Removed class value a.A", factory.getClasses().containsValue(node1));
-        assertTrue("Class a.A is no longer concrete", node1.isConfirmed());
-        assertTrue("Removed a.A --> a.B", node1.getOutboundDependencies().contains(node2));
-
-        assertTrue("Removed class key a.B", factory.getClasses().containsKey("a.B"));
-        assertTrue("Removed class value a.B", factory.getClasses().containsValue(node2));
-        assertFalse("Class a.B is now concrete", node2.isConfirmed());
-        assertTrue("Removed a.B <-- a.A", node2.getInboundDependencies().contains(node1));
+        assertTrue(factory.getPackages().containsKey("a"), "Removed package key a");
+        assertTrue(factory.getPackages().containsValue(node1.getPackageNode()), "Removed package value a");
+        assertTrue(node1.getPackageNode().isConfirmed(), "Package a is no longer concrete");
+        assertTrue(node1.getPackageNode().getClasses().contains(node1), "Package node no longer contains class node a.A");
+        assertTrue(node2.getPackageNode().getClasses().contains(node2), "Package node no longer contains class node a.B");
+
+        assertTrue(factory.getClasses().containsKey("a.A"), "Removed class key a.A");
+        assertTrue(factory.getClasses().containsValue(node1), "Removed class value a.A");
+        assertTrue(node1.isConfirmed(), "Class a.A is no longer concrete");
+        assertTrue(node1.getOutboundDependencies().contains(node2), "Removed a.A --> a.B");
+
+        assertTrue(factory.getClasses().containsKey("a.B"), "Removed class key a.B");
+        assertTrue(factory.getClasses().containsValue(node2), "Removed class value a.B");
+        assertFalse(node2.isConfirmed(), "Class a.B is now concrete");
+        assertTrue(node2.getInboundDependencies().contains(node1), "Removed a.B <-- a.A");
     }
 
-    public void testAcceptEmptyNonConcreteFeatureWithInboundDependency() {
-        FeatureNode node1 = factory.createFeature("a.A.a", true);
-        FeatureNode node2 = factory.createFeature("a.A.b", false);
+    @Test
+    void testAcceptEmptyNonConcreteFeatureWithInboundDependency() {
+        var node1 = factory.createFeature("a.A.a", true);
+        var node2 = factory.createFeature("a.A.b", false);
 
         node1.addDependency(node2);
 
-        assertTrue("Missing package key a", factory.getPackages().containsKey("a"));
-        assertTrue("Missing package value a", factory.getPackages().containsValue(node1.getClassNode().getPackageNode()));
-        assertTrue("Package a is not concrete", node1.getClassNode().getPackageNode().isConfirmed());
-        assertTrue("Package node does not contain class node", node1.getClassNode().getPackageNode().getClasses().contains(node1.getClassNode()));
+        assertTrue(factory.getPackages().containsKey("a"), "Missing package key a");
+        assertTrue(factory.getPackages().containsValue(node1.getClassNode().getPackageNode()), "Missing package value a");
+        assertTrue(node1.getClassNode().getPackageNode().isConfirmed(), "Package a is not concrete");
+        assertTrue(node1.getClassNode().getPackageNode().getClasses().contains(node1.getClassNode()), "Package node does not contain class node");
         
-        assertTrue("Missing class key", factory.getClasses().containsKey("a.A"));
-        assertTrue("Missing class value", factory.getClasses().containsValue(node1.getClassNode()));
-        assertTrue("Class a.A is not concrete", node1.getClassNode().isConfirmed());
-        assertTrue("Class node does not contain feature node a.A.a", node1.getClassNode().getFeatures().contains(node1));
-        assertTrue("Class node does not contain feature node a.A.b", node2.getClassNode().getFeatures().contains(node2));
+        assertTrue(factory.getClasses().containsKey("a.A"), "Missing class key");
+        assertTrue(factory.getClasses().containsValue(node1.getClassNode()), "Missing class value");
+        assertTrue(node1.getClassNode().isConfirmed(), "Class a.A is not concrete");
+        assertTrue(node1.getClassNode().getFeatures().contains(node1), "Class node does not contain feature node a.A.a");
+        assertTrue(node2.getClassNode().getFeatures().contains(node2), "Class node does not contain feature node a.A.b");
         
-        assertTrue("Missing feature key", factory.getFeatures().containsKey("a.A.a"));
-        assertTrue("Missing feature value", factory.getFeatures().containsValue(node1));
-        assertTrue("Feature a.A.a is not concrete", node1.isConfirmed());
-        assertTrue("a.A.a --> a.A.b is missing", node1.getOutboundDependencies().contains(node2));
+        assertTrue(factory.getFeatures().containsKey("a.A.a"), "Missing feature key");
+        assertTrue(factory.getFeatures().containsValue(node1), "Missing feature value");
+        assertTrue(node1.isConfirmed(), "Feature a.A.a is not concrete");
+        assertTrue(node1.getOutboundDependencies().contains(node2), "a.A.a --> a.A.b is missing");
         
-        assertTrue("Missing feature key", factory.getFeatures().containsKey("a.A.b"));
-        assertTrue("Missing feature value", factory.getFeatures().containsValue(node2));
-        assertFalse("Feature a.A.b is concrete", node2.isConfirmed());
-        assertTrue("a.A.b <-- a.A.a is missing", node2.getInboundDependencies().contains(node1));
+        assertTrue(factory.getFeatures().containsKey("a.A.b"), "Missing feature key");
+        assertTrue(factory.getFeatures().containsValue(node2), "Missing feature value");
+        assertFalse(node2.isConfirmed(), "Feature a.A.b is concrete");
+        assertTrue(node2.getInboundDependencies().contains(node1), "a.A.b <-- a.A.a is missing");
 
         node2.accept(visitor);
         
-        assertTrue("Removed package key a", factory.getPackages().containsKey("a"));
-        assertTrue("Removed package value a", factory.getPackages().containsValue(node1.getClassNode().getPackageNode()));
-        assertTrue("Package a is no longer concrete", node1.getClassNode().getPackageNode().isConfirmed());
-        assertTrue("Package node no longer contains class node", node1.getClassNode().getPackageNode().getClasses().contains(node1.getClassNode()));
-        
-        assertTrue("Did not remove class key", factory.getClasses().containsKey("a.A"));
-        assertTrue("Did not remove class value", factory.getClasses().containsValue(node1.getClassNode()));
-        assertTrue("Class a.A is no longer concrete", node1.getClassNode().isConfirmed());
-        assertTrue("Class node no longer contains feature node a.A.a", node1.getClassNode().getFeatures().contains(node1));
-        assertTrue("Class node no longer contains feature node a.A.b", node2.getClassNode().getFeatures().contains(node2));
-        
-        assertTrue("Remove feature key", factory.getFeatures().containsKey("a.A.a"));
-        assertTrue("Remove feature value", factory.getFeatures().containsValue(node1));
-        assertTrue("Feature a.A.a is no longer concrete", node1.isConfirmed());
-        assertTrue("Removed a.A.a --> a.A.b", node1.getOutboundDependencies().contains(node2));
-        
-        assertTrue("Remove feature key", factory.getFeatures().containsKey("a.A.b"));
-        assertTrue("Remove feature value", factory.getFeatures().containsValue(node2));
-        assertFalse("Feature a.A.b is now concrete", node2.isConfirmed());
-        assertTrue("Removed a.A.b <-- a.A.a", node2.getInboundDependencies().contains(node1));
+        assertTrue(factory.getPackages().containsKey("a"), "Removed package key a");
+        assertTrue(factory.getPackages().containsValue(node1.getClassNode().getPackageNode()), "Removed package value a");
+        assertTrue(node1.getClassNode().getPackageNode().isConfirmed(), "Package a is no longer concrete");
+        assertTrue(node1.getClassNode().getPackageNode().getClasses().contains(node1.getClassNode()), "Package node no longer contains class node");
+        
+        assertTrue(factory.getClasses().containsKey("a.A"), "Did not remove class key");
+        assertTrue(factory.getClasses().containsValue(node1.getClassNode()), "Did not remove class value");
+        assertTrue(node1.getClassNode().isConfirmed(), "Class a.A is no longer concrete");
+        assertTrue(node1.getClassNode().getFeatures().contains(node1), "Class node no longer contains feature node a.A.a");
+        assertTrue(node2.getClassNode().getFeatures().contains(node2), "Class node no longer contains feature node a.A.b");
+        
+        assertTrue(factory.getFeatures().containsKey("a.A.a"), "Remove feature key");
+        assertTrue(factory.getFeatures().containsValue(node1), "Remove feature value");
+        assertTrue(node1.isConfirmed(), "Feature a.A.a is no longer concrete");
+        assertTrue(node1.getOutboundDependencies().contains(node2), "Removed a.A.a --> a.A.b");
+        
+        assertTrue(factory.getFeatures().containsKey("a.A.b"), "Remove feature key");
+        assertTrue(factory.getFeatures().containsValue(node2), "Remove feature value");
+        assertFalse(node2.isConfirmed(), "Feature a.A.b is now concrete");
+        assertTrue(node2.getInboundDependencies().contains(node1), "Removed a.A.b <-- a.A.a");
     }
 
-    public void testAcceptEmptyConcretePackageWithInboundDependency() {
-        PackageNode node1 = factory.createPackage("a", true);
-        PackageNode node2 = factory.createPackage("b", true);
+    @Test
+    void testAcceptEmptyConcretePackageWithInboundDependency() {
+        var node1 = factory.createPackage("a", true);
+        var node2 = factory.createPackage("b", true);
 
         node1.addDependency(node2);
         
-        assertTrue("Missing package key a", factory.getPackages().containsKey("a"));
-        assertTrue("Missing package value a", factory.getPackages().containsValue(node1));
-        assertTrue("Package a is not concrete", node1.isConfirmed());
-        assertTrue("a --> b is missing", node1.getOutboundDependencies().contains(node2));
+        assertTrue(factory.getPackages().containsKey("a"), "Missing package key a");
+        assertTrue(factory.getPackages().containsValue(node1), "Missing package value a");
+        assertTrue(node1.isConfirmed(), "Package a is not concrete");
+        assertTrue(node1.getOutboundDependencies().contains(node2), "a --> b is missing");
         
-        assertTrue("Missing package key b", factory.getPackages().containsKey("b"));
-        assertTrue("Missing package value b", factory.getPackages().containsValue(node2));
-        assertTrue("Package b is not concrete", node2.isConfirmed());
-        assertTrue("b <-- a is missing", node2.getInboundDependencies().contains(node1));
+        assertTrue(factory.getPackages().containsKey("b"), "Missing package key b");
+        assertTrue(factory.getPackages().containsValue(node2), "Missing package value b");
+        assertTrue(node2.isConfirmed(), "Package b is not concrete");
+        assertTrue(node2.getInboundDependencies().contains(node1), "b <-- a is missing");
 
         node2.accept(visitor);
         
-        assertTrue("Removed package key a", factory.getPackages().containsKey("a"));
-        assertTrue("Removed package value a", factory.getPackages().containsValue(node1));
-        assertTrue("Package a is no longer concrete", node1.isConfirmed());
-        assertTrue("Removed a --> b", node1.getOutboundDependencies().contains(node2));
+        assertTrue(factory.getPackages().containsKey("a"), "Removed package key a");
+        assertTrue(factory.getPackages().containsValue(node1), "Removed package value a");
+        assertTrue(node1.isConfirmed(), "Package a is no longer concrete");
+        assertTrue(node1.getOutboundDependencies().contains(node2), "Removed a --> b");
 
-        assertTrue("Removed package key b", factory.getPackages().containsKey("b"));
-        assertTrue("Removed package value b", factory.getPackages().containsValue(node2));
-        assertFalse("Package b is still concrete", node2.isConfirmed());
-        assertTrue("Removed b <-- a", node2.getInboundDependencies().contains(node1));
+        assertTrue(factory.getPackages().containsKey("b"), "Removed package key b");
+        assertTrue(factory.getPackages().containsValue(node2), "Removed package value b");
+        assertFalse(node2.isConfirmed(), "Package b is still concrete");
+        assertTrue(node2.getInboundDependencies().contains(node1), "Removed b <-- a");
     }
 
-    public void testAcceptEmptyConcreteClassWithInboundDependency() {
-        ClassNode node1 = factory.createClass("a.A", true);
-        ClassNode node2 = factory.createClass("a.B", true);
+    @Test
+    void testAcceptEmptyConcreteClassWithInboundDependency() {
+        var node1 = factory.createClass("a.A", true);
+        var node2 = factory.createClass("a.B", true);
 
         node1.addDependency(node2);
 
-        assertTrue("Missing package key a", factory.getPackages().containsKey("a"));
-        assertTrue("Missing package value a", factory.getPackages().containsValue(node1.getPackageNode()));
-        assertTrue("Package a is not concrete", node1.getPackageNode().isConfirmed());
-        assertTrue("Package node does not contain class node a.A", node1.getPackageNode().getClasses().contains(node1));
-        assertTrue("Package node does not contain class node a.B", node2.getPackageNode().getClasses().contains(node2));
+        assertTrue(factory.getPackages().containsKey("a"), "Missing package key a");
+        assertTrue(factory.getPackages().containsValue(node1.getPackageNode()), "Missing package value a");
+        assertTrue(node1.getPackageNode().isConfirmed(), "Package a is not concrete");
+        assertTrue(node1.getPackageNode().getClasses().contains(node1), "Package node does not contain class node a.A");
+        assertTrue(node2.getPackageNode().getClasses().contains(node2), "Package node does not contain class node a.B");
 
-        assertTrue("Missing class key", factory.getClasses().containsKey("a.A"));
-        assertTrue("Missing class value", factory.getClasses().containsValue(node1));
-        assertTrue("Class a.A is not concrete", node1.isConfirmed());
-        assertTrue("a.A --> a.B is missing", node1.getOutboundDependencies().contains(node2));
+        assertTrue(factory.getClasses().containsKey("a.A"), "Missing class key");
+        assertTrue(factory.getClasses().containsValue(node1), "Missing class value");
+        assertTrue(node1.isConfirmed(), "Class a.A is not concrete");
+        assertTrue(node1.getOutboundDependencies().contains(node2), "a.A --> a.B is missing");
 
-        assertTrue("Missing class key", factory.getClasses().containsKey("a.B"));
-        assertTrue("Missing class value", factory.getClasses().containsValue(node2));
-        assertTrue("Class a.B is not concrete", node2.isConfirmed());
-        assertTrue("a.B <-- a.A is missing", node2.getInboundDependencies().contains(node1));
+        assertTrue(factory.getClasses().containsKey("a.B"), "Missing class key");
+        assertTrue(factory.getClasses().containsValue(node2), "Missing class value");
+        assertTrue(node2.isConfirmed(), "Class a.B is not concrete");
+        assertTrue(node2.getInboundDependencies().contains(node1), "a.B <-- a.A is missing");
 
         node2.accept(visitor);
         
-        assertTrue("Removed package key a", factory.getPackages().containsKey("a"));
-        assertTrue("Removed package value a", factory.getPackages().containsValue(node1.getPackageNode()));
-        assertTrue("Package a is no longer concrete", node1.getPackageNode().isConfirmed());
-        assertTrue("Package node no longer contains class node a.A", node1.getPackageNode().getClasses().contains(node1));
-        assertTrue("Package node no longer contains class node a.B", node2.getPackageNode().getClasses().contains(node2));
-
-        assertTrue("Removed class key a.A", factory.getClasses().containsKey("a.A"));
-        assertTrue("Removed class value a.A", factory.getClasses().containsValue(node1));
-        assertTrue("Class a.A is no longer concrete", node1.isConfirmed());
-        assertTrue("Removed a.A --> a.B", node1.getOutboundDependencies().contains(node2));
-
-        assertTrue("Removed class key a.B", factory.getClasses().containsKey("a.B"));
-        assertTrue("Removed class value a.B", factory.getClasses().containsValue(node2));
-        assertFalse("Class a.B is still concrete", node2.isConfirmed());
-        assertTrue("Removed a.B <-- a.A", node2.getInboundDependencies().contains(node1));
+        assertTrue(factory.getPackages().containsKey("a"), "Removed package key a");
+        assertTrue(factory.getPackages().containsValue(node1.getPackageNode()), "Removed package value a");
+        assertTrue(node1.getPackageNode().isConfirmed(), "Package a is no longer concrete");
+        assertTrue(node1.getPackageNode().getClasses().contains(node1), "Package node no longer contains class node a.A");
+        assertTrue(node2.getPackageNode().getClasses().contains(node2), "Package node no longer contains class node a.B");
+
+        assertTrue(factory.getClasses().containsKey("a.A"), "Removed class key a.A");
+        assertTrue(factory.getClasses().containsValue(node1), "Removed class value a.A");
+        assertTrue(node1.isConfirmed(), "Class a.A is no longer concrete");
+        assertTrue(node1.getOutboundDependencies().contains(node2), "Removed a.A --> a.B");
+
+        assertTrue(factory.getClasses().containsKey("a.B"), "Removed class key a.B");
+        assertTrue(factory.getClasses().containsValue(node2), "Removed class value a.B");
+        assertFalse(node2.isConfirmed(), "Class a.B is still concrete");
+        assertTrue(node2.getInboundDependencies().contains(node1), "Removed a.B <-- a.A");
     }
 
-    public void testAcceptEmptyConcreteFeatureWithInboundDependency() {
-        FeatureNode node1 = factory.createFeature("a.A.a", true);
-        FeatureNode node2 = factory.createFeature("a.A.b", true);
+    @Test
+    void testAcceptEmptyConcreteFeatureWithInboundDependency() {
+        var node1 = factory.createFeature("a.A.a", true);
+        var node2 = factory.createFeature("a.A.b", true);
 
         node1.addDependency(node2);
 
-        assertTrue("Missing package key a", factory.getPackages().containsKey("a"));
-        assertTrue("Missing package value a", factory.getPackages().containsValue(node1.getClassNode().getPackageNode()));
-        assertTrue("Package a is not concrete", node1.getClassNode().getPackageNode().isConfirmed());
-        assertTrue("Package node does not contain class node", node1.getClassNode().getPackageNode().getClasses().contains(node1.getClassNode()));
+        assertTrue(factory.getPackages().containsKey("a"), "Missing package key a");
+        assertTrue(factory.getPackages().containsValue(node1.getClassNode().getPackageNode()), "Missing package value a");
+        assertTrue(node1.getClassNode().getPackageNode().isConfirmed(), "Package a is not concrete");
+        assertTrue(node1.getClassNode().getPackageNode().getClasses().contains(node1.getClassNode()), "Package node does not contain class node");
         
-        assertTrue("Missing class key", factory.getClasses().containsKey("a.A"));
-        assertTrue("Missing class value", factory.getClasses().containsValue(node1.getClassNode()));
-        assertTrue("Class a.A is not concrete", node1.getClassNode().isConfirmed());
-        assertTrue("Class node does not contain feature node a.A.a", node1.getClassNode().getFeatures().contains(node1));
-        assertTrue("Class node does not contain feature node a.A.b", node2.getClassNode().getFeatures().contains(node2));
+        assertTrue(factory.getClasses().containsKey("a.A"), "Missing class key");
+        assertTrue(factory.getClasses().containsValue(node1.getClassNode()), "Missing class value");
+        assertTrue(node1.getClassNode().isConfirmed(), "Class a.A is not concrete");
+        assertTrue(node1.getClassNode().getFeatures().contains(node1), "Class node does not contain feature node a.A.a");
+        assertTrue(node2.getClassNode().getFeatures().contains(node2), "Class node does not contain feature node a.A.b");
         
-        assertTrue("Missing feature key", factory.getFeatures().containsKey("a.A.a"));
-        assertTrue("Missing feature value", factory.getFeatures().containsValue(node1));
-        assertTrue("Feature a.A.a is not concrete", node1.isConfirmed());
-        assertTrue("a.A.a --> a.A.b is missing", node1.getOutboundDependencies().contains(node2));
+        assertTrue(factory.getFeatures().containsKey("a.A.a"), "Missing feature key");
+        assertTrue(factory.getFeatures().containsValue(node1), "Missing feature value");
+        assertTrue(node1.isConfirmed(), "Feature a.A.a is not concrete");
+        assertTrue(node1.getOutboundDependencies().contains(node2), "a.A.a --> a.A.b is missing");
         
-        assertTrue("Missing feature key", factory.getFeatures().containsKey("a.A.b"));
-        assertTrue("Missing feature value", factory.getFeatures().containsValue(node2));
-        assertTrue("Feature a.A.b is not concrete", node2.isConfirmed());
-        assertTrue("a.A.b <-- a.A.a is missing", node2.getInboundDependencies().contains(node1));
+        assertTrue(factory.getFeatures().containsKey("a.A.b"), "Missing feature key");
+        assertTrue(factory.getFeatures().containsValue(node2), "Missing feature value");
+        assertTrue(node2.isConfirmed(), "Feature a.A.b is not concrete");
+        assertTrue(node2.getInboundDependencies().contains(node1), "a.A.b <-- a.A.a is missing");
 
         node2.accept(visitor);
         
-        assertTrue("Removed package key a", factory.getPackages().containsKey("a"));
-        assertTrue("Removed package value a", factory.getPackages().containsValue(node1.getClassNode().getPackageNode()));
-        assertTrue("Package a is no longer concrete", node1.getClassNode().getPackageNode().isConfirmed());
-        assertTrue("Package node no longer contains class node", node1.getClassNode().getPackageNode().getClasses().contains(node1.getClassNode()));
-        
-        assertTrue("Did not remove class key", factory.getClasses().containsKey("a.A"));
-        assertTrue("Did not remove class value", factory.getClasses().containsValue(node1.getClassNode()));
-        assertTrue("Class a.A is no longer concrete", node1.getClassNode().isConfirmed());
-        assertTrue("Class node no longer contains feature node a.A.a", node1.getClassNode().getFeatures().contains(node1));
-        assertTrue("Class node no longer contains feature node a.A.b", node2.getClassNode().getFeatures().contains(node2));
-        
-        assertTrue("Remove feature key", factory.getFeatures().containsKey("a.A.a"));
-        assertTrue("Remove feature value", factory.getFeatures().containsValue(node1));
-        assertTrue("Feature a.A.a is no longer concrete", node1.isConfirmed());
-        assertTrue("Removed a.A.a --> a.A.b", node1.getOutboundDependencies().contains(node2));
-        
-        assertTrue("Remove feature key", factory.getFeatures().containsKey("a.A.b"));
-        assertTrue("Remove feature value", factory.getFeatures().containsValue(node2));
-        assertFalse("Feature a.A.b is still concrete", node2.isConfirmed());
-        assertTrue("Removed a.A.b <-- a.A.a", node2.getInboundDependencies().contains(node1));
+        assertTrue(factory.getPackages().containsKey("a"), "Removed package key a");
+        assertTrue(factory.getPackages().containsValue(node1.getClassNode().getPackageNode()), "Removed package value a");
+        assertTrue(node1.getClassNode().getPackageNode().isConfirmed(), "Package a is no longer concrete");
+        assertTrue(node1.getClassNode().getPackageNode().getClasses().contains(node1.getClassNode()), "Package node no longer contains class node");
+        
+        assertTrue(factory.getClasses().containsKey("a.A"), "Did not remove class key");
+        assertTrue(factory.getClasses().containsValue(node1.getClassNode()), "Did not remove class value");
+        assertTrue(node1.getClassNode().isConfirmed(), "Class a.A is no longer concrete");
+        assertTrue(node1.getClassNode().getFeatures().contains(node1), "Class node no longer contains feature node a.A.a");
+        assertTrue(node2.getClassNode().getFeatures().contains(node2), "Class node no longer contains feature node a.A.b");
+        
+        assertTrue(factory.getFeatures().containsKey("a.A.a"), "Remove feature key");
+        assertTrue(factory.getFeatures().containsValue(node1), "Remove feature value");
+        assertTrue(node1.isConfirmed(), "Feature a.A.a is no longer concrete");
+        assertTrue(node1.getOutboundDependencies().contains(node2), "Removed a.A.a --> a.A.b");
+        
+        assertTrue(factory.getFeatures().containsKey("a.A.b"), "Remove feature key");
+        assertTrue(factory.getFeatures().containsValue(node2), "Remove feature value");
+        assertFalse(node2.isConfirmed(), "Feature a.A.b is still concrete");
+        assertTrue(node2.getInboundDependencies().contains(node1), "Removed a.A.b <-- a.A.a");
     }
 
-    public void testAcceptOutboundNonEmptyPackage() {
-        PackageNode node1 = factory.createPackage("a", false);
-        ClassNode node2 = factory.createClass("a.A", false);
+    @Test
+    void testAcceptOutboundNonEmptyPackage() {
+        var node1 = factory.createPackage("a", false);
+        var node2 = factory.createClass("a.A", false);
 
-        assertTrue("Missing package key a", factory.getPackages().containsKey("a"));
-        assertTrue("Missing package value a", factory.getPackages().containsValue(node1));
-        assertFalse("Package a concrete", node1.isConfirmed());
-        assertTrue("Package node does not contain class node", node1.getClasses().contains(node2));
+        assertTrue(factory.getPackages().containsKey("a"), "Missing package key a");
+        assertTrue(factory.getPackages().containsValue(node1), "Missing package value a");
+        assertFalse(node1.isConfirmed(), "Package a concrete");
+        assertTrue(node1.getClasses().contains(node2), "Package node does not contain class node");
         
-        assertTrue("Missing class key", factory.getClasses().containsKey("a.A"));
-        assertTrue("Missing class value", factory.getClasses().containsValue(node2));
-        assertFalse("Class a.A is concrete", node2.isConfirmed());
+        assertTrue(factory.getClasses().containsKey("a.A"), "Missing class key");
+        assertTrue(factory.getClasses().containsValue(node2), "Missing class value");
+        assertFalse(node2.isConfirmed(), "Class a.A is concrete");
 
         node1.acceptOutbound(visitor);
         
-        assertTrue("Removed package key a", factory.getPackages().containsKey("a"));
-        assertTrue("Removed package value a", factory.getPackages().containsValue(node1));
-        assertFalse("Package a is now concrete", node1.isConfirmed());
-        assertTrue("Package node no longer contains class node", node1.getClasses().contains(node2));
+        assertTrue(factory.getPackages().containsKey("a"), "Removed package key a");
+        assertTrue(factory.getPackages().containsValue(node1), "Removed package value a");
+        assertFalse(node1.isConfirmed(), "Package a is now concrete");
+        assertTrue(node1.getClasses().contains(node2), "Package node no longer contains class node");
         
-        assertTrue("Removed class key", factory.getClasses().containsKey("a.A"));
-        assertTrue("Removed class value", factory.getClasses().containsValue(node2));
-        assertFalse("Class a.A is now concrete", node2.isConfirmed());
+        assertTrue(factory.getClasses().containsKey("a.A"), "Removed class key");
+        assertTrue(factory.getClasses().containsValue(node2), "Removed class value");
+        assertFalse(node2.isConfirmed(), "Class a.A is now concrete");
     }
 
-    public void testAcceptOutboundNonEmptyClass() {
-        ClassNode node1 = factory.createClass("a.A", false);
-        FeatureNode node2 = factory.createFeature("a.A.a", false);
+    @Test
+    void testAcceptOutboundNonEmptyClass() {
+        var node1 = factory.createClass("a.A", false);
+        var node2 = factory.createFeature("a.A.a", false);
 
-        assertTrue("Missing package key a", factory.getPackages().containsKey("a"));
-        assertTrue("Missing package value a", factory.getPackages().containsValue(node1.getPackageNode()));
-        assertFalse("Package a is concrete", node1.getPackageNode().isConfirmed());
-        assertTrue("Package node does not contain class node", node1.getPackageNode().getClasses().contains(node1));
+        assertTrue(factory.getPackages().containsKey("a"), "Missing package key a");
+        assertTrue(factory.getPackages().containsValue(node1.getPackageNode()), "Missing package value a");
+        assertFalse(node1.getPackageNode().isConfirmed(), "Package a is concrete");
+        assertTrue(node1.getPackageNode().getClasses().contains(node1), "Package node does not contain class node");
         
-        assertTrue("Missing class key", factory.getClasses().containsKey("a.A"));
-        assertTrue("Missing class value", factory.getClasses().containsValue(node1));
-        assertFalse("Class a.A is concrete", node1.isConfirmed());
-        assertTrue("Class node does not contain feature node", node1.getFeatures().contains(node2));
+        assertTrue(factory.getClasses().containsKey("a.A"), "Missing class key");
+        assertTrue(factory.getClasses().containsValue(node1), "Missing class value");
+        assertFalse(node1.isConfirmed(), "Class a.A is concrete");
+        assertTrue(node1.getFeatures().contains(node2), "Class node does not contain feature node");
         
-        assertTrue("Missing feature key", factory.getFeatures().containsKey("a.A.a"));
-        assertTrue("Missing feature value", factory.getFeatures().containsValue(node2));
-        assertFalse("Feature a.A.a is concrete", node2.isConfirmed());
+        assertTrue(factory.getFeatures().containsKey("a.A.a"), "Missing feature key");
+        assertTrue(factory.getFeatures().containsValue(node2), "Missing feature value");
+        assertFalse(node2.isConfirmed(), "Feature a.A.a is concrete");
 
         node1.acceptOutbound(visitor);
         
-        assertTrue("Removed package key a", factory.getPackages().containsKey("a"));
-        assertTrue("Removed package value a", factory.getPackages().containsValue(node1.getPackageNode()));
-        assertFalse("Package a is now concrete", node1.getPackageNode().isConfirmed());
-        assertTrue("Package node no longer contains class node", node1.getPackageNode().getClasses().contains(node1));
+        assertTrue(factory.getPackages().containsKey("a"), "Removed package key a");
+        assertTrue(factory.getPackages().containsValue(node1.getPackageNode()), "Removed package value a");
+        assertFalse(node1.getPackageNode().isConfirmed(), "Package a is now concrete");
+        assertTrue(node1.getPackageNode().getClasses().contains(node1), "Package node no longer contains class node");
         
-        assertTrue("Removed class key", factory.getClasses().containsKey("a.A"));
-        assertTrue("Removed class value", factory.getClasses().containsValue(node1));
-        assertFalse("Class a.A is now concrete", node1.isConfirmed());
-        assertTrue("Class node no longer contains feature node", node1.getFeatures().contains(node2));
+        assertTrue(factory.getClasses().containsKey("a.A"), "Removed class key");
+        assertTrue(factory.getClasses().containsValue(node1), "Removed class value");
+        assertFalse(node1.isConfirmed(), "Class a.A is now concrete");
+        assertTrue(node1.getFeatures().contains(node2), "Class node no longer contains feature node");
         
-        assertTrue("Removed feature key", factory.getFeatures().containsKey("a.A.a"));
-        assertTrue("Removed feature value", factory.getFeatures().containsValue(node2));
-        assertFalse("Feature a.A.a is now concrete", node2.isConfirmed());
+        assertTrue(factory.getFeatures().containsKey("a.A.a"), "Removed feature key");
+        assertTrue(factory.getFeatures().containsValue(node2), "Removed feature value");
+        assertFalse(node2.isConfirmed(), "Feature a.A.a is now concrete");
     }
 }
diff --git a/lib/src/test/java/com/jeantessier/dependency/TestLCOM4Gatherer.java b/lib/src/test/java/com/jeantessier/dependency/TestLCOM4Gatherer.java
index 7a7a96ea..a6a20985 100644
--- a/lib/src/test/java/com/jeantessier/dependency/TestLCOM4Gatherer.java
+++ b/lib/src/test/java/com/jeantessier/dependency/TestLCOM4Gatherer.java
@@ -32,31 +32,28 @@
 
 package com.jeantessier.dependency;
 
-import junit.framework.TestCase;
 
 import java.util.*;
 
-public class TestLCOM4Gatherer extends TestCase {
-    private NodeFactory factory;
+import org.junit.jupiter.api.*;
 
-    private LCOM4Gatherer sut;
+import static org.junit.jupiter.api.Assertions.*;
 
-    protected void setUp() throws Exception {
-        super.setUp();
+public class TestLCOM4Gatherer {
+    private final NodeFactory factory = new NodeFactory();
 
-        factory = new NodeFactory();
+    private final LCOM4Gatherer sut = new LCOM4Gatherer();
 
-        sut = new LCOM4Gatherer();
-    }
-
-    public void testNothing() {
+    @Test
+    void testNothing() {
         sut.traverseNodes(factory.getPackages().values());
 
         var actualResults = sut.getResults();
         assertTrue(actualResults.isEmpty());
     }
 
-    public void testEmptyPackage() {
+    @Test
+    void testEmptyPackage() {
         factory.createPackage("", true);
 
         sut.traverseNodes(factory.getPackages().values());
@@ -65,37 +62,39 @@ public void testEmptyPackage() {
         assertTrue(actualResults.isEmpty());
     }
 
-    public void testEmptyClass() {
+    @Test
+    void testEmptyClass() {
         ClassNode classNode = factory.createClass("Empty", true);
 
         sut.traverseNodes(factory.getPackages().values());
 
         var actualResults = sut.getResults();
-        assertEquals("nb results", 1, actualResults.keySet().size());
-        assertTrue(classNode.getName() + " is missing from " + actualResults, actualResults.containsKey(classNode));
+        assertEquals(1, actualResults.size(), "nb results");
+        assertTrue(actualResults.containsKey(classNode), classNode.getName() + " is missing from " + actualResults);
 
         Collection<Collection<FeatureNode>> components = actualResults.get(classNode);
-        assertEquals("LCOM4 of empty class", 0, components.size());
+        assertEquals(0, components.size(), "LCOM4 of empty class");
     }
 
     /**
      * Tests One.one, where class One will have an LCOM4 of 1 and
      * the component will be [One.one].
      */
-    public void testOneFeature() {
+    @Test
+    void testOneFeature() {
         FeatureNode featureNode = factory.createFeature("One.one", true);
 
         sut.traverseNodes(factory.getPackages().values());
 
         var actualResults = sut.getResults();
-        assertEquals("nb results", 1, actualResults.keySet().size());
-        assertTrue(featureNode.getClassNode().getName() + " is missing from " + actualResults, actualResults.containsKey(featureNode.getClassNode()));
+        assertEquals(1, actualResults.size(), "nb results");
+        assertTrue(actualResults.containsKey(featureNode.getClassNode()), featureNode.getClassNode().getName() + " is missing from " + actualResults);
 
-        Collection<Collection<FeatureNode>> components = actualResults.get(featureNode.getClassNode());
-        assertEquals("LCOM4 of class w/ one feature", 1, components.size());
+        var components = actualResults.get(featureNode.getClassNode());
+        assertEquals(1, components.size(), "LCOM4 of class w/ one feature");
 
-        Collection<FeatureNode> component = components.iterator().next();
-        assertEquals("Size of first component", 1, component.size());
+        var component = components.iterator().next();
+        assertEquals(1, component.size(), "Size of first component");
         assertTrue(component.contains(featureNode));
     }
 
@@ -103,18 +102,19 @@ public void testOneFeature() {
      * Tests One.one and One.two, where class One will have an LCOM4 of 2 and
      * the components will be [One.one] and [One.two].
      */
-    public void testTwoDisjointFeatures() {
+    @Test
+    void testTwoDisjointFeatures() {
         FeatureNode featureNode1 = factory.createFeature("Two.one", true);
         FeatureNode featureNode2 = factory.createFeature("Two.two", true);
 
         sut.traverseNodes(factory.getPackages().values());
 
         var actualResults = sut.getResults();
-        assertEquals("nb results", 1, actualResults.keySet().size());
-        assertTrue(featureNode1.getClassNode().getName() + " is missing from " + actualResults, actualResults.containsKey(featureNode1.getClassNode()));
+        assertEquals(1, actualResults.size(), "nb results");
+        assertTrue(actualResults.containsKey(featureNode1.getClassNode()), featureNode1.getClassNode().getName() + " is missing from " + actualResults);
 
-        Collection<Collection<FeatureNode>> components = actualResults.get(featureNode1.getClassNode());
-        assertEquals("LCOM4 of class w/ two disjoint features", 2, components.size());
+        var components = actualResults.get(featureNode1.getClassNode());
+        assertEquals(2, components.size(), "LCOM4 of class w/ two disjoint features");
 
         assertAtLeastOneComponentEquals(components, featureNode1);
         assertAtLeastOneComponentEquals(components, featureNode2);
@@ -124,7 +124,8 @@ public void testTwoDisjointFeatures() {
      * Tests One.one --> One.two, where class One will have an LCOM4 of 1 and
      * the component will be [One.one, One.two].
      */
-    public void testTwoConnectedFeatures() {
+    @Test
+    void testTwoConnectedFeatures() {
         FeatureNode featureNode1 = factory.createFeature("Two.one", true);
         FeatureNode featureNode2 = factory.createFeature("Two.two", true);
 
@@ -133,11 +134,11 @@ public void testTwoConnectedFeatures() {
         sut.traverseNodes(factory.getPackages().values());
 
         var actualResults = sut.getResults();
-        assertEquals("nb results", 1, actualResults.keySet().size());
-        assertTrue(featureNode1.getClassNode().getName() + " is missing from " + actualResults, actualResults.containsKey(featureNode1.getClassNode()));
+        assertEquals(1, actualResults.size(), "nb results");
+        assertTrue(actualResults.containsKey(featureNode1.getClassNode()), featureNode1.getClassNode().getName() + " is missing from " + actualResults);
 
-        Collection<Collection<FeatureNode>> components = actualResults.get(featureNode1.getClassNode());
-        assertEquals("LCOM4 of class w/ two connected features", 1, components.size());
+        var components = actualResults.get(featureNode1.getClassNode());
+        assertEquals(1, components.size(), "LCOM4 of class w/ two connected features");
 
         assertAtLeastOneComponentEquals(components, featureNode1, featureNode2);
     }
@@ -146,7 +147,8 @@ public void testTwoConnectedFeatures() {
      * Tests One.one --> One.two --> One.three, where class One will have an
      * LCOM4 of 1 and the component will be [One.one, One.two, One.three].
      */
-    public void testThreeConnectedFeatures() {
+    @Test
+    void testThreeConnectedFeatures() {
         FeatureNode featureNode1 = factory.createFeature("Three.one", true);
         FeatureNode featureNode2 = factory.createFeature("Three.two", true);
         FeatureNode featureNode3 = factory.createFeature("Three.three", true);
@@ -157,11 +159,11 @@ public void testThreeConnectedFeatures() {
         sut.traverseNodes(factory.getPackages().values());
 
         var actualResults = sut.getResults();
-        assertEquals("nb results", 1, actualResults.keySet().size());
-        assertTrue(featureNode1.getClassNode().getName() + " is missing from " + actualResults, actualResults.containsKey(featureNode1.getClassNode()));
+        assertEquals(1, actualResults.size(), "nb results");
+        assertTrue(actualResults.containsKey(featureNode1.getClassNode()), featureNode1.getClassNode().getName() + " is missing from " + actualResults);
 
-        Collection<Collection<FeatureNode>> components = actualResults.get(featureNode1.getClassNode());
-        assertEquals("LCOM4 of class w/ three connected features", 1, components.size());
+        var components = actualResults.get(featureNode1.getClassNode());
+        assertEquals(1, components.size(), "LCOM4 of class w/ three connected features");
 
         assertAtLeastOneComponentEquals(components, featureNode1, featureNode2, featureNode3);
     }
@@ -171,7 +173,8 @@ public void testThreeConnectedFeatures() {
      * the component will be [One.one].  Two.two is not included because it is
      * in another class.
      */
-    public void testTwoConnectedFeaturesInSeparateClasses() {
+    @Test
+    void testTwoConnectedFeaturesInSeparateClasses() {
         FeatureNode featureNode1 = factory.createFeature("One.one", true);
         FeatureNode featureNode2 = factory.createFeature("Two.two", true);
 
@@ -180,11 +183,11 @@ public void testTwoConnectedFeaturesInSeparateClasses() {
         sut.traverseNodes(factory.getPackages().values());
 
         var actualResults = sut.getResults();
-        assertEquals("nb results", 2, actualResults.keySet().size());
-        assertTrue(featureNode1.getClassNode().getName() + " is missing from " + actualResults, actualResults.containsKey(featureNode1.getClassNode()));
+        assertEquals(2, actualResults.size(), "nb results");
+        assertTrue(actualResults.containsKey(featureNode1.getClassNode()), featureNode1.getClassNode().getName() + " is missing from " + actualResults);
 
-        Collection<Collection<FeatureNode>> components = actualResults.get(featureNode1.getClassNode());
-        assertEquals("LCOM4 of class w/ feature connected to other class", 1, components.size());
+        var components = actualResults.get(featureNode1.getClassNode());
+        assertEquals(1, components.size(), "LCOM4 of class w/ feature connected to other class");
 
         assertAtLeastOneComponentEquals(components, featureNode1);
     }
@@ -195,7 +198,8 @@ public void testTwoConnectedFeaturesInSeparateClasses() {
      * are two components because the link between the methods is outside
      * class One.
      */
-    public void testTwoIndirectlyConnectedFeatures() {
+    @Test
+    void testTwoIndirectlyConnectedFeatures() {
         FeatureNode featureNode1 = factory.createFeature("One.one", true);
         FeatureNode featureNode2 = factory.createFeature("Two.two", true);
         FeatureNode featureNode3 = factory.createFeature("One.two", true);
@@ -206,31 +210,33 @@ public void testTwoIndirectlyConnectedFeatures() {
         sut.traverseNodes(factory.getPackages().values());
 
         var actualResults = sut.getResults();
-        assertEquals("nb results", 2, actualResults.keySet().size());
-        assertTrue(featureNode1.getClassNode().getName() + " is missing from " + actualResults, actualResults.containsKey(featureNode1.getClassNode()));
+        assertEquals(2, actualResults.size(), "nb results");
+        assertTrue(actualResults.containsKey(featureNode1.getClassNode()), featureNode1.getClassNode().getName() + " is missing from " + actualResults);
 
-        Collection<Collection<FeatureNode>> components = actualResults.get(featureNode1.getClassNode());
-        assertEquals("LCOM4 of class w/ features connected through other class", 2, components.size());
+        var components = actualResults.get(featureNode1.getClassNode());
+        assertEquals(2, components.size(), "LCOM4 of class w/ features connected through other class");
 
         assertAtLeastOneComponentEquals(components, featureNode1);
         assertAtLeastOneComponentEquals(components, featureNode3);
     }
 
-    public void testIgnoreConstructor() {
+    @Test
+    void testIgnoreConstructor() {
         ClassNode classNode = factory.createClass("One", true);
         factory.createFeature("One.One()", true);
 
         sut.traverseNodes(factory.getPackages().values());
 
         var actualResults = sut.getResults();
-        assertEquals("nb results", 1, actualResults.keySet().size());
-        assertTrue(classNode.getName() + " is missing from " + actualResults, actualResults.containsKey(classNode));
+        assertEquals(1, actualResults.size(), "nb results");
+        assertTrue(actualResults.containsKey(classNode), classNode.getName() + " is missing from " + actualResults);
 
-        Collection<Collection<FeatureNode>> components = actualResults.get(classNode);
-        assertEquals("LCOM4 of class w/ only constructors", 0, components.size());
+        var components = actualResults.get(classNode);
+        assertEquals(0, components.size(), "LCOM4 of class w/ only constructors");
     }
 
-    public void testIgnoreConstructor_WithinGraph() {
+    @Test
+    void testIgnoreConstructor_WithinGraph() {
         ClassNode classNode = factory.createClass("Three", true);
         FeatureNode constructorNode = factory.createFeature("Three.Three()", true);
         FeatureNode featureNode1 = factory.createFeature("Three.one", true);
@@ -242,20 +248,20 @@ public void testIgnoreConstructor_WithinGraph() {
         sut.traverseNodes(factory.getPackages().values());
 
         var actualResults = sut.getResults();
-        assertEquals("nb results", 1, actualResults.keySet().size());
-        assertTrue(classNode.getName() + " is missing from " + actualResults, actualResults.containsKey(classNode));
+        assertEquals(1, actualResults.size(), "nb results");
+        assertTrue(actualResults.containsKey(classNode), classNode.getName() + " is missing from " + actualResults);
 
-        Collection<Collection<FeatureNode>> components = actualResults.get(classNode);
-        assertEquals("LCOM4 of class w/ two features connected through the constructor " + components, 2, components.size());
+        var components = actualResults.get(classNode);
+        assertEquals(2, components.size(), "LCOM4 of class w/ two features connected through the constructor " + components);
 
         assertAtLeastOneComponentEquals(components, featureNode1);
         assertAtLeastOneComponentEquals(components, featureNode2);
     }
 
     private void assertAtLeastOneComponentEquals(Collection<Collection<FeatureNode>> components, FeatureNode ... expectedNodes) {
-        var found = components.stream().anyMatch(component -> checkComponentEquals(component, expectedNodes));
-
-        assertTrue(Arrays.asList(expectedNodes) + " not in " + components,found);
+        assertTrue(
+                components.stream()
+                        .anyMatch(component -> checkComponentEquals(component, expectedNodes)));
     }
 
     private boolean checkComponentEquals(Collection<FeatureNode> component, FeatureNode ... expectedNodes) {
diff --git a/lib/src/test/java/com/jeantessier/dependency/TestNullSelectionCriteria.java b/lib/src/test/java/com/jeantessier/dependency/TestNullSelectionCriteria.java
index 7b3eaa04..177746a5 100644
--- a/lib/src/test/java/com/jeantessier/dependency/TestNullSelectionCriteria.java
+++ b/lib/src/test/java/com/jeantessier/dependency/TestNullSelectionCriteria.java
@@ -32,50 +32,37 @@
 
 package com.jeantessier.dependency;
 
-import junit.framework.*;
+import org.junit.jupiter.api.*;
 
-public class TestNullSelectionCriteria extends TestCase {
-    private NullSelectionCriteria criteria;
+import static org.junit.jupiter.api.Assertions.*;
 
-    private PackageNode a;
-    private ClassNode a_A;
-    private FeatureNode a_A_a;
-    
-    private PackageNode b;
-    private ClassNode b_B;
-    private FeatureNode b_B_b;
-    
-    private PackageNode c;
-    private ClassNode c_C;
-    private FeatureNode c_C_c;
+public class TestNullSelectionCriteria {
+    private final NodeFactory factory = new NodeFactory();
 
-    protected void setUp() throws Exception {
-        criteria = new NullSelectionCriteria();
+    private final PackageNode a = factory.createPackage("a");
+    private final ClassNode a_A = factory.createClass("a.A");
+    private final FeatureNode a_A_a = factory.createFeature("a.A.a");
 
-        NodeFactory factory = new NodeFactory();
+    private final PackageNode b = factory.createPackage("b");
+    private final ClassNode b_B = factory.createClass("b.B");
+    private final FeatureNode b_B_b = factory.createFeature("b.B.b");
 
-        a     = factory.createPackage("a");
-        a_A   = factory.createClass("a.A");
-        a_A_a = factory.createFeature("a.A.a");
-        
-        b     = factory.createPackage("b");
-        b_B   = factory.createClass("b.B");
-        b_B_b = factory.createFeature("b.B.b");
-        
-        c     = factory.createPackage("c");
-        c_C   = factory.createClass("c.C");
-        c_C_c = factory.createFeature("c.C.c");
-    }
-    
-    public void testMatch() {
-        assertFalse("a in package scope",     criteria.matches(a));
-        assertFalse("a.A in package scope",   criteria.matches(a_A));
-        assertFalse("a.A.a in package scope", criteria.matches(a_A_a));
-        assertFalse("b in package scope",     criteria.matches(b));
-        assertFalse("b.B in package scope",   criteria.matches(b_B));
-        assertFalse("b.B.b in package scope", criteria.matches(b_B_b));
-        assertFalse("c in package scope",     criteria.matches(c));
-        assertFalse("c.C in package scope",   criteria.matches(c_C));
-        assertFalse("c.C.c in package scope", criteria.matches(c_C_c));
+    private final PackageNode c = factory.createPackage("c");
+    private final ClassNode c_C = factory.createClass("c.C");
+    private final FeatureNode c_C_c = factory.createFeature("c.C.c");
+
+    private final NullSelectionCriteria criteria = new NullSelectionCriteria();
+
+    @Test
+    void testMatch() {
+        assertFalse(criteria.matches(a), "a in package scope");
+        assertFalse(criteria.matches(a_A), "a.A in package scope");
+        assertFalse(criteria.matches(a_A_a), "a.A.a in package scope");
+        assertFalse(criteria.matches(b), "b in package scope");
+        assertFalse(criteria.matches(b_B), "b.B in package scope");
+        assertFalse(criteria.matches(b_B_b), "b.B.b in package scope");
+        assertFalse(criteria.matches(c), "c in package scope");
+        assertFalse(criteria.matches(c_C), "c.C in package scope");
+        assertFalse(criteria.matches(c_C_c), "c.C.c in package scope");
     }
 }
diff --git a/lib/src/test/java/com/jeantessier/dependency/TestTransitiveClosure.java b/lib/src/test/java/com/jeantessier/dependency/TestTransitiveClosure.java
index 037196da..dd6745d7 100644
--- a/lib/src/test/java/com/jeantessier/dependency/TestTransitiveClosure.java
+++ b/lib/src/test/java/com/jeantessier/dependency/TestTransitiveClosure.java
@@ -32,37 +32,32 @@
 
 package com.jeantessier.dependency;
 
-import java.util.*;
-
-import junit.framework.*;
+import org.junit.jupiter.api.*;
 
-public class TestTransitiveClosure extends TestCase {
-    private NodeFactory factory;
+import java.util.*;
 
-    private RegularExpressionSelectionCriteria startCriteria;
-    private RegularExpressionSelectionCriteria stopCriteria;
+import static org.junit.jupiter.api.Assertions.*;
 
-    private TransitiveClosure selector;
+public class TestTransitiveClosure {
+    private final NodeFactory factory = new NodeFactory();
 
-    protected void setUp() throws Exception {
-        super.setUp();
+    private final RegularExpressionSelectionCriteria startCriteria = new RegularExpressionSelectionCriteria();
+    private final RegularExpressionSelectionCriteria stopCriteria = new RegularExpressionSelectionCriteria();
 
-        factory = new NodeFactory();
+    private final TransitiveClosure selector = new TransitiveClosure(startCriteria, stopCriteria);
 
+    @BeforeEach
+    void setUp() {
         var a_A_a = factory.createFeature("a.A.a");
         var b_B_b = factory.createFeature("b.B.b");
         var c_C_c = factory.createFeature("c.C.c");
 
         a_A_a.addDependency(b_B_b);
         b_B_b.addDependency(c_C_c);
-
-        startCriteria = new RegularExpressionSelectionCriteria();
-        stopCriteria  = new RegularExpressionSelectionCriteria();
-        
-        selector = new TransitiveClosure(startCriteria, stopCriteria);
     }
     
-    public void testZeroOutbound() {
+    @Test
+    void testZeroOutbound() {
         startCriteria.setGlobalIncludes("/a.A.a/");
         stopCriteria.setGlobalIncludes("/c.C.c/");
 
@@ -71,12 +66,13 @@ public void testZeroOutbound() {
         
         selector.traverseNodes(factory.getPackages().values());
 
-        assertEquals("packages", 1, selector.getFactory().getPackages().size());
-        assertEquals("classes",  1, selector.getFactory().getClasses().size());
-        assertEquals("features", 1, selector.getFactory().getFeatures().size());
+        assertEquals(1, selector.getFactory().getPackages().size(), "packages");
+        assertEquals(1, selector.getFactory().getClasses().size(), "classes");
+        assertEquals(1, selector.getFactory().getFeatures().size(), "features");
     }
 
-    public void testOneOutbound() {
+    @Test
+    void testOneOutbound() {
         startCriteria.setGlobalIncludes("/a.A.a/");
         stopCriteria.setGlobalIncludes("/c.C.c/");
 
@@ -85,12 +81,13 @@ public void testOneOutbound() {
         
         selector.traverseNodes(factory.getPackages().values());
 
-        assertEquals("packages", 2, selector.getFactory().getPackages().size());
-        assertEquals("classes",  2, selector.getFactory().getClasses().size());
-        assertEquals("features", 2, selector.getFactory().getFeatures().size());
+        assertEquals(2, selector.getFactory().getPackages().size(), "packages");
+        assertEquals(2, selector.getFactory().getClasses().size(), "classes");
+        assertEquals(2, selector.getFactory().getFeatures().size(), "features");
     }
 
-    public void testAllOutbound() {
+    @Test
+    void testAllOutbound() {
         startCriteria.setGlobalIncludes("/a.A.a/");
         stopCriteria.setGlobalIncludes("/c.C.c/");
 
@@ -99,12 +96,13 @@ public void testAllOutbound() {
         
         selector.traverseNodes(factory.getPackages().values());
 
-        assertEquals("packages", factory.getPackages().size(), selector.getFactory().getPackages().size());
-        assertEquals("classes",  factory.getClasses().size(),  selector.getFactory().getClasses().size());
-        assertEquals("features", factory.getFeatures().size(), selector.getFactory().getFeatures().size());
+        assertEquals(factory.getPackages().size(), selector.getFactory().getPackages().size(), "packages");
+        assertEquals(factory.getClasses().size(), selector.getFactory().getClasses().size(), "classes");
+        assertEquals(factory.getFeatures().size(), selector.getFactory().getFeatures().size(), "features");
     }
 
-    public void testZeroInbound() {
+    @Test
+    void testZeroInbound() {
         startCriteria.setGlobalIncludes("/c.C.c/");
         stopCriteria.setGlobalIncludes("/a.A.a/");
 
@@ -113,12 +111,13 @@ public void testZeroInbound() {
         
         selector.traverseNodes(factory.getPackages().values());
 
-        assertEquals("packages", 1, selector.getFactory().getPackages().size());
-        assertEquals("classes",  1, selector.getFactory().getClasses().size());
-        assertEquals("features", 1, selector.getFactory().getFeatures().size());
+        assertEquals(1, selector.getFactory().getPackages().size(), "packages");
+        assertEquals(1, selector.getFactory().getClasses().size(), "classes");
+        assertEquals(1, selector.getFactory().getFeatures().size(), "features");
     }
 
-    public void testOneInbound() {
+    @Test
+    void testOneInbound() {
         startCriteria.setGlobalIncludes("/c.C.c/");
         stopCriteria.setGlobalIncludes("/a.A.a/");
 
@@ -127,12 +126,13 @@ public void testOneInbound() {
         
         selector.traverseNodes(factory.getPackages().values());
 
-        assertEquals("packages", 2, selector.getFactory().getPackages().size());
-        assertEquals("classes",  2, selector.getFactory().getClasses().size());
-        assertEquals("features", 2, selector.getFactory().getFeatures().size());
+        assertEquals(2, selector.getFactory().getPackages().size(), "packages");
+        assertEquals(2, selector.getFactory().getClasses().size(), "classes");
+        assertEquals(2, selector.getFactory().getFeatures().size(), "features");
     }
 
-    public void testAllInbound() {
+    @Test
+    void testAllInbound() {
         startCriteria.setGlobalIncludes("/c.C.c/");
         stopCriteria.setGlobalIncludes("/a.A.a/");
 
@@ -141,12 +141,13 @@ public void testAllInbound() {
         
         selector.traverseNodes(factory.getPackages().values());
 
-        assertEquals("packages", factory.getPackages().size(), selector.getFactory().getPackages().size());
-        assertEquals("classes",  factory.getClasses().size(),  selector.getFactory().getClasses().size());
-        assertEquals("features", factory.getFeatures().size(), selector.getFactory().getFeatures().size());
+        assertEquals(factory.getPackages().size(), selector.getFactory().getPackages().size(), "packages");
+        assertEquals(factory.getClasses().size(), selector.getFactory().getClasses().size(), "classes");
+        assertEquals(factory.getFeatures().size(), selector.getFactory().getFeatures().size(), "features");
     }
 
-    public void testZeroBothDirections() {
+    @Test
+    void testZeroBothDirections() {
         startCriteria.setGlobalIncludes("/b.B.b/");
         stopCriteria.setGlobalIncludes(Collections.emptyList());
 
@@ -155,12 +156,13 @@ public void testZeroBothDirections() {
         
         selector.traverseNodes(factory.getPackages().values());
 
-        assertEquals("packages", 1, selector.getFactory().getPackages().size());
-        assertEquals("classes",  1, selector.getFactory().getClasses().size());
-        assertEquals("features", 1, selector.getFactory().getFeatures().size());
+        assertEquals(1, selector.getFactory().getPackages().size(), "packages");
+        assertEquals(1, selector.getFactory().getClasses().size(), "classes");
+        assertEquals(1, selector.getFactory().getFeatures().size(), "features");
     }
 
-    public void testOneBothDirections() {
+    @Test
+    void testOneBothDirections() {
         startCriteria.setGlobalIncludes("/b.B.b/");
         stopCriteria.setGlobalIncludes(Collections.emptyList());
 
@@ -169,12 +171,13 @@ public void testOneBothDirections() {
         
         selector.traverseNodes(factory.getPackages().values());
 
-        assertEquals("packages", factory.getPackages().size(), selector.getFactory().getPackages().size());
-        assertEquals("classes",  factory.getClasses().size(),  selector.getFactory().getClasses().size());
-        assertEquals("features", factory.getFeatures().size(), selector.getFactory().getFeatures().size());
+        assertEquals(factory.getPackages().size(), selector.getFactory().getPackages().size(), "packages");
+        assertEquals(factory.getClasses().size(), selector.getFactory().getClasses().size(), "classes");
+        assertEquals(factory.getFeatures().size(), selector.getFactory().getFeatures().size(), "features");
     }
 
-    public void testAllBothDirections() {
+    @Test
+    void testAllBothDirections() {
         startCriteria.setGlobalIncludes("/b.B.b/");
         stopCriteria.setGlobalIncludes(Collections.emptyList());
 
@@ -183,8 +186,8 @@ public void testAllBothDirections() {
         
         selector.traverseNodes(factory.getPackages().values());
 
-        assertEquals("packages", factory.getPackages().size(), selector.getFactory().getPackages().size());
-        assertEquals("classes",  factory.getClasses().size(),  selector.getFactory().getClasses().size());
-        assertEquals("features", factory.getFeatures().size(), selector.getFactory().getFeatures().size());
+        assertEquals(factory.getPackages().size(), selector.getFactory().getPackages().size(), "packages");
+        assertEquals(factory.getClasses().size(), selector.getFactory().getClasses().size(), "classes");
+        assertEquals(factory.getFeatures().size(), selector.getFactory().getFeatures().size(), "features");
     }
 }
diff --git a/lib/src/test/java/com/jeantessier/dependency/TestTransitiveClosureEngine.java b/lib/src/test/java/com/jeantessier/dependency/TestTransitiveClosureEngine.java
index b7e2d90a..40add8f3 100644
--- a/lib/src/test/java/com/jeantessier/dependency/TestTransitiveClosureEngine.java
+++ b/lib/src/test/java/com/jeantessier/dependency/TestTransitiveClosureEngine.java
@@ -32,149 +32,139 @@
 
 package com.jeantessier.dependency;
 
-import junit.framework.*;
+import org.junit.jupiter.api.*;
 
-public class TestTransitiveClosureEngine extends TestCase {
-    private NodeFactory factory;
+import static org.junit.jupiter.api.Assertions.*;
 
-    private PackageNode a;
-    private ClassNode   a_A;
-    private FeatureNode a_A_a;
-    
-    private PackageNode b;
-    private ClassNode   b_B;
-    private FeatureNode b_B_b;
-    
-    private PackageNode c;
-    private ClassNode   c_C;
-    private FeatureNode c_C_c;
+public class TestTransitiveClosureEngine {
+    private final NodeFactory factory = new NodeFactory();
 
-    private RegularExpressionSelectionCriteria startCriteria;
-    private RegularExpressionSelectionCriteria stopCriteria;
-    
-    protected void setUp() throws Exception {
-        super.setUp();
-        
-        factory = new NodeFactory();
+    private final Node a = factory.createPackage("a");
+    private final Node a_A = factory.createClass("a.A");
+    private final Node a_A_a = factory.createFeature("a.A.a");
 
-        a     = factory.createPackage("a");
-        a_A   = factory.createClass("a.A");
-        a_A_a = factory.createFeature("a.A.a");
-        
-        b     = factory.createPackage("b");
-        b_B   = factory.createClass("b.B");
-        b_B_b = factory.createFeature("b.B.b");
-        
-        c     = factory.createPackage("c");
-        c_C   = factory.createClass("c.C");
-        c_C_c = factory.createFeature("c.C.c");
+    private final Node b = factory.createPackage("b");
+    private final Node b_B = factory.createClass("b.B");
+    private final Node b_B_b = factory.createFeature("b.B.b");
 
+    private final Node c = factory.createPackage("c");
+    private final Node c_C = factory.createClass("c.C");
+    private final Node c_C_c = factory.createFeature("c.C.c");
+
+    private final RegularExpressionSelectionCriteria startCriteria = new RegularExpressionSelectionCriteria();
+    private final RegularExpressionSelectionCriteria stopCriteria = new RegularExpressionSelectionCriteria();
+    
+    @BeforeEach
+    void setUp() {
         a_A_a.addDependency(b_B_b);
         b_B_b.addDependency(c_C_c);
 
-        startCriteria = new RegularExpressionSelectionCriteria();
-        stopCriteria  = new RegularExpressionSelectionCriteria();
         stopCriteria.setGlobalIncludes("");
     }
 
-    public void testSelectScope() {
+    @Test
+    void testSelectScope() {
         startCriteria.setGlobalIncludes("/a.A.a/");
 
         GraphCopier copier = new GraphCopier(new SelectiveTraversalStrategy(startCriteria, new RegularExpressionSelectionCriteria()));
 
         copier.traverseNodes(factory.getPackages().values());
         
-        assertEquals("packages in scope: " , 1, copier.getScopeFactory().getPackages().values().size());
-        assertEquals("classes in scope"    , 1, copier.getScopeFactory().getClasses().values().size());
-        assertEquals("features in scope"   , 1, copier.getScopeFactory().getFeatures().values().size());
+        assertEquals(1, copier.getScopeFactory().getPackages().size(), "packages in scope: ");
+        assertEquals(1, copier.getScopeFactory().getClasses().size(), "classes in scope");
+        assertEquals(1, copier.getScopeFactory().getFeatures().size(), "features in scope");
 
-        assertEquals("package b in scope"    , a,     copier.getScopeFactory().getPackages().get("a"));
-        assertEquals("class a.A in scope"    , a_A,   copier.getScopeFactory().getClasses().get("a.A"));
-        assertEquals("feature a.A.a in scope", a_A_a, copier.getScopeFactory().getFeatures().get("a.A.a"));
+        assertEquals(a, copier.getScopeFactory().getPackages().get("a"), "package b in scope");
+        assertEquals(a_A, copier.getScopeFactory().getClasses().get("a.A"), "class a.A in scope");
+        assertEquals(a_A_a, copier.getScopeFactory().getFeatures().get("a.A.a"), "feature a.A.a in scope");
     }
 
-    public void testOutboundStartingPoint() {
+    @Test
+    void testOutboundStartingPoint() {
         startCriteria.setGlobalIncludes("/a.A.a/");
 
         var engine = new TransitiveClosureEngine(factory.getPackages().values(), startCriteria, stopCriteria, new ClosureOutboundSelector());
 
-        assertEquals("Nb layers", 1, engine.getNbLayers());
+        assertEquals(1, engine.getNbLayers(), "Nb layers");
 
-        assertEquals("layer 0", 1, engine.getLayer(0).size());
-        assertEquals("a.A.a in layer 0", a_A_a, engine.getLayer(0).iterator().next());
-        assertNotSame("a.A.a in layer 0", a_A_a, engine.getLayer(0).iterator().next());
+        assertEquals(1, engine.getLayer(0).size(), "layer 0");
+        assertEquals(a_A_a, engine.getLayer(0).iterator().next(), "a.A.a in layer 0");
+        assertNotSame(a_A_a, engine.getLayer(0).iterator().next(), "a.A.a in layer 0");
 
-        assertEquals("Nb outbounds from a.A.a", 0, engine.getLayer(0).iterator().next().getOutboundDependencies().size());
+        assertEquals(0, engine.getLayer(0).iterator().next().getOutboundDependencies().size(), "Nb outbounds from a.A.a");
         
-        assertEquals("packages in scope: ", 1, engine.getFactory().getPackages().values().size());
-        assertEquals("classes in scope" ,   1, engine.getFactory().getClasses().values().size());
-        assertEquals("features in scope",   1, engine.getFactory().getFeatures().values().size());
+        assertEquals(1, engine.getFactory().getPackages().size(), "packages in scope: ");
+        assertEquals(1, engine.getFactory().getClasses().size(), "classes in scope");
+        assertEquals(1, engine.getFactory().getFeatures().size(), "features in scope");
 
-        assertEquals("package a in scope",     a,     engine.getFactory().getPackages().get("a"));
-        assertEquals("class a.A in scope",     a_A,   engine.getFactory().getClasses().get("a.A"));
-        assertEquals("feature a.A.a in scope", a_A_a, engine.getFactory().getFeatures().get("a.A.a"));
+        assertEquals(a, engine.getFactory().getPackages().get("a"), "package a in scope");
+        assertEquals(a_A, engine.getFactory().getClasses().get("a.A"), "class a.A in scope");
+        assertEquals(a_A_a, engine.getFactory().getFeatures().get("a.A.a"), "feature a.A.a in scope");
     }
 
-    public void testOneOutboundLayer() {
+    @Test
+    void testOneOutboundLayer() {
         startCriteria.setGlobalIncludes("/a.A.a/");
 
         var engine = new TransitiveClosureEngine(factory.getPackages().values(), startCriteria, stopCriteria, new ClosureOutboundSelector());
         engine.computeNextLayer();
 
-        assertEquals("Nb layers", 2, engine.getNbLayers());
+        assertEquals(2, engine.getNbLayers(), "Nb layers");
 
-        assertEquals("layer 1", 1, engine.getLayer(1).size());
-        assertEquals("b.B.b in layer 1", b_B_b, engine.getLayer(1).iterator().next());
-        assertNotSame("b.B.b in layer 1", b_B_b, engine.getLayer(1).iterator().next());
+        assertEquals(1, engine.getLayer(1).size(), "layer 1");
+        assertEquals(b_B_b, engine.getLayer(1).iterator().next(), "b.B.b in layer 1");
+        assertNotSame(b_B_b, engine.getLayer(1).iterator().next(), "b.B.b in layer 1");
 
-        assertEquals("Nb outbounds from a.A.a", a_A_a.getOutboundDependencies().size(), engine.getLayer(0).iterator().next().getOutboundDependencies().size());
-        assertEquals("Nb outbounds from b.B.b", 0,                       engine.getLayer(1).iterator().next().getOutboundDependencies().size());
+        assertEquals(a_A_a.getOutboundDependencies().size(), engine.getLayer(0).iterator().next().getOutboundDependencies().size(), "Nb outbounds from a.A.a");
+        assertEquals(0, engine.getLayer(1).iterator().next().getOutboundDependencies().size(), "Nb outbounds from b.B.b");
         
-        assertEquals("packages in scope: ", 2, engine.getFactory().getPackages().values().size());
-        assertEquals("classes in scope" ,   2, engine.getFactory().getClasses().values().size());
-        assertEquals("features in scope",   2, engine.getFactory().getFeatures().values().size());
-
-        assertEquals("package a in scope",     a,     engine.getFactory().getPackages().get("a"));
-        assertEquals("class a.A in scope",     a_A,   engine.getFactory().getClasses().get("a.A"));
-        assertEquals("feature a.A.a in scope", a_A_a, engine.getFactory().getFeatures().get("a.A.a"));
-        assertEquals("package b in scope",     b,     engine.getFactory().getPackages().get("b"));
-        assertEquals("class b.B in scope",     b_B,   engine.getFactory().getClasses().get("b.B"));
-        assertEquals("feature b.B.b in scope", b_B_b, engine.getFactory().getFeatures().get("b.B.b"));
+        assertEquals(2, engine.getFactory().getPackages().size(), "packages in scope: ");
+        assertEquals(2, engine.getFactory().getClasses().size(), "classes in scope");
+        assertEquals(2, engine.getFactory().getFeatures().size(), "features in scope");
+
+        assertEquals(a, engine.getFactory().getPackages().get("a"), "package a in scope");
+        assertEquals(a_A, engine.getFactory().getClasses().get("a.A"), "class a.A in scope");
+        assertEquals(a_A_a, engine.getFactory().getFeatures().get("a.A.a"), "feature a.A.a in scope");
+        assertEquals(b, engine.getFactory().getPackages().get("b"), "package b in scope");
+        assertEquals(b_B, engine.getFactory().getClasses().get("b.B"), "class b.B in scope");
+        assertEquals(b_B_b, engine.getFactory().getFeatures().get("b.B.b"), "feature b.B.b in scope");
     }
 
-    public void testTwoOutboundLayers() {
+    @Test
+    void testTwoOutboundLayers() {
         startCriteria.setGlobalIncludes("/a.A.a/");
 
         var engine = new TransitiveClosureEngine(factory.getPackages().values(), startCriteria, stopCriteria, new ClosureOutboundSelector());
         engine.computeNextLayer();
         engine.computeNextLayer();
 
-        assertEquals("Nb layers", 3, engine.getNbLayers());
+        assertEquals(3, engine.getNbLayers(), "Nb layers");
 
-        assertEquals("layer 2", 1, engine.getLayer(1).size());
-        assertEquals("c.C.c in layer 2", c_C_c, engine.getLayer(2).iterator().next());
-        assertNotSame("c.C.c in layer 2", c_C_c, engine.getLayer(2).iterator().next());
+        assertEquals(1, engine.getLayer(1).size(), "layer 2");
+        assertEquals(c_C_c, engine.getLayer(2).iterator().next(), "c.C.c in layer 2");
+        assertNotSame(c_C_c, engine.getLayer(2).iterator().next(), "c.C.c in layer 2");
 
-        assertEquals("Nb outbounds from a.A.a", a_A_a.getOutboundDependencies().size(), engine.getLayer(0).iterator().next().getOutboundDependencies().size());
-        assertEquals("Nb outbounds from b.B.b", b_B_b.getOutboundDependencies().size(), engine.getLayer(1).iterator().next().getOutboundDependencies().size());
-        assertEquals("Nb outbounds from c.C.c", 0,                       engine.getLayer(2).iterator().next().getOutboundDependencies().size());
+        assertEquals(a_A_a.getOutboundDependencies().size(), engine.getLayer(0).iterator().next().getOutboundDependencies().size(), "Nb outbounds from a.A.a");
+        assertEquals(b_B_b.getOutboundDependencies().size(), engine.getLayer(1).iterator().next().getOutboundDependencies().size(), "Nb outbounds from b.B.b");
+        assertEquals(0, engine.getLayer(2).iterator().next().getOutboundDependencies().size(), "Nb outbounds from c.C.c");
         
-        assertEquals("packages in scope: ", 3, engine.getFactory().getPackages().values().size());
-        assertEquals("classes in scope" ,   3, engine.getFactory().getClasses().values().size());
-        assertEquals("features in scope",   3, engine.getFactory().getFeatures().values().size());
-
-        assertEquals("package a in scope",     a,     engine.getFactory().getPackages().get("a"));
-        assertEquals("class a.A in scope",     a_A,   engine.getFactory().getClasses().get("a.A"));
-        assertEquals("feature a.A.a in scope", a_A_a, engine.getFactory().getFeatures().get("a.A.a"));
-        assertEquals("package b in scope",     b,     engine.getFactory().getPackages().get("b"));
-        assertEquals("class b.B in scope",     b_B,   engine.getFactory().getClasses().get("b.B"));
-        assertEquals("feature b.B.b in scope", b_B_b, engine.getFactory().getFeatures().get("b.B.b"));
-        assertEquals("package c in scope",     c,     engine.getFactory().getPackages().get("c"));
-        assertEquals("class c.C in scope",     c_C,   engine.getFactory().getClasses().get("c.C"));
-        assertEquals("feature c.C.c in scope", c_C_c, engine.getFactory().getFeatures().get("c.C.c"));
+        assertEquals(3, engine.getFactory().getPackages().size(), "packages in scope: ");
+        assertEquals(3, engine.getFactory().getClasses().size(), "classes in scope");
+        assertEquals(3, engine.getFactory().getFeatures().size(), "features in scope");
+
+        assertEquals(a, engine.getFactory().getPackages().get("a"), "package a in scope");
+        assertEquals(a_A, engine.getFactory().getClasses().get("a.A"), "class a.A in scope");
+        assertEquals(a_A_a, engine.getFactory().getFeatures().get("a.A.a"), "feature a.A.a in scope");
+        assertEquals(b, engine.getFactory().getPackages().get("b"), "package b in scope");
+        assertEquals(b_B, engine.getFactory().getClasses().get("b.B"), "class b.B in scope");
+        assertEquals(b_B_b, engine.getFactory().getFeatures().get("b.B.b"), "feature b.B.b in scope");
+        assertEquals(c, engine.getFactory().getPackages().get("c"), "package c in scope");
+        assertEquals(c_C, engine.getFactory().getClasses().get("c.C"), "class c.C in scope");
+        assertEquals(c_C_c, engine.getFactory().getFeatures().get("c.C.c"), "feature c.C.c in scope");
     }
 
-    public void testThreeOutboundLayers() {
+    @Test
+    void testThreeOutboundLayers() {
         startCriteria.setGlobalIncludes("/a.A.a/");
 
         var engine = new TransitiveClosureEngine(factory.getPackages().values(), startCriteria, stopCriteria, new ClosureOutboundSelector());
@@ -182,28 +172,29 @@ public void testThreeOutboundLayers() {
         engine.computeNextLayer();
         engine.computeNextLayer();
 
-        assertEquals("Nb layers", 3, engine.getNbLayers());
+        assertEquals(3, engine.getNbLayers(), "Nb layers");
 
-        assertEquals("Nb outbounds from a.A.a", a_A_a.getOutboundDependencies().size(), engine.getLayer(0).iterator().next().getOutboundDependencies().size());
-        assertEquals("Nb outbounds from b.B.b", b_B_b.getOutboundDependencies().size(), engine.getLayer(1).iterator().next().getOutboundDependencies().size());
-        assertEquals("Nb outbounds from c.C.c", c_C_c.getOutboundDependencies().size(), engine.getLayer(2).iterator().next().getOutboundDependencies().size());
+        assertEquals(a_A_a.getOutboundDependencies().size(), engine.getLayer(0).iterator().next().getOutboundDependencies().size(), "Nb outbounds from a.A.a");
+        assertEquals(b_B_b.getOutboundDependencies().size(), engine.getLayer(1).iterator().next().getOutboundDependencies().size(), "Nb outbounds from b.B.b");
+        assertEquals(c_C_c.getOutboundDependencies().size(), engine.getLayer(2).iterator().next().getOutboundDependencies().size(), "Nb outbounds from c.C.c");
         
-        assertEquals("packages in scope: ", 3, engine.getFactory().getPackages().values().size());
-        assertEquals("classes in scope" ,   3, engine.getFactory().getClasses().values().size());
-        assertEquals("features in scope",   3, engine.getFactory().getFeatures().values().size());
-
-        assertEquals("package a in scope",     a,     engine.getFactory().getPackages().get("a"));
-        assertEquals("class a.A in scope",     a_A,   engine.getFactory().getClasses().get("a.A"));
-        assertEquals("feature a.A.a in scope", a_A_a, engine.getFactory().getFeatures().get("a.A.a"));
-        assertEquals("package b in scope",     b,     engine.getFactory().getPackages().get("b"));
-        assertEquals("class b.B in scope",     b_B,   engine.getFactory().getClasses().get("b.B"));
-        assertEquals("feature b.B.b in scope", b_B_b, engine.getFactory().getFeatures().get("b.B.b"));
-        assertEquals("package c in scope",     c,     engine.getFactory().getPackages().get("c"));
-        assertEquals("class c.C in scope",     c_C,   engine.getFactory().getClasses().get("c.C"));
-        assertEquals("feature c.C.c in scope", c_C_c, engine.getFactory().getFeatures().get("c.C.c"));
+        assertEquals(3, engine.getFactory().getPackages().size(), "packages in scope: ");
+        assertEquals(3, engine.getFactory().getClasses().size(), "classes in scope");
+        assertEquals(3, engine.getFactory().getFeatures().size(), "features in scope");
+
+        assertEquals(a, engine.getFactory().getPackages().get("a"), "package a in scope");
+        assertEquals(a_A, engine.getFactory().getClasses().get("a.A"), "class a.A in scope");
+        assertEquals(a_A_a, engine.getFactory().getFeatures().get("a.A.a"), "feature a.A.a in scope");
+        assertEquals(b, engine.getFactory().getPackages().get("b"), "package b in scope");
+        assertEquals(b_B, engine.getFactory().getClasses().get("b.B"), "class b.B in scope");
+        assertEquals(b_B_b, engine.getFactory().getFeatures().get("b.B.b"), "feature b.B.b in scope");
+        assertEquals(c, engine.getFactory().getPackages().get("c"), "package c in scope");
+        assertEquals(c_C, engine.getFactory().getClasses().get("c.C"), "class c.C in scope");
+        assertEquals(c_C_c, engine.getFactory().getFeatures().get("c.C.c"), "feature c.C.c in scope");
     }
 
-    public void testFourOutboundLayers() {
+    @Test
+    void testFourOutboundLayers() {
         startCriteria.setGlobalIncludes("/a.A.a/");
 
         var engine = new TransitiveClosureEngine(factory.getPackages().values(), startCriteria, stopCriteria, new ClosureOutboundSelector());
@@ -212,109 +203,113 @@ public void testFourOutboundLayers() {
         engine.computeNextLayer();
         engine.computeNextLayer();
 
-        assertEquals("Nb layers", 3, engine.getNbLayers());
+        assertEquals(3, engine.getNbLayers(), "Nb layers");
 
-        assertEquals("Nb outbounds from a.A.a", a_A_a.getOutboundDependencies().size(), engine.getLayer(0).iterator().next().getOutboundDependencies().size());
-        assertEquals("Nb outbounds from b.B.b", b_B_b.getOutboundDependencies().size(), engine.getLayer(1).iterator().next().getOutboundDependencies().size());
-        assertEquals("Nb outbounds from c.C.c", c_C_c.getOutboundDependencies().size(), engine.getLayer(2).iterator().next().getOutboundDependencies().size());
+        assertEquals(a_A_a.getOutboundDependencies().size(), engine.getLayer(0).iterator().next().getOutboundDependencies().size(), "Nb outbounds from a.A.a");
+        assertEquals(b_B_b.getOutboundDependencies().size(), engine.getLayer(1).iterator().next().getOutboundDependencies().size(), "Nb outbounds from b.B.b");
+        assertEquals(c_C_c.getOutboundDependencies().size(), engine.getLayer(2).iterator().next().getOutboundDependencies().size(), "Nb outbounds from c.C.c");
         
-        assertEquals("packages in scope: ", 3, engine.getFactory().getPackages().values().size());
-        assertEquals("classes in scope" ,   3, engine.getFactory().getClasses().values().size());
-        assertEquals("features in scope",   3, engine.getFactory().getFeatures().values().size());
-
-        assertEquals("package a in scope",     a,     engine.getFactory().getPackages().get("a"));
-        assertEquals("class a.A in scope",     a_A,   engine.getFactory().getClasses().get("a.A"));
-        assertEquals("feature a.A.a in scope", a_A_a, engine.getFactory().getFeatures().get("a.A.a"));
-        assertEquals("package b in scope",     b,     engine.getFactory().getPackages().get("b"));
-        assertEquals("class b.B in scope",     b_B,   engine.getFactory().getClasses().get("b.B"));
-        assertEquals("feature b.B.b in scope", b_B_b, engine.getFactory().getFeatures().get("b.B.b"));
-        assertEquals("package c in scope",     c,     engine.getFactory().getPackages().get("c"));
-        assertEquals("class c.C in scope",     c_C,   engine.getFactory().getClasses().get("c.C"));
-        assertEquals("feature c.C.c in scope", c_C_c, engine.getFactory().getFeatures().get("c.C.c"));
+        assertEquals(3, engine.getFactory().getPackages().size(), "packages in scope: ");
+        assertEquals(3, engine.getFactory().getClasses().size(), "classes in scope");
+        assertEquals(3, engine.getFactory().getFeatures().size(), "features in scope");
+
+        assertEquals(a, engine.getFactory().getPackages().get("a"), "package a in scope");
+        assertEquals(a_A, engine.getFactory().getClasses().get("a.A"), "class a.A in scope");
+        assertEquals(a_A_a, engine.getFactory().getFeatures().get("a.A.a"), "feature a.A.a in scope");
+        assertEquals(b, engine.getFactory().getPackages().get("b"), "package b in scope");
+        assertEquals(b_B, engine.getFactory().getClasses().get("b.B"), "class b.B in scope");
+        assertEquals(b_B_b, engine.getFactory().getFeatures().get("b.B.b"), "feature b.B.b in scope");
+        assertEquals(c, engine.getFactory().getPackages().get("c"), "package c in scope");
+        assertEquals(c_C, engine.getFactory().getClasses().get("c.C"), "class c.C in scope");
+        assertEquals(c_C_c, engine.getFactory().getFeatures().get("c.C.c"), "feature c.C.c in scope");
     }
 
-    public void testInboundStartingPoint() {
+    @Test
+    void testInboundStartingPoint() {
         startCriteria.setGlobalIncludes("/c.C.c/");
 
         var engine = new TransitiveClosureEngine(factory.getPackages().values(), startCriteria, stopCriteria, new ClosureInboundSelector());
 
-        assertEquals("Nb layers", 1, engine.getNbLayers());
+        assertEquals(1, engine.getNbLayers(), "Nb layers");
 
-        assertEquals("layer 0", 1, engine.getLayer(0).size());
-        assertEquals("c.C.c in layer 0", c_C_c, engine.getLayer(0).iterator().next());
-        assertNotSame("c.C.c in layer 0", c_C_c, engine.getLayer(0).iterator().next());
+        assertEquals(1, engine.getLayer(0).size(), "layer 0");
+        assertEquals(c_C_c, engine.getLayer(0).iterator().next(), "c.C.c in layer 0");
+        assertNotSame(c_C_c, engine.getLayer(0).iterator().next(), "c.C.c in layer 0");
 
-        assertEquals("Nb inbounds from c.C.c", 0, engine.getLayer(0).iterator().next().getInboundDependencies().size());
+        assertEquals(0, engine.getLayer(0).iterator().next().getInboundDependencies().size(), "Nb inbounds from c.C.c");
         
-        assertEquals("packages in scope: ", 1, engine.getFactory().getPackages().values().size());
-        assertEquals("classes in scope" ,   1, engine.getFactory().getClasses().values().size());
-        assertEquals("features in scope",   1, engine.getFactory().getFeatures().values().size());
+        assertEquals(1, engine.getFactory().getPackages().size(), "packages in scope: ");
+        assertEquals(1, engine.getFactory().getClasses().size(), "classes in scope");
+        assertEquals(1, engine.getFactory().getFeatures().size(), "features in scope");
 
-        assertEquals("package c in scope",     c,     engine.getFactory().getPackages().get("c"));
-        assertEquals("class c.C in scope",     c_C,   engine.getFactory().getClasses().get("c.C"));
-        assertEquals("feature c.C.c in scope", c_C_c, engine.getFactory().getFeatures().get("c.C.c"));
+        assertEquals(c, engine.getFactory().getPackages().get("c"), "package c in scope");
+        assertEquals(c_C, engine.getFactory().getClasses().get("c.C"), "class c.C in scope");
+        assertEquals(c_C_c, engine.getFactory().getFeatures().get("c.C.c"), "feature c.C.c in scope");
     }
 
-    public void testOneInboundLayer() {
+    @Test
+    void testOneInboundLayer() {
         startCriteria.setGlobalIncludes("/c.C.c/");
 
         var engine = new TransitiveClosureEngine(factory.getPackages().values(), startCriteria, stopCriteria, new ClosureInboundSelector());
         engine.computeNextLayer();
 
-        assertEquals("Nb layers", 2, engine.getNbLayers());
+        assertEquals(2, engine.getNbLayers(), "Nb layers");
 
-        assertEquals("layer 1", 1, engine.getLayer(1).size());
-        assertEquals("b.B.b in layer 1", b_B_b, engine.getLayer(1).iterator().next());
-        assertNotSame("b.B.b in layer 1", b_B_b, engine.getLayer(1).iterator().next());
+        assertEquals(1, engine.getLayer(1).size(), "layer 1");
+        assertEquals(b_B_b, engine.getLayer(1).iterator().next(), "b.B.b in layer 1");
+        assertNotSame(b_B_b, engine.getLayer(1).iterator().next(), "b.B.b in layer 1");
 
-        assertEquals("Nb inbounds from c.C.c", c_C_c.getInboundDependencies().size(), engine.getLayer(0).iterator().next().getInboundDependencies().size());
-        assertEquals("Nb inbounds from b.B.b", 0,                      engine.getLayer(1).iterator().next().getInboundDependencies().size());
+        assertEquals(c_C_c.getInboundDependencies().size(), engine.getLayer(0).iterator().next().getInboundDependencies().size(), "Nb inbounds from c.C.c");
+        assertEquals(0, engine.getLayer(1).iterator().next().getInboundDependencies().size(), "Nb inbounds from b.B.b");
         
-        assertEquals("packages in scope: ", 2, engine.getFactory().getPackages().values().size());
-        assertEquals("classes in scope" ,   2, engine.getFactory().getClasses().values().size());
-        assertEquals("features in scope",   2, engine.getFactory().getFeatures().values().size());
-
-        assertEquals("package b in scope",     b,     engine.getFactory().getPackages().get("b"));
-        assertEquals("class b.B in scope",     b_B,   engine.getFactory().getClasses().get("b.B"));
-        assertEquals("feature b.B.b in scope", b_B_b, engine.getFactory().getFeatures().get("b.B.b"));
-        assertEquals("package c in scope",     c,     engine.getFactory().getPackages().get("c"));
-        assertEquals("class c.C in scope",     c_C,   engine.getFactory().getClasses().get("c.C"));
-        assertEquals("feature c.C.c in scope", c_C_c, engine.getFactory().getFeatures().get("c.C.c"));
+        assertEquals(2, engine.getFactory().getPackages().size(), "packages in scope: ");
+        assertEquals(2, engine.getFactory().getClasses().size(), "classes in scope");
+        assertEquals(2, engine.getFactory().getFeatures().size(), "features in scope");
+
+        assertEquals(b, engine.getFactory().getPackages().get("b"), "package b in scope");
+        assertEquals(b_B, engine.getFactory().getClasses().get("b.B"), "class b.B in scope");
+        assertEquals(b_B_b, engine.getFactory().getFeatures().get("b.B.b"), "feature b.B.b in scope");
+        assertEquals(c, engine.getFactory().getPackages().get("c"), "package c in scope");
+        assertEquals(c_C, engine.getFactory().getClasses().get("c.C"), "class c.C in scope");
+        assertEquals(c_C_c, engine.getFactory().getFeatures().get("c.C.c"), "feature c.C.c in scope");
     }
 
-    public void testTwoInboundLayers() {
+    @Test
+    void testTwoInboundLayers() {
         startCriteria.setGlobalIncludes("/c.C.c/");
 
         var engine = new TransitiveClosureEngine(factory.getPackages().values(), startCriteria, stopCriteria, new ClosureInboundSelector());
         engine.computeNextLayer();
         engine.computeNextLayer();
 
-        assertEquals("Nb layers", 3, engine.getNbLayers());
+        assertEquals(3, engine.getNbLayers(), "Nb layers");
 
-        assertEquals("layer 2", 1, engine.getLayer(1).size());
-        assertEquals("a.A.a in layer 2", a_A_a, engine.getLayer(2).iterator().next());
-        assertNotSame("a.A.a in layer 2", a_A_a, engine.getLayer(2).iterator().next());
+        assertEquals(1, engine.getLayer(1).size(), "layer 2");
+        assertEquals(a_A_a, engine.getLayer(2).iterator().next(), "a.A.a in layer 2");
+        assertNotSame(a_A_a, engine.getLayer(2).iterator().next(), "a.A.a in layer 2");
 
-        assertEquals("Nb inbounds from c.C.c", c_C_c.getInboundDependencies().size(), engine.getLayer(0).iterator().next().getInboundDependencies().size());
-        assertEquals("Nb inbounds from b.B.b", b_B_b.getInboundDependencies().size(), engine.getLayer(1).iterator().next().getInboundDependencies().size());
-        assertEquals("Nb inbounds from a.A.a", 0,                      engine.getLayer(2).iterator().next().getInboundDependencies().size());
+        assertEquals(c_C_c.getInboundDependencies().size(), engine.getLayer(0).iterator().next().getInboundDependencies().size(), "Nb inbounds from c.C.c");
+        assertEquals(b_B_b.getInboundDependencies().size(), engine.getLayer(1).iterator().next().getInboundDependencies().size(), "Nb inbounds from b.B.b");
+        assertEquals(0, engine.getLayer(2).iterator().next().getInboundDependencies().size(), "Nb inbounds from a.A.a");
         
-        assertEquals("packages in scope: ", 3, engine.getFactory().getPackages().values().size());
-        assertEquals("classes in scope" ,   3, engine.getFactory().getClasses().values().size());
-        assertEquals("features in scope",   3, engine.getFactory().getFeatures().values().size());
-
-        assertEquals("package a in scope",     a,     engine.getFactory().getPackages().get("a"));
-        assertEquals("class a.A in scope",     a_A,   engine.getFactory().getClasses().get("a.A"));
-        assertEquals("feature a.A.a in scope", a_A_a, engine.getFactory().getFeatures().get("a.A.a"));
-        assertEquals("package b in scope",     b,     engine.getFactory().getPackages().get("b"));
-        assertEquals("class b.B in scope",     b_B,   engine.getFactory().getClasses().get("b.B"));
-        assertEquals("feature b.B.b in scope", b_B_b, engine.getFactory().getFeatures().get("b.B.b"));
-        assertEquals("package c in scope",     c,     engine.getFactory().getPackages().get("c"));
-        assertEquals("class c.C in scope",     c_C,   engine.getFactory().getClasses().get("c.C"));
-        assertEquals("feature c.C.c in scope", c_C_c, engine.getFactory().getFeatures().get("c.C.c"));
+        assertEquals(3, engine.getFactory().getPackages().size(), "packages in scope: ");
+        assertEquals(3, engine.getFactory().getClasses().size(), "classes in scope");
+        assertEquals(3, engine.getFactory().getFeatures().size(), "features in scope");
+
+        assertEquals(a, engine.getFactory().getPackages().get("a"), "package a in scope");
+        assertEquals(a_A, engine.getFactory().getClasses().get("a.A"), "class a.A in scope");
+        assertEquals(a_A_a, engine.getFactory().getFeatures().get("a.A.a"), "feature a.A.a in scope");
+        assertEquals(b, engine.getFactory().getPackages().get("b"), "package b in scope");
+        assertEquals(b_B, engine.getFactory().getClasses().get("b.B"), "class b.B in scope");
+        assertEquals(b_B_b, engine.getFactory().getFeatures().get("b.B.b"), "feature b.B.b in scope");
+        assertEquals(c, engine.getFactory().getPackages().get("c"), "package c in scope");
+        assertEquals(c_C, engine.getFactory().getClasses().get("c.C"), "class c.C in scope");
+        assertEquals(c_C_c, engine.getFactory().getFeatures().get("c.C.c"), "feature c.C.c in scope");
     }
 
-    public void testThreeInboundLayers() {
+    @Test
+    void testThreeInboundLayers() {
         startCriteria.setGlobalIncludes("/c.C.c/");
 
         var engine = new TransitiveClosureEngine(factory.getPackages().values(), startCriteria, stopCriteria, new ClosureInboundSelector());
@@ -322,28 +317,29 @@ public void testThreeInboundLayers() {
         engine.computeNextLayer();
         engine.computeNextLayer();
 
-        assertEquals("Nb layers", 3, engine.getNbLayers());
+        assertEquals(3, engine.getNbLayers(), "Nb layers");
 
-        assertEquals("Nb inbounds from c.C.c", c_C_c.getInboundDependencies().size(), engine.getLayer(0).iterator().next().getInboundDependencies().size());
-        assertEquals("Nb inbounds from b.B.b", b_B_b.getInboundDependencies().size(), engine.getLayer(1).iterator().next().getInboundDependencies().size());
-        assertEquals("Nb inbounds from a.A.a", a_A_a.getInboundDependencies().size(), engine.getLayer(2).iterator().next().getInboundDependencies().size());
+        assertEquals(c_C_c.getInboundDependencies().size(), engine.getLayer(0).iterator().next().getInboundDependencies().size(), "Nb inbounds from c.C.c");
+        assertEquals(b_B_b.getInboundDependencies().size(), engine.getLayer(1).iterator().next().getInboundDependencies().size(), "Nb inbounds from b.B.b");
+        assertEquals(a_A_a.getInboundDependencies().size(), engine.getLayer(2).iterator().next().getInboundDependencies().size(), "Nb inbounds from a.A.a");
         
-        assertEquals("packages in scope: ", 3, engine.getFactory().getPackages().values().size());
-        assertEquals("classes in scope" ,   3, engine.getFactory().getClasses().values().size());
-        assertEquals("features in scope",   3, engine.getFactory().getFeatures().values().size());
-
-        assertEquals("package a in scope",     a,     engine.getFactory().getPackages().get("a"));
-        assertEquals("class a.A in scope",     a_A,   engine.getFactory().getClasses().get("a.A"));
-        assertEquals("feature a.A.a in scope", a_A_a, engine.getFactory().getFeatures().get("a.A.a"));
-        assertEquals("package b in scope",     b,     engine.getFactory().getPackages().get("b"));
-        assertEquals("class b.B in scope",     b_B,   engine.getFactory().getClasses().get("b.B"));
-        assertEquals("feature b.B.b in scope", b_B_b, engine.getFactory().getFeatures().get("b.B.b"));
-        assertEquals("package c in scope",     c,     engine.getFactory().getPackages().get("c"));
-        assertEquals("class c.C in scope",     c_C,   engine.getFactory().getClasses().get("c.C"));
-        assertEquals("feature c.C.c in scope", c_C_c, engine.getFactory().getFeatures().get("c.C.c"));
+        assertEquals(3, engine.getFactory().getPackages().size(), "packages in scope: ");
+        assertEquals(3, engine.getFactory().getClasses().size(), "classes in scope");
+        assertEquals(3, engine.getFactory().getFeatures().size(), "features in scope");
+
+        assertEquals(a, engine.getFactory().getPackages().get("a"), "package a in scope");
+        assertEquals(a_A, engine.getFactory().getClasses().get("a.A"), "class a.A in scope");
+        assertEquals(a_A_a, engine.getFactory().getFeatures().get("a.A.a"), "feature a.A.a in scope");
+        assertEquals(b, engine.getFactory().getPackages().get("b"), "package b in scope");
+        assertEquals(b_B, engine.getFactory().getClasses().get("b.B"), "class b.B in scope");
+        assertEquals(b_B_b, engine.getFactory().getFeatures().get("b.B.b"), "feature b.B.b in scope");
+        assertEquals(c, engine.getFactory().getPackages().get("c"), "package c in scope");
+        assertEquals(c_C, engine.getFactory().getClasses().get("c.C"), "class c.C in scope");
+        assertEquals(c_C_c, engine.getFactory().getFeatures().get("c.C.c"), "feature c.C.c in scope");
     }
 
-    public void testFourInboundLayers() {
+    @Test
+    void testFourInboundLayers() {
         startCriteria.setGlobalIncludes("/c.C.c/");
 
         var engine = new TransitiveClosureEngine(factory.getPackages().values(), startCriteria, stopCriteria, new ClosureInboundSelector());
@@ -352,28 +348,29 @@ public void testFourInboundLayers() {
         engine.computeNextLayer();
         engine.computeNextLayer();
 
-        assertEquals("Nb layers", 3, engine.getNbLayers());
+        assertEquals(3, engine.getNbLayers(), "Nb layers");
 
-        assertEquals("Nb inbounds from c.C.c", c_C_c.getInboundDependencies().size(), engine.getLayer(0).iterator().next().getInboundDependencies().size());
-        assertEquals("Nb inbounds from b.B.b", b_B_b.getInboundDependencies().size(), engine.getLayer(1).iterator().next().getInboundDependencies().size());
-        assertEquals("Nb inbounds from a.A.a", a_A_a.getInboundDependencies().size(), engine.getLayer(2).iterator().next().getInboundDependencies().size());
+        assertEquals(c_C_c.getInboundDependencies().size(), engine.getLayer(0).iterator().next().getInboundDependencies().size(), "Nb inbounds from c.C.c");
+        assertEquals(b_B_b.getInboundDependencies().size(), engine.getLayer(1).iterator().next().getInboundDependencies().size(), "Nb inbounds from b.B.b");
+        assertEquals(a_A_a.getInboundDependencies().size(), engine.getLayer(2).iterator().next().getInboundDependencies().size(), "Nb inbounds from a.A.a");
         
-        assertEquals("packages in scope: ", 3, engine.getFactory().getPackages().values().size());
-        assertEquals("classes in scope" ,   3, engine.getFactory().getClasses().values().size());
-        assertEquals("features in scope",   3, engine.getFactory().getFeatures().values().size());
-
-        assertEquals("package a in scope",     a,     engine.getFactory().getPackages().get("a"));
-        assertEquals("class a.A in scope",     a_A,   engine.getFactory().getClasses().get("a.A"));
-        assertEquals("feature a.A.a in scope", a_A_a, engine.getFactory().getFeatures().get("a.A.a"));
-        assertEquals("package b in scope",     b,     engine.getFactory().getPackages().get("b"));
-        assertEquals("class b.B in scope",     b_B,   engine.getFactory().getClasses().get("b.B"));
-        assertEquals("feature b.B.b in scope", b_B_b, engine.getFactory().getFeatures().get("b.B.b"));
-        assertEquals("package c in scope",     c,     engine.getFactory().getPackages().get("c"));
-        assertEquals("class c.C in scope",     c_C,   engine.getFactory().getClasses().get("c.C"));
-        assertEquals("feature c.C.c in scope", c_C_c, engine.getFactory().getFeatures().get("c.C.c"));
+        assertEquals(3, engine.getFactory().getPackages().size(), "packages in scope: ");
+        assertEquals(3, engine.getFactory().getClasses().size(), "classes in scope");
+        assertEquals(3, engine.getFactory().getFeatures().size(), "features in scope");
+
+        assertEquals(a, engine.getFactory().getPackages().get("a"), "package a in scope");
+        assertEquals(a_A, engine.getFactory().getClasses().get("a.A"), "class a.A in scope");
+        assertEquals(a_A_a, engine.getFactory().getFeatures().get("a.A.a"), "feature a.A.a in scope");
+        assertEquals(b, engine.getFactory().getPackages().get("b"), "package b in scope");
+        assertEquals(b_B, engine.getFactory().getClasses().get("b.B"), "class b.B in scope");
+        assertEquals(b_B_b, engine.getFactory().getFeatures().get("b.B.b"), "feature b.B.b in scope");
+        assertEquals(c, engine.getFactory().getPackages().get("c"), "package c in scope");
+        assertEquals(c_C, engine.getFactory().getClasses().get("c.C"), "class c.C in scope");
+        assertEquals(c_C_c, engine.getFactory().getFeatures().get("c.C.c"), "feature c.C.c in scope");
     }
 
-    public void testStopCriteria() {
+    @Test
+    void testStopCriteria() {
         startCriteria.setGlobalIncludes("/c.C.c/");
         stopCriteria.setGlobalIncludes("/b.B.b/");
 
@@ -383,217 +380,224 @@ public void testStopCriteria() {
         engine.computeNextLayer();
         engine.computeNextLayer();
 
-        assertEquals("Nb layers", 2, engine.getNbLayers());
+        assertEquals(2, engine.getNbLayers(), "Nb layers");
 
-        assertEquals("Nb inbounds from c.C.c", c_C_c.getInboundDependencies().size(), engine.getLayer(0).iterator().next().getInboundDependencies().size());
-        assertEquals("Nb inbounds from b.B.b", 0,                      engine.getLayer(1).iterator().next().getInboundDependencies().size());
+        assertEquals(c_C_c.getInboundDependencies().size(), engine.getLayer(0).iterator().next().getInboundDependencies().size(), "Nb inbounds from c.C.c");
+        assertEquals(0, engine.getLayer(1).iterator().next().getInboundDependencies().size(), "Nb inbounds from b.B.b");
         
-        assertEquals("packages in scope: ", 2, engine.getFactory().getPackages().values().size());
-        assertEquals("classes in scope" ,   2, engine.getFactory().getClasses().values().size());
-        assertEquals("features in scope",   2, engine.getFactory().getFeatures().values().size());
-
-        assertEquals("package b in scope",     b,     engine.getFactory().getPackages().get("b"));
-        assertEquals("class b.B in scope",     b_B,   engine.getFactory().getClasses().get("b.B"));
-        assertEquals("feature b.B.b in scope", b_B_b, engine.getFactory().getFeatures().get("b.B.b"));
-        assertEquals("package c in scope",     c,     engine.getFactory().getPackages().get("c"));
-        assertEquals("class c.C in scope",     c_C,   engine.getFactory().getClasses().get("c.C"));
-        assertEquals("feature c.C.c in scope", c_C_c, engine.getFactory().getFeatures().get("c.C.c"));
+        assertEquals(2, engine.getFactory().getPackages().size(), "packages in scope: ");
+        assertEquals(2, engine.getFactory().getClasses().size(), "classes in scope");
+        assertEquals(2, engine.getFactory().getFeatures().size(), "features in scope");
+
+        assertEquals(b, engine.getFactory().getPackages().get("b"), "package b in scope");
+        assertEquals(b_B, engine.getFactory().getClasses().get("b.B"), "class b.B in scope");
+        assertEquals(b_B_b, engine.getFactory().getFeatures().get("b.B.b"), "feature b.B.b in scope");
+        assertEquals(c, engine.getFactory().getPackages().get("c"), "package c in scope");
+        assertEquals(c_C, engine.getFactory().getClasses().get("c.C"), "class c.C in scope");
+        assertEquals(c_C_c, engine.getFactory().getFeatures().get("c.C.c"), "feature c.C.c in scope");
     }
 
-    public void testComputeAllLayers() {
+    @Test
+    void testComputeAllLayers() {
         startCriteria.setGlobalIncludes("/c.C.c/");
 
         var engine = new TransitiveClosureEngine(factory.getPackages().values(), startCriteria, stopCriteria, new ClosureInboundSelector());
         engine.computeAllLayers();
 
-        assertEquals("Nb layers", 3, engine.getNbLayers());
+        assertEquals(3, engine.getNbLayers(), "Nb layers");
 
-        assertEquals("Nb inbounds from c.C.c", c_C_c.getInboundDependencies().size(), engine.getLayer(0).iterator().next().getInboundDependencies().size());
-        assertEquals("Nb inbounds from b.B.b", b_B_b.getInboundDependencies().size(), engine.getLayer(1).iterator().next().getInboundDependencies().size());
-        assertEquals("Nb inbounds from a.A.a", a_A_a.getInboundDependencies().size(), engine.getLayer(2).iterator().next().getInboundDependencies().size());
+        assertEquals(c_C_c.getInboundDependencies().size(), engine.getLayer(0).iterator().next().getInboundDependencies().size(), "Nb inbounds from c.C.c");
+        assertEquals(b_B_b.getInboundDependencies().size(), engine.getLayer(1).iterator().next().getInboundDependencies().size(), "Nb inbounds from b.B.b");
+        assertEquals(a_A_a.getInboundDependencies().size(), engine.getLayer(2).iterator().next().getInboundDependencies().size(), "Nb inbounds from a.A.a");
         
-        assertEquals("packages in scope: ", 3, engine.getFactory().getPackages().values().size());
-        assertEquals("classes in scope" ,   3, engine.getFactory().getClasses().values().size());
-        assertEquals("features in scope",   3, engine.getFactory().getFeatures().values().size());
-
-        assertEquals("package a in scope",     a,     engine.getFactory().getPackages().get("a"));
-        assertEquals("class a.A in scope",     a_A,   engine.getFactory().getClasses().get("a.A"));
-        assertEquals("feature a.A.a in scope", a_A_a, engine.getFactory().getFeatures().get("a.A.a"));
-        assertEquals("package b in scope",     b,     engine.getFactory().getPackages().get("b"));
-        assertEquals("class b.B in scope",     b_B,   engine.getFactory().getClasses().get("b.B"));
-        assertEquals("feature b.B.b in scope", b_B_b, engine.getFactory().getFeatures().get("b.B.b"));
-        assertEquals("package c in scope",     c,     engine.getFactory().getPackages().get("c"));
-        assertEquals("class c.C in scope",     c_C,   engine.getFactory().getClasses().get("c.C"));
-        assertEquals("feature c.C.c in scope", c_C_c, engine.getFactory().getFeatures().get("c.C.c"));
+        assertEquals(3, engine.getFactory().getPackages().size(), "packages in scope: ");
+        assertEquals(3, engine.getFactory().getClasses().size(), "classes in scope");
+        assertEquals(3, engine.getFactory().getFeatures().size(), "features in scope");
+
+        assertEquals(a, engine.getFactory().getPackages().get("a"), "package a in scope");
+        assertEquals(a_A, engine.getFactory().getClasses().get("a.A"), "class a.A in scope");
+        assertEquals(a_A_a, engine.getFactory().getFeatures().get("a.A.a"), "feature a.A.a in scope");
+        assertEquals(b, engine.getFactory().getPackages().get("b"), "package b in scope");
+        assertEquals(b_B, engine.getFactory().getClasses().get("b.B"), "class b.B in scope");
+        assertEquals(b_B_b, engine.getFactory().getFeatures().get("b.B.b"), "feature b.B.b in scope");
+        assertEquals(c, engine.getFactory().getPackages().get("c"), "package c in scope");
+        assertEquals(c_C, engine.getFactory().getClasses().get("c.C"), "class c.C in scope");
+        assertEquals(c_C_c, engine.getFactory().getFeatures().get("c.C.c"), "feature c.C.c in scope");
     }
 
-    public void testComputeAllLayersWithStopCriteria() {
+    @Test
+    void testComputeAllLayersWithStopCriteria() {
         startCriteria.setGlobalIncludes("/c.C.c/");
         stopCriteria.setGlobalIncludes("/b.B.b/");
 
         var engine = new TransitiveClosureEngine(factory.getPackages().values(), startCriteria, stopCriteria, new ClosureInboundSelector());
         engine.computeAllLayers();
 
-        assertEquals("Nb layers", 2, engine.getNbLayers());
+        assertEquals(2, engine.getNbLayers(), "Nb layers");
 
-        assertEquals("Nb inbounds from c.C.c", c_C_c.getInboundDependencies().size(), engine.getLayer(0).iterator().next().getInboundDependencies().size());
-        assertEquals("Nb inbounds from b.B.b", 0,                      engine.getLayer(1).iterator().next().getInboundDependencies().size());
+        assertEquals(c_C_c.getInboundDependencies().size(), engine.getLayer(0).iterator().next().getInboundDependencies().size(), "Nb inbounds from c.C.c");
+        assertEquals(0, engine.getLayer(1).iterator().next().getInboundDependencies().size(), "Nb inbounds from b.B.b");
         
-        assertEquals("packages in scope: ", 2, engine.getFactory().getPackages().values().size());
-        assertEquals("classes in scope" ,   2, engine.getFactory().getClasses().values().size());
-        assertEquals("features in scope",   2, engine.getFactory().getFeatures().values().size());
-
-        assertEquals("package b in scope",     b,     engine.getFactory().getPackages().get("b"));
-        assertEquals("class b.B in scope",     b_B,   engine.getFactory().getClasses().get("b.B"));
-        assertEquals("feature b.B.b in scope", b_B_b, engine.getFactory().getFeatures().get("b.B.b"));
-        assertEquals("package c in scope",     c,     engine.getFactory().getPackages().get("c"));
-        assertEquals("class c.C in scope",     c_C,   engine.getFactory().getClasses().get("c.C"));
-        assertEquals("feature c.C.c in scope", c_C_c, engine.getFactory().getFeatures().get("c.C.c"));
+        assertEquals(2, engine.getFactory().getPackages().size(), "packages in scope: ");
+        assertEquals(2, engine.getFactory().getClasses().size(), "classes in scope");
+        assertEquals(2, engine.getFactory().getFeatures().size(), "features in scope");
+
+        assertEquals(b, engine.getFactory().getPackages().get("b"), "package b in scope");
+        assertEquals(b_B, engine.getFactory().getClasses().get("b.B"), "class b.B in scope");
+        assertEquals(b_B_b, engine.getFactory().getFeatures().get("b.B.b"), "feature b.B.b in scope");
+        assertEquals(c, engine.getFactory().getPackages().get("c"), "package c in scope");
+        assertEquals(c_C, engine.getFactory().getClasses().get("c.C"), "class c.C in scope");
+        assertEquals(c_C_c, engine.getFactory().getFeatures().get("c.C.c"), "feature c.C.c in scope");
     }
 
-    public void testComputeAllLayersUntilStartCriteria() {
+    @Test
+    void testComputeAllLayersUntilStartCriteria() {
         startCriteria.setGlobalIncludes("/c.C.c/");
         stopCriteria.setGlobalIncludes("//");
 
         var engine = new TransitiveClosureEngine(factory.getPackages().values(), startCriteria, stopCriteria, new ClosureInboundSelector());
         engine.computeAllLayers();
 
-        assertEquals("Nb layers", 1, engine.getNbLayers());
+        assertEquals(1, engine.getNbLayers(), "Nb layers");
 
-        assertEquals("Nb inbounds from c.C.c", 0, engine.getLayer(0).iterator().next().getInboundDependencies().size());
+        assertEquals(0, engine.getLayer(0).iterator().next().getInboundDependencies().size(), "Nb inbounds from c.C.c");
         
-        assertEquals("packages in scope: ", 1, engine.getFactory().getPackages().values().size());
-        assertEquals("classes in scope" ,   1, engine.getFactory().getClasses().values().size());
-        assertEquals("features in scope",   1, engine.getFactory().getFeatures().values().size());
+        assertEquals(1, engine.getFactory().getPackages().size(), "packages in scope: ");
+        assertEquals(1, engine.getFactory().getClasses().size(), "classes in scope");
+        assertEquals(1, engine.getFactory().getFeatures().size(), "features in scope");
 
-        assertEquals("package c in scope",     c,     engine.getFactory().getPackages().get("c"));
-        assertEquals("class c.C in scope",     c_C,   engine.getFactory().getClasses().get("c.C"));
-        assertEquals("feature c.C.c in scope", c_C_c, engine.getFactory().getFeatures().get("c.C.c"));
+        assertEquals(c, engine.getFactory().getPackages().get("c"), "package c in scope");
+        assertEquals(c_C, engine.getFactory().getClasses().get("c.C"), "class c.C in scope");
+        assertEquals(c_C_c, engine.getFactory().getFeatures().get("c.C.c"), "feature c.C.c in scope");
     }
 
-    public void testCompute1LayerOnly() {
+    @Test
+    void testCompute1LayerOnly() {
         startCriteria.setGlobalIncludes("/c.C.c/");
         stopCriteria.setGlobalIncludes("");
 
         var engine = new TransitiveClosureEngine(factory.getPackages().values(), startCriteria, stopCriteria, new ClosureInboundSelector());
         engine.computeLayers(1);
 
-        assertEquals("Nb layers", 2, engine.getNbLayers());
+        assertEquals(2, engine.getNbLayers(), "Nb layers");
 
-        assertEquals("Nb inbounds from c.C.c", c_C_c.getInboundDependencies().size(), engine.getLayer(0).iterator().next().getInboundDependencies().size());
-        assertEquals("Nb inbounds from b.B.b", 0,                      engine.getLayer(1).iterator().next().getInboundDependencies().size());
+        assertEquals(c_C_c.getInboundDependencies().size(), engine.getLayer(0).iterator().next().getInboundDependencies().size(), "Nb inbounds from c.C.c");
+        assertEquals(0, engine.getLayer(1).iterator().next().getInboundDependencies().size(), "Nb inbounds from b.B.b");
         
-        assertEquals("packages in scope: ", 2, engine.getFactory().getPackages().values().size());
-        assertEquals("classes in scope" ,   2, engine.getFactory().getClasses().values().size());
-        assertEquals("features in scope",   2, engine.getFactory().getFeatures().values().size());
-
-        assertEquals("package b in scope",     b,     engine.getFactory().getPackages().get("b"));
-        assertEquals("class b.B in scope",     b_B,   engine.getFactory().getClasses().get("b.B"));
-        assertEquals("feature b.B.b in scope", b_B_b, engine.getFactory().getFeatures().get("b.B.b"));
-        assertEquals("package c in scope",     c,     engine.getFactory().getPackages().get("c"));
-        assertEquals("class c.C in scope",     c_C,   engine.getFactory().getClasses().get("c.C"));
-        assertEquals("feature c.C.c in scope", c_C_c, engine.getFactory().getFeatures().get("c.C.c"));
+        assertEquals(2, engine.getFactory().getPackages().size(), "packages in scope: ");
+        assertEquals(2, engine.getFactory().getClasses().size(), "classes in scope");
+        assertEquals(2, engine.getFactory().getFeatures().size(), "features in scope");
+
+        assertEquals(b, engine.getFactory().getPackages().get("b"), "package b in scope");
+        assertEquals(b_B, engine.getFactory().getClasses().get("b.B"), "class b.B in scope");
+        assertEquals(b_B_b, engine.getFactory().getFeatures().get("b.B.b"), "feature b.B.b in scope");
+        assertEquals(c, engine.getFactory().getPackages().get("c"), "package c in scope");
+        assertEquals(c_C, engine.getFactory().getClasses().get("c.C"), "class c.C in scope");
+        assertEquals(c_C_c, engine.getFactory().getFeatures().get("c.C.c"), "feature c.C.c in scope");
     }
 
-    public void testCompute4LayersWithStopCriteria() {
+    @Test
+    void testCompute4LayersWithStopCriteria() {
         startCriteria.setGlobalIncludes("/c.C.c/");
         stopCriteria.setGlobalIncludes("/b.B.b/");
 
         var engine = new TransitiveClosureEngine(factory.getPackages().values(), startCriteria, stopCriteria, new ClosureInboundSelector());
         engine.computeLayers(4);
 
-        assertEquals("Nb layers", 2, engine.getNbLayers());
+        assertEquals(2, engine.getNbLayers(), "Nb layers");
 
-        assertEquals("Nb inbounds from c.C.c", c_C_c.getInboundDependencies().size(), engine.getLayer(0).iterator().next().getInboundDependencies().size());
-        assertEquals("Nb inbounds from b.B.b", 0,                      engine.getLayer(1).iterator().next().getInboundDependencies().size());
+        assertEquals(c_C_c.getInboundDependencies().size(), engine.getLayer(0).iterator().next().getInboundDependencies().size(), "Nb inbounds from c.C.c");
+        assertEquals(0, engine.getLayer(1).iterator().next().getInboundDependencies().size(), "Nb inbounds from b.B.b");
         
-        assertEquals("packages in scope: ", 2, engine.getFactory().getPackages().values().size());
-        assertEquals("classes in scope" ,   2, engine.getFactory().getClasses().values().size());
-        assertEquals("features in scope",   2, engine.getFactory().getFeatures().values().size());
-
-        assertEquals("package b in scope",     b,     engine.getFactory().getPackages().get("b"));
-        assertEquals("class b.B in scope",     b_B,   engine.getFactory().getClasses().get("b.B"));
-        assertEquals("feature b.B.b in scope", b_B_b, engine.getFactory().getFeatures().get("b.B.b"));
-        assertEquals("package c in scope",     c,     engine.getFactory().getPackages().get("c"));
-        assertEquals("class c.C in scope",     c_C,   engine.getFactory().getClasses().get("c.C"));
-        assertEquals("feature c.C.c in scope", c_C_c, engine.getFactory().getFeatures().get("c.C.c"));
+        assertEquals(2, engine.getFactory().getPackages().size(), "packages in scope: ");
+        assertEquals(2, engine.getFactory().getClasses().size(), "classes in scope");
+        assertEquals(2, engine.getFactory().getFeatures().size(), "features in scope");
+
+        assertEquals(b, engine.getFactory().getPackages().get("b"), "package b in scope");
+        assertEquals(b_B, engine.getFactory().getClasses().get("b.B"), "class b.B in scope");
+        assertEquals(b_B_b, engine.getFactory().getFeatures().get("b.B.b"), "feature b.B.b in scope");
+        assertEquals(c, engine.getFactory().getPackages().get("c"), "package c in scope");
+        assertEquals(c_C, engine.getFactory().getClasses().get("c.C"), "class c.C in scope");
+        assertEquals(c_C_c, engine.getFactory().getFeatures().get("c.C.c"), "feature c.C.c in scope");
     }
 
-    public void testComputeAllOutboundLayersP2P() {
+    @Test
+    void testComputeAllOutboundLayersP2P() {
         startCriteria.setGlobalIncludes("/^a/");
         stopCriteria.setGlobalIncludes("/^c/");
 
         var engine = new TransitiveClosureEngine(factory.getPackages().values(), startCriteria, stopCriteria, new ClosureOutboundSelector());
         engine.computeAllLayers();
 
-        assertEquals("Nb layers", 3, engine.getNbLayers());
+        assertEquals(3, engine.getNbLayers(), "Nb layers");
 
         var node = engine.getLayer(0).stream()
                 .filter(n -> n.equals(a_A_a))
                 .findAny()
                 .orElse(null);
 
-        assertEquals("Layer 0 size", 3, engine.getLayer(0).size());
-        assertEquals("Layer 0 content", a_A_a.getName(), node.getName());
-        assertEquals("Nb outbounds from a.A.a", a_A_a.getOutboundDependencies().size(), node.getOutboundDependencies().size());
-        assertEquals("Layer 1 size", 1, engine.getLayer(1).size());
-        assertEquals("Layer 1 content", b_B_b.getName(), engine.getLayer(1).iterator().next().getName());
-        assertEquals("Nb outbounds from b.B.b", b_B_b.getOutboundDependencies().size(), engine.getLayer(1).iterator().next().getOutboundDependencies().size());
-        assertEquals("Layer 2 size", 1, engine.getLayer(2).size());
-        assertEquals("Layer 2 content", c_C_c.getName(), engine.getLayer(2).iterator().next().getName());
-        assertEquals("Nb outbounds from c.C.c", c_C_c.getOutboundDependencies().size(), engine.getLayer(2).iterator().next().getOutboundDependencies().size());
+        assertEquals(3, engine.getLayer(0).size(), "Layer 0 size");
+        assertEquals(a_A_a.getName(), node.getName(), "Layer 0 content");
+        assertEquals(a_A_a.getOutboundDependencies().size(), node.getOutboundDependencies().size(), "Nb outbounds from a.A.a");
+        assertEquals(1, engine.getLayer(1).size(), "Layer 1 size");
+        assertEquals(b_B_b.getName(), engine.getLayer(1).iterator().next().getName(), "Layer 1 content");
+        assertEquals(b_B_b.getOutboundDependencies().size(), engine.getLayer(1).iterator().next().getOutboundDependencies().size(), "Nb outbounds from b.B.b");
+        assertEquals(1, engine.getLayer(2).size(), "Layer 2 size");
+        assertEquals(c_C_c.getName(), engine.getLayer(2).iterator().next().getName(), "Layer 2 content");
+        assertEquals(c_C_c.getOutboundDependencies().size(), engine.getLayer(2).iterator().next().getOutboundDependencies().size(), "Nb outbounds from c.C.c");
         
-        assertEquals("packages in scope: ", 3, engine.getFactory().getPackages().values().size());
-        assertEquals("classes in scope" ,   3, engine.getFactory().getClasses().values().size());
-        assertEquals("features in scope",   3, engine.getFactory().getFeatures().values().size());
-
-        assertEquals("package a in scope",     a,     engine.getFactory().getPackages().get("a"));
-        assertEquals("class a.A in scope",     a_A,   engine.getFactory().getClasses().get("a.A"));
-        assertEquals("feature a.A.a in scope", a_A_a, engine.getFactory().getFeatures().get("a.A.a"));
-        assertEquals("package b in scope",     b,     engine.getFactory().getPackages().get("b"));
-        assertEquals("class b.B in scope",     b_B,   engine.getFactory().getClasses().get("b.B"));
-        assertEquals("feature b.B.b in scope", b_B_b, engine.getFactory().getFeatures().get("b.B.b"));
-        assertEquals("package c in scope",     c,     engine.getFactory().getPackages().get("c"));
-        assertEquals("class c.C in scope",     c_C,   engine.getFactory().getClasses().get("c.C"));
-        assertEquals("feature c.C.c in scope", c_C_c, engine.getFactory().getFeatures().get("c.C.c"));
+        assertEquals(3, engine.getFactory().getPackages().size(), "packages in scope: ");
+        assertEquals(3, engine.getFactory().getClasses().size(), "classes in scope");
+        assertEquals(3, engine.getFactory().getFeatures().size(), "features in scope");
+
+        assertEquals(a, engine.getFactory().getPackages().get("a"), "package a in scope");
+        assertEquals(a_A, engine.getFactory().getClasses().get("a.A"), "class a.A in scope");
+        assertEquals(a_A_a, engine.getFactory().getFeatures().get("a.A.a"), "feature a.A.a in scope");
+        assertEquals(b, engine.getFactory().getPackages().get("b"), "package b in scope");
+        assertEquals(b_B, engine.getFactory().getClasses().get("b.B"), "class b.B in scope");
+        assertEquals(b_B_b, engine.getFactory().getFeatures().get("b.B.b"), "feature b.B.b in scope");
+        assertEquals(c, engine.getFactory().getPackages().get("c"), "package c in scope");
+        assertEquals(c_C, engine.getFactory().getClasses().get("c.C"), "class c.C in scope");
+        assertEquals(c_C_c, engine.getFactory().getFeatures().get("c.C.c"), "feature c.C.c in scope");
     }
 
-    public void testComputeAllInboundLayersP2P() {
+    @Test
+    void testComputeAllInboundLayersP2P() {
         startCriteria.setGlobalIncludes("/^c/");
         stopCriteria.setGlobalIncludes("/^a/");
 
         var engine = new TransitiveClosureEngine(factory.getPackages().values(), startCriteria, stopCriteria, new ClosureInboundSelector());
         engine.computeAllLayers();
 
-        assertEquals("Nb layers", 3, engine.getNbLayers());
+        assertEquals(3, engine.getNbLayers(), "Nb layers");
 
         var node = engine.getLayer(0).stream()
                 .filter(n -> n.equals(c_C_c))
                 .findAny()
                 .orElse(null);
 
-        assertEquals("Layer 0 size", 3, engine.getLayer(0).size());
-        assertEquals("Layer 0 content", c_C_c.getName(), node.getName());
-        assertEquals("Nb inbounds from c.C.c", c_C_c.getInboundDependencies().size(), node.getInboundDependencies().size());
-        assertEquals("Layer 1 size", 1, engine.getLayer(1).size());
-        assertEquals("Layer 1 content", b_B_b.getName(), engine.getLayer(1).iterator().next().getName());
-        assertEquals("Nb inbounds from b.B.b", b_B_b.getInboundDependencies().size(), engine.getLayer(1).iterator().next().getInboundDependencies().size());
-        assertEquals("Layer 2 size", 1, engine.getLayer(1).size());
-        assertEquals("Layer 2 content", a_A_a.getName(), engine.getLayer(2).iterator().next().getName());
-        assertEquals("Nb inbounds from a.A.a", a_A_a.getInboundDependencies().size(), engine.getLayer(2).iterator().next().getInboundDependencies().size());
+        assertEquals(3, engine.getLayer(0).size(), "Layer 0 size");
+        assertEquals(c_C_c.getName(), node.getName(), "Layer 0 content");
+        assertEquals(c_C_c.getInboundDependencies().size(), node.getInboundDependencies().size(), "Nb inbounds from c.C.c");
+        assertEquals(1, engine.getLayer(1).size(), "Layer 1 size");
+        assertEquals(b_B_b.getName(), engine.getLayer(1).iterator().next().getName(), "Layer 1 content");
+        assertEquals(b_B_b.getInboundDependencies().size(), engine.getLayer(1).iterator().next().getInboundDependencies().size(), "Nb inbounds from b.B.b");
+        assertEquals(1, engine.getLayer(1).size(), "Layer 2 size");
+        assertEquals(a_A_a.getName(), engine.getLayer(2).iterator().next().getName(), "Layer 2 content");
+        assertEquals(a_A_a.getInboundDependencies().size(), engine.getLayer(2).iterator().next().getInboundDependencies().size(), "Nb inbounds from a.A.a");
         
-        assertEquals("packages in scope: ", 3, engine.getFactory().getPackages().values().size());
-        assertEquals("classes in scope" ,   3, engine.getFactory().getClasses().values().size());
-        assertEquals("features in scope",   3, engine.getFactory().getFeatures().values().size());
-
-        assertEquals("package a in scope",     a,     engine.getFactory().getPackages().get("a"));
-        assertEquals("class a.A in scope",     a_A,   engine.getFactory().getClasses().get("a.A"));
-        assertEquals("feature a.A.a in scope", a_A_a, engine.getFactory().getFeatures().get("a.A.a"));
-        assertEquals("package b in scope",     b,     engine.getFactory().getPackages().get("b"));
-        assertEquals("class b.B in scope",     b_B,   engine.getFactory().getClasses().get("b.B"));
-        assertEquals("feature b.B.b in scope", b_B_b, engine.getFactory().getFeatures().get("b.B.b"));
-        assertEquals("package c in scope",     c,     engine.getFactory().getPackages().get("c"));
-        assertEquals("class c.C in scope",     c_C,   engine.getFactory().getClasses().get("c.C"));
-        assertEquals("feature c.C.c in scope", c_C_c, engine.getFactory().getFeatures().get("c.C.c"));
+        assertEquals(3, engine.getFactory().getPackages().size(), "packages in scope: ");
+        assertEquals(3, engine.getFactory().getClasses().size(), "classes in scope");
+        assertEquals(3, engine.getFactory().getFeatures().size(), "features in scope");
+
+        assertEquals(a, engine.getFactory().getPackages().get("a"), "package a in scope");
+        assertEquals(a_A, engine.getFactory().getClasses().get("a.A"), "class a.A in scope");
+        assertEquals(a_A_a, engine.getFactory().getFeatures().get("a.A.a"), "feature a.A.a in scope");
+        assertEquals(b, engine.getFactory().getPackages().get("b"), "package b in scope");
+        assertEquals(b_B, engine.getFactory().getClasses().get("b.B"), "class b.B in scope");
+        assertEquals(b_B_b, engine.getFactory().getFeatures().get("b.B.b"), "feature b.B.b in scope");
+        assertEquals(c, engine.getFactory().getPackages().get("c"), "package c in scope");
+        assertEquals(c_C, engine.getFactory().getClasses().get("c.C"), "class c.C in scope");
+        assertEquals(c_C_c, engine.getFactory().getFeatures().get("c.C.c"), "feature c.C.c in scope");
     }
 }
diff --git a/lib/src/test/java/com/jeantessier/dependency/TestTransitiveClosureNonMaximized.java b/lib/src/test/java/com/jeantessier/dependency/TestTransitiveClosureNonMaximized.java
index 8baff216..08432473 100644
--- a/lib/src/test/java/com/jeantessier/dependency/TestTransitiveClosureNonMaximized.java
+++ b/lib/src/test/java/com/jeantessier/dependency/TestTransitiveClosureNonMaximized.java
@@ -32,67 +32,51 @@
 
 package com.jeantessier.dependency;
 
+import org.apache.logging.log4j.*;
+import org.junit.jupiter.api.*;
+
 import java.util.*;
 
-import junit.framework.*;
+import static org.junit.jupiter.api.Assertions.*;
 
-import org.apache.logging.log4j.*;
-
-public class TestTransitiveClosureNonMaximized extends TestCase {
+public class TestTransitiveClosureNonMaximized {
     private final Logger logger = LogManager.getLogger();
 
-    private NodeFactory factory;
+    private final NodeFactory factory = new NodeFactory();
 
-    private FeatureNode in2;
-    private FeatureNode in1;
-    private FeatureNode base;
-    private FeatureNode out1;
-    private FeatureNode out2;
+    private final FeatureNode in2 = factory.createFeature("in2.In2.In2()");
+    private final FeatureNode in1 = factory.createFeature("in1.In1.In1()");
+    private final FeatureNode base = factory.createFeature("base.Base.Base()");
+    private final FeatureNode out1 = factory.createFeature("out1.Out1.Out1()");
+    private final FeatureNode out2 = factory.createFeature("out2.Out2.Out2()");
     
-    private RegularExpressionSelectionCriteria startCriteria;
-    private RegularExpressionSelectionCriteria stopCriteria;
-
-    private NodeFactory resultFactory;
-
-    protected void setUp() throws Exception {
-        super.setUp();
-
-        factory = new NodeFactory();
-
-        in2  = factory.createFeature("in2.In2.In2()");
-        in1  = factory.createFeature("in1.In1.In1()");
-        base = factory.createFeature("base.Base.Base()");
-        out1 = factory.createFeature("out1.Out1.Out1()");
-        out2 = factory.createFeature("out2.Out2.Out2()");
+    private final RegularExpressionSelectionCriteria startCriteria = new RegularExpressionSelectionCriteria();
+    private final RegularExpressionSelectionCriteria stopCriteria = new RegularExpressionSelectionCriteria();
 
+    @BeforeEach
+    void setUp() {
         in2.addDependency(in1);
         in1.addDependency(base);
         base.addDependency(out1);
         out1.addDependency(out2);
-        
-        List<String> scopeIncludes = new ArrayList<>();
-        scopeIncludes.add("/^base/");
-        List<String> filterIncludes = Collections.emptyList();
-        
-        startCriteria = new RegularExpressionSelectionCriteria();
+
         startCriteria.setMatchingPackages(false);
         startCriteria.setMatchingClasses(false);
         startCriteria.setMatchingFeatures(false);
-        startCriteria.setGlobalIncludes(scopeIncludes);
+        startCriteria.setGlobalIncludes(List.of("/^base/"));
 
-        stopCriteria = new RegularExpressionSelectionCriteria();
         stopCriteria.setMatchingPackages(false);
         stopCriteria.setMatchingClasses(false);
         stopCriteria.setMatchingFeatures(false);
-        stopCriteria.setGlobalIncludes(filterIncludes);
     }
 
-    public void testFeatureToFeatureFromFeature() {
+    @Test
+    void testFeatureToFeatureFromFeature() {
         startCriteria.setMatchingFeatures(true);
         stopCriteria.setMatchingFeatures(true);
 
         logger.info("Start f2f test from feature ...");
-        compute(Collections.singleton(base));
+        var resultFactory = compute(Collections.singleton(base));
         logger.info("Stop f2f test from feature ...");
 
         assertEquals(5, resultFactory.getFeatures().size());
@@ -136,12 +120,13 @@ public void testFeatureToFeatureFromFeature() {
         assertEquals(0, resultFactory.createPackage("out2").getOutboundDependencies().size());
     }
 
-    public void testFeatureToFeatureFromPackages() {
+    @Test
+    void testFeatureToFeatureFromPackages() {
         startCriteria.setMatchingFeatures(true);
         stopCriteria.setMatchingFeatures(true);
 
         logger.info("Start f2f test from package list ...");
-        compute(factory.getPackages().values());
+        var resultFactory = compute(factory.getPackages().values());
         logger.info("Stop f2f test from package list ...");
 
         assertEquals(5, resultFactory.getFeatures().size());
@@ -185,12 +170,13 @@ public void testFeatureToFeatureFromPackages() {
         assertEquals(0, resultFactory.createPackage("out2").getOutboundDependencies().size());
     }
 
-    public void testClassToClassFromClass() {
+    @Test
+    void testClassToClassFromClass() {
         startCriteria.setMatchingClasses(true);
         stopCriteria.setMatchingClasses(true);
 
         logger.info("Start c2c test from class ...");
-        compute(Collections.singleton(base.getClassNode()));
+        var resultFactory = compute(Collections.singleton(base.getClassNode()));
         logger.info("Stop c2c test from class ...");
 
         assertEquals(0, resultFactory.getFeatures().size());
@@ -225,12 +211,13 @@ public void testClassToClassFromClass() {
         assertEquals(0, resultFactory.createPackage("out2").getOutboundDependencies().size());
     }
 
-    public void testClassToClassFromPackageList() {
+    @Test
+    void testClassToClassFromPackageList() {
         startCriteria.setMatchingClasses(true);
         stopCriteria.setMatchingClasses(true);
 
         logger.info("Start c2c test from package list ...");
-        compute(factory.getPackages().values());
+        var resultFactory = compute(factory.getPackages().values());
         logger.info("Stop c2c test from package list ...");
 
         assertEquals(0, resultFactory.getFeatures().size());
@@ -265,12 +252,13 @@ public void testClassToClassFromPackageList() {
         assertEquals(0, resultFactory.createPackage("out2").getOutboundDependencies().size());
     }
 
-    public void testPackageToPackageFromPackage() {
+    @Test
+    void testPackageToPackageFromPackage() {
         startCriteria.setMatchingPackages(true);
         stopCriteria.setMatchingPackages(true);
 
         logger.info("Start p2p test from package ...");
-        compute(Collections.singleton(base.getClassNode().getPackageNode()));
+        var resultFactory = compute(Collections.singleton(base.getClassNode().getPackageNode()));
         logger.info("Stop p2p test from package ...");
 
         assertEquals(0, resultFactory.getFeatures().size());
@@ -296,12 +284,13 @@ public void testPackageToPackageFromPackage() {
         assertEquals(0, resultFactory.createPackage("out2").getOutboundDependencies().size());
     }
 
-    public void testPackageToPackageFromPackageList() {
+    @Test
+    void testPackageToPackageFromPackageList() {
         startCriteria.setMatchingPackages(true);
         stopCriteria.setMatchingPackages(true);
 
         logger.info("Start p2p test from package list ...");
-        compute(factory.getPackages().values());
+        var resultFactory = compute(factory.getPackages().values());
         logger.info("Stop p2p test from package list ...");
 
         assertEquals(0, resultFactory.getFeatures().size());
@@ -327,7 +316,7 @@ public void testPackageToPackageFromPackageList() {
         assertEquals(0, resultFactory.createPackage("out2").getOutboundDependencies().size());
     }
 
-    private void compute(Collection<? extends Node> nodes) {
+    private NodeFactory compute(Collection<? extends Node> nodes) {
         RegularExpressionSelectionCriteria localStartCriteria = new RegularExpressionSelectionCriteria();
         localStartCriteria.setGlobalIncludes(startCriteria.getGlobalIncludes());
         RegularExpressionSelectionCriteria localStopCriteria  = new RegularExpressionSelectionCriteria();
@@ -352,6 +341,6 @@ private void compute(Collection<? extends Node> nodes) {
         GraphSummarizer summarizer = new GraphSummarizer(localScopeCriteria, localFilterCriteria);
         summarizer.traverseNodes(closure.getFactory().getPackages().values());
 
-        resultFactory = summarizer.getScopeFactory();
+        return summarizer.getScopeFactory();
     }
 }