diff --git a/CHANGELOG.md b/CHANGELOG.md
index 34ea80b8..cf41e3fd 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,13 +4,14 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [Unreleased] - 2022-02-14
+## [Unreleased] - 2022-02-15
 
 ### Added
 
 ### Changed
 * Bumped dependency rho-mu to 1.2.0
 * Bumped dependency org.cicirello.core to 1.1.0
+* Migrated test cases to JUnit 5 (specifically JUnit Jupiter 5.8.2).
 
 ### Deprecated
 
diff --git a/pom.xml b/pom.xml
index dca5f705..4ebf6a96 100644
--- a/pom.xml
+++ b/pom.xml
@@ -165,12 +165,10 @@
   
 	<dependencies>
 		<dependency>
-			<groupId>junit</groupId>
-			<artifactId>junit</artifactId>
-			<version>4.13.2</version>
-			<type>jar</type>
+			<groupId>org.junit.jupiter</groupId>
+			<artifactId>junit-jupiter</artifactId>
+			<version>5.8.2</version>
 			<scope>test</scope>
-			<optional>true</optional>
 		</dependency>
 		<dependency>
 			<groupId>org.cicirello</groupId>
diff --git a/src/main/java/org/cicirello/permutations/PermutationIterator.java b/src/main/java/org/cicirello/permutations/PermutationIterator.java
index 67290224..8bdaa509 100644
--- a/src/main/java/org/cicirello/permutations/PermutationIterator.java
+++ b/src/main/java/org/cicirello/permutations/PermutationIterator.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2018-2021 Vincent A. Cicirello, <https://www.cicirello.org/>.
+ * Copyright 2018-2022 Vincent A. Cicirello, <https://www.cicirello.org/>.
  *
  * This file is part of JavaPermutationTools (https://jpt.cicirello.org/).
  *
@@ -17,7 +17,6 @@
  *
  * You should have received a copy of the GNU General Public License
  * along with JavaPermutationTools.  If not, see <http://www.gnu.org/licenses/>.
- *
  */
 
 package org.cicirello.permutations;
@@ -33,7 +32,6 @@
  * modify the returned Permutation without risk of interfering with the operation of the Iterator.
  *
  * @author <a href=https://www.cicirello.org/ target=_top>Vincent A. Cicirello</a>, <a href=https://www.cicirello.org/ target=_top>https://www.cicirello.org/</a> 
- * @version 5.24.2021
  */
 public class PermutationIterator implements Iterator<Permutation> {
 	
@@ -67,7 +65,8 @@ public PermutationIterator(Permutation p) {
 	}
 	
 	/**
-	 * {@inheritDoc}
+	 * Checks if this PermutationIterator has more Permutations.
+	 * @return true if and only if this PermutationIterator has more Permutations to iterate over.
 	 */
 	@Override
 	public boolean hasNext() {
@@ -75,7 +74,9 @@ public boolean hasNext() {
 	}
 	
 	/**
-	 * {@inheritDoc}
+	 * Gets the Permutation for the next iteration.
+	 * @return The Permutation for the next iteration.
+	 * @throws NoSuchElementException if hasNext() is false 
 	 */
 	@Override
 	public Permutation next() {
diff --git a/src/test/java/org/cicirello/permutations/PermutationTestCases.java b/src/test/java/org/cicirello/permutations/PermutationTestCases.java
index 5b470872..9f75e76a 100644
--- a/src/test/java/org/cicirello/permutations/PermutationTestCases.java
+++ b/src/test/java/org/cicirello/permutations/PermutationTestCases.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2018-2021 Vincent A. Cicirello, <https://www.cicirello.org/>.
+ * Copyright 2018-2022 Vincent A. Cicirello, <https://www.cicirello.org/>.
  *
  * This file is part of JavaPermutationTools (https://jpt.cicirello.org/).
  *
@@ -17,7 +17,6 @@
  *
  * You should have received a copy of the GNU General Public License
  * along with JavaPermutationTools.  If not, see <http://www.gnu.org/licenses/>.
- *
  */
 package org.cicirello.permutations;
 
@@ -26,11 +25,11 @@
 import java.util.concurrent.ThreadLocalRandom;
 import java.math.BigInteger;
 import java.util.NoSuchElementException;
-import org.junit.*;
-import static org.junit.Assert.*;
+import org.junit.jupiter.api.*;
+import static org.junit.jupiter.api.Assertions.*;
 
 /**
- * JUnit 4 tests for the constructors and methods of the Permutation class, as well as the PermutationIterator.
+ * JUnit tests for the constructors and methods of the Permutation class, as well as the PermutationIterator.
  */
 public class PermutationTestCases {
 	
@@ -59,7 +58,7 @@ public void testZeroLengthPermutations() {
 		assertEquals(p2,copy);
 		assertEquals(p3,copy);
 		
-		assertEquals("length of inverse of zero length permutation should be 0", 0, p1.getInverse().length);
+		assertEquals(0, p1.getInverse().length, "length of inverse of zero length permutation should be 0");
 		
 		// confirm that reverse() and scramble() don't throw exceptions
 		p1.reverse();
@@ -95,8 +94,8 @@ public void testPermutationConstructorSpecific() {
 			fact *= n;
 			for (int i = 0; i < fact; i++) {
 				Permutation p = new Permutation(n, i);
-				assertEquals("toInteger should produce same int value", i, p.toInteger());
-				assertEquals("toBigInteger should produce same int value", BigInteger.valueOf(i), p.toBigInteger());
+				assertEquals(i, p.toInteger());
+				assertEquals(BigInteger.valueOf(i), p.toBigInteger());
 				validatePermutation(p, n);
 			}
 		}
@@ -109,8 +108,8 @@ public void testPermutationConstructorSpecific() {
 		for (int i = 0; i < 100; i++) {
 			int which = r.nextInt(fact);
 			Permutation p = new Permutation(n, which);
-			assertEquals("toInteger should produce same int value", which, p.toInteger());
-			assertEquals("toBigInteger should produce same int value", BigInteger.valueOf(which), p.toBigInteger());
+			assertEquals(which, p.toInteger());
+			assertEquals(BigInteger.valueOf(which), p.toBigInteger());
 			validatePermutation(p, n);
 		}
 	}
@@ -123,8 +122,8 @@ public void testPermutationConstructorSpecificBigInt() {
 			for (int i = 0; i < fact; i++) {
 				BigInteger big = BigInteger.valueOf(i);
 				Permutation p = new Permutation(n, big);
-				assertEquals("toInteger should produce same int value", i, p.toInteger());
-				assertEquals("toBigInteger should produce same int value", big, p.toBigInteger());
+				assertEquals(i, p.toInteger());
+				assertEquals(big, p.toBigInteger());
 				validatePermutation(p, n);
 			}
 		}
@@ -138,8 +137,8 @@ public void testPermutationConstructorSpecificBigInt() {
 			int which = r.nextInt(fact);
 			BigInteger bigWhich = BigInteger.valueOf(which);
 			Permutation p = new Permutation(n, bigWhich);
-			assertEquals("toInteger should produce same int value", which, p.toInteger());
-			assertEquals("toBigInteger should produce same int value", bigWhich, p.toBigInteger());
+			assertEquals(which, p.toInteger());
+			assertEquals(bigWhich, p.toBigInteger());
 			validatePermutation(p, n);
 		}
 		n = 20;
@@ -150,7 +149,7 @@ public void testPermutationConstructorSpecificBigInt() {
 		for (int i = 0; i < 20; i++) {
 			BigInteger bigWhich = new BigInteger(f.bitLength()-1, ThreadLocalRandom.current());
 			Permutation p = new Permutation(n, bigWhich);
-			assertEquals("toBigInteger should produce same BigInteger value", bigWhich, p.toBigInteger());
+			assertEquals(bigWhich, p.toBigInteger());
 			validatePermutation(p, n);
 		}
 	}
@@ -171,7 +170,9 @@ public void testPermutationConstructorFromArray() {
 		for (int[] a : arrays) {
 			Permutation p = new Permutation(a.clone());
 			validatePermutation(p, a.length);
-			for (int i = 0; i < a.length; i++) assertEquals("elements should be in same order", a[i], p.get(i));
+			for (int i = 0; i < a.length; i++) {
+				assertEquals(a[i], p.get(i), "elements should be in same order");
+			}
 			assertEquals(str[s], p.toString());
 			s++;
 		}
@@ -200,7 +201,9 @@ public void testPermutationSetFromArray() {
 			Permutation p = new Permutation(a.length, 0);
 			p.set(a.clone());
 			validatePermutation(p, a.length);
-			for (int i = 0; i < a.length; i++) assertEquals("elements should be in same order", a[i], p.get(i));
+			for (int i = 0; i < a.length; i++) {
+				assertEquals(a[i], p.get(i));
+			}
 		}
 		final int[] negative = { 1, 4, -1, 0, 3};
 		final int[] tooHigh = { 1, 4, 5, 0, 3};
@@ -248,7 +251,9 @@ public void testSet(Permutation p, int[] s, int from, int to, int numElements) {
 			Permutation p = new Permutation(a.length, 0);
 			test.testSet(p, a.clone()); 
 			validatePermutation(p, a.length);
-			for (int i = 0; i < a.length; i++) assertEquals("elements should be in same order", a[i], p.get(i));
+			for (int i = 0; i < a.length; i++) {
+				assertEquals(a[i], p.get(i));
+			}
 		}
 		for (int[] a : arrays) {
 			Permutation p = new Permutation(a.length, 0);
@@ -256,13 +261,17 @@ public void testSet(Permutation p, int[] s, int from, int to, int numElements) {
 				test.testSet(p, i, a[i]);
 			} 
 			validatePermutation(p, a.length);
-			for (int i = 0; i < a.length; i++) assertEquals("elements should be in same order", a[i], p.get(i));
+			for (int i = 0; i < a.length; i++) {
+				assertEquals(a[i], p.get(i));
+			}
 		}
 		for (int[] a : arrays) {
 			Permutation p = new Permutation(a.length, 0);
 			test.testSet(p, 0, a.clone()); 
 			validatePermutation(p, a.length);
-			for (int i = 0; i < a.length; i++) assertEquals("elements should be in same order", a[i], p.get(i));
+			for (int i = 0; i < a.length; i++) {
+				assertEquals(a[i], p.get(i));
+			}
 		}
 		for (int[] a : arrays) {
 			Permutation p = new Permutation(a);
@@ -270,20 +279,22 @@ public void testSet(Permutation p, int[] s, int from, int to, int numElements) {
 			int start = a.length > 1 ? 1 : 0;
 			test.testSet(p, start, change);
 			for (int i = 0; i < start; i++) {
-				assertEquals("elements before start should not change", a[i], p.get(i));
+				assertEquals(a[i], p.get(i));
 			}
 			for (int i = 0; i < change.length; i++) {
-				assertEquals("checking changed elements", change[i], p.get(start+i));
+				assertEquals(change[i], p.get(start+i), "checking changed elements");
 			}
 			for (int i = start + change.length; i < a.length; i++) {
-				assertEquals("elements after end should not change", a[i], p.get(i));
+				assertEquals(a[i], p.get(i));
 			}
 		}
 		for (int[] a : arrays) {
 			Permutation p = new Permutation(a.length, 0);
 			test.testSet(p, a.clone(), 0, 0, a.length); 
 			validatePermutation(p, a.length);
-			for (int i = 0; i < a.length; i++) assertEquals("elements should be in same order", a[i], p.get(i));
+			for (int i = 0; i < a.length; i++) {
+				assertEquals(a[i], p.get(i));
+			}
 		}
 		for (int[] a : arrays) {
 			Permutation p = new Permutation(a);
@@ -291,13 +302,13 @@ public void testSet(Permutation p, int[] s, int from, int to, int numElements) {
 			int start = a.length > 1 ? 1 : 0;
 			test.testSet(p, change, 0, start, change.length);
 			for (int i = 0; i < start; i++) {
-				assertEquals("elements before start should not change", a[i], p.get(i));
+				assertEquals(a[i], p.get(i));
 			}
 			for (int i = 0; i < change.length; i++) {
-				assertEquals("checking changed elements", change[i], p.get(start+i));
+				assertEquals(change[i], p.get(start+i), "checking changed elements");
 			}
 			for (int i = start + change.length; i < a.length; i++) {
-				assertEquals("elements after end should not change", a[i], p.get(i));
+				assertEquals(a[i], p.get(i));
 			}
 		}
 		for (int[] a : arrays) {
@@ -306,13 +317,13 @@ public void testSet(Permutation p, int[] s, int from, int to, int numElements) {
 			int start = a.length > 1 ? 1 : 0;
 			test.testSet(p, change, 2, start, change.length - 4);
 			for (int i = 0; i < start; i++) {
-				assertEquals("elements before start should not change", a[i], p.get(i));
+				assertEquals(a[i], p.get(i));
 			}
 			for (int i = 2; i < change.length-2; i++) {
-				assertEquals("checking changed elements", change[i], p.get(start+i-2));
+				assertEquals(change[i], p.get(start+i-2), "checking changed elements");
 			}
 			for (int i = start + change.length - 4; i < a.length; i++) {
-				assertEquals("elements after end should not change", a[i], p.get(i));
+				assertEquals(a[i], p.get(i));
 			}
 		}
 	}
@@ -323,7 +334,7 @@ public void testPermutationCopyConstructor() {
 			for (int i = 0; i < 10; i++) {
 				Permutation p = new Permutation(n);
 				Permutation copy = new Permutation(p);
-				assertEquals("copy should create an identical copy", p, copy);
+				assertEquals(p, copy);
 				assertEquals(p.hashCode(), copy.hashCode());
 			}
 		}
@@ -335,8 +346,8 @@ public void testPermutationCopyMethod() {
 			for (int i = 0; i < 10; i++) {
 				Permutation p = new Permutation(n);
 				Permutation copy = p.copy();
-				assertEquals("copy should create an identical copy", p, copy);
-				assertTrue("copy should be a new object", p != copy);
+				assertEquals(p, copy);
+				assertTrue(p != copy);
 				assertEquals(p.hashCode(), copy.hashCode());
 			}
 		}
@@ -363,13 +374,13 @@ public void testPermutationConstructorCopyPartial() {
 			for (int m = 0; m <= n; m++) {
 				Permutation copy1 = new Permutation(p1, m);
 				Permutation copy2 = new Permutation(p2, m);
-				assertEquals("partial copy length", m, copy1.length());
-				assertEquals("partial copy length", m, copy2.length());
+				assertEquals(m, copy1.length());
+				assertEquals(m, copy2.length());
 				validatePermutation(copy1, m);
 				validatePermutation(copy2, m);
 				for (int i = 0; i < m; i++) {
-					assertEquals("should be sorted order", i, copy1.get(i));
-					assertEquals("should be reverse sorted order", m-1-i, copy2.get(i));
+					assertEquals(i, copy1.get(i));
+					assertEquals(m-1-i, copy2.get(i));
 				}
 			}
 		}
@@ -380,11 +391,11 @@ public void testPermutationEquals() {
 		Permutation p = new Permutation(10);
 		for (int n = 1; n < 10; n++) {
 			Permutation partialCopy = new Permutation(p, n);
-			assertNotEquals("lengths differ not equal", p, partialCopy);
+			assertNotEquals(p, partialCopy);
 		}
 		Permutation copy = new Permutation(p);
-		assertEquals("identical copy should be equal", p, copy);
-		assertNotEquals("different at end points", new Permutation(new int[] {0, 1, 2, 3}), new Permutation(new int[] {3, 1, 2, 0}));
+		assertEquals(p, copy);
+		assertNotEquals(new Permutation(new int[] {0, 1, 2, 3}), new Permutation(new int[] {3, 1, 2, 0}));
 	}
 	
 	@Test
@@ -394,11 +405,11 @@ public void testPermutationInverse() {
 		Permutation p = new Permutation(before);
 		int[] expected = {3, 5, 1, 4, 0, 2};
 		int[] inv = p.getInverse();
-		assertArrayEquals("inverse", expected, inv);
-		assertArrayEquals("confirm inverse didn't change original", beforeCopy, before);
+		assertArrayEquals(expected, inv);
+		assertArrayEquals(beforeCopy, before);
 		int[] array = {0, 1, 2, 3, 4, 5};
 		p = new Permutation(array);
-		assertArrayEquals("inverse", array, p.getInverse());
+		assertArrayEquals(array, p.getInverse());
 	}
 	
 	@Test
@@ -409,11 +420,11 @@ public void testPermutationInverseP() {
 		int[] expected = {3, 5, 1, 4, 0, 2};
 		Permutation pExpected = new Permutation(expected);
 		Permutation inv = p.getInversePermutation();
-		assertEquals("inverse", pExpected, inv);
-		assertEquals("confirm inverse didn't change original", p2, p);
+		assertEquals(pExpected, inv);
+		assertEquals(p2, p);
 		int[] array = {0, 1, 2, 3, 4, 5};
 		p = new Permutation(array);
-		assertEquals("inverse", p, p.getInversePermutation());
+		assertEquals(p, p.getInversePermutation());
 	}
 	
 	@Test
@@ -423,12 +434,12 @@ public void testPermutationInvert() {
 		int[] expected = {3, 5, 1, 4, 0, 2};
 		Permutation pExpected = new Permutation(expected);
 		p.invert();
-		assertEquals("inverse", pExpected, p);
+		assertEquals(pExpected, p);
 		int[] array = {0, 1, 2, 3, 4, 5};
 		p = new Permutation(array);
 		pExpected = new Permutation(array);
 		p.invert();
-		assertEquals("inverse", pExpected, p);
+		assertEquals(pExpected, p);
 	}
 	
 	@Test
@@ -436,27 +447,27 @@ public void testToArray() {
 		int[] init = {4, 2, 5, 0, 3, 1};
 		Permutation p = new Permutation(init.clone());
 		int[] array = p.toArray();
-		assertArrayEquals("should be equal to current state", init, array);
+		assertArrayEquals(init, array);
 		for (int i = 0; i < array.length; i++) {
 			// change the array to confirm did not affect Permutation
 			array[i] = i;
 		}
-		assertArrayEquals("should still be equal to current state", init, p.toArray());
+		assertArrayEquals(init, p.toArray());
 		
 		array = null;
 		array = p.toArray(array);
-		assertArrayEquals("should be equal to current state", init, array);
+		assertArrayEquals(init, array);
 		
 		array = new int[6];
 		int[] result = p.toArray(array);
-		assertTrue("Should use the array parameter if correct length", result == array);
-		assertArrayEquals("should be equal to current state", init, result);
+		assertTrue(result == array);
+		assertArrayEquals(init, result);
 		
 		array = new int[7];
 		result = null;
 		result = p.toArray(array);
-		assertFalse("Should construct new array if the array parameter wrong length", result == array);
-		assertArrayEquals("should be equal to current state", init, result);
+		assertFalse(result == array);
+		assertArrayEquals(init, result);
 	}
 	
 	@Test
@@ -466,9 +477,9 @@ public void testGetRange() {
 		for (int i = 0; i < init.length; i++) {
 			for (int j = i; j < init.length; j++) {
 				int[] a = p.get(i, j);
-				assertEquals("length of result", j-i+1, a.length);
+				assertEquals(j-i+1, a.length);
 				for (int k = 0; k < a.length; k++) {
-					assertEquals("Elements should be in target range of permutation", init[i+k], a[k]);
+					assertEquals(init[i+k], a[k]);
 				}
 			}
 		}
@@ -476,10 +487,10 @@ public void testGetRange() {
 			for (int j = i; j < init.length; j++) {
 				int[] result = new int[j-i+1];
 				int[] a = p.get(i, j, result);
-				assertTrue("Should use the passed array", result == a);
-				assertEquals("length of result", j-i+1, a.length);
+				assertTrue(result == a);
+				assertEquals(j-i+1, a.length);
 				for (int k = 0; k < a.length; k++) {
-					assertEquals("Elements should be in target range of permutation", init[i+k], a[k]);
+					assertEquals(init[i+k], a[k]);
 				}
 			}
 		}
@@ -487,9 +498,9 @@ public void testGetRange() {
 			for (int j = i; j < init.length; j++) {
 				int[] result = null;
 				int[] a = p.get(i, j, result);
-				assertEquals("length of result", j-i+1, a.length);
+				assertEquals(j-i+1, a.length);
 				for (int k = 0; k < a.length; k++) {
-					assertEquals("Elements should be in target range of permutation", init[i+k], a[k]);
+					assertEquals(init[i+k], a[k]);
 				}
 			}
 		}
@@ -497,10 +508,10 @@ public void testGetRange() {
 			for (int j = i; j < init.length; j++) {
 				int[] result = new int[j-i+2];
 				int[] a = p.get(i, j, result);
-				assertTrue("Should construct a new array if length incorrect", result != a);
-				assertEquals("length of result", j-i+1, a.length);
+				assertTrue(result != a);
+				assertEquals(j-i+1, a.length);
 				for (int k = 0; k < a.length; k++) {
-					assertEquals("Elements should be in target range of permutation", init[i+k], a[k]);
+					assertEquals(init[i+k], a[k]);
 				}
 			}
 		}
@@ -523,25 +534,25 @@ public void testPermutationRemoveInsert() {
 				copy.removeAndInsert(i, j);
 				if (i < j) {
 					for (int k = 0; k < i; k++) {
-						assertEquals("elements before removal point should not change", p.get(k), copy.get(k));
+						assertEquals(p.get(k), copy.get(k));
 					}
 					for (int k = i; k < j; k++) {
-						assertEquals("elements from removal to insertion point should shift once", p.get(k+1), copy.get(k));
+						assertEquals(p.get(k+1), copy.get(k));
 					}
-					assertEquals("removed element should be at insertion point", p.get(i), copy.get(j));
+					assertEquals(p.get(i), copy.get(j));
 					for (int k = j+1; k < p.length(); k++) {
-						assertEquals("elements after insertion point should not change", p.get(k), copy.get(k));
+						assertEquals(p.get(k), copy.get(k));
 					}
 				} else if (i > j) {
 					for (int k = 0; k < j; k++) {
-						assertEquals("elements before insertion point should not change", p.get(k), copy.get(k));
+						assertEquals(p.get(k), copy.get(k));
 					}
-					assertEquals("removed element should be at insertion point", p.get(i), copy.get(j));
+					assertEquals(p.get(i), copy.get(j));
 					for (int k = j+1; k <= i; k++) {
-						assertEquals("elements from removal to insertion point should shift once", p.get(k-1), copy.get(k));
+						assertEquals(p.get(k-1), copy.get(k));
 					}
 					for (int k = i+1; k < p.length(); k++) {
-						assertEquals("elements after removal point should not change", p.get(k), copy.get(k));
+						assertEquals(p.get(k), copy.get(k));
 					}
 				} else {
 					assertEquals(p, copy);
@@ -563,27 +574,27 @@ public void testPermutationBlockRemoveInsert() {
 		Permutation p1 = new Permutation(a1);
 		Permutation mutant = new Permutation(p);
 		mutant.removeAndInsert(7, 1, 0);
-		assertEquals("move 1 to front", p1, mutant);
+		assertEquals(p1, mutant);
 		Permutation p2 = new Permutation(a2);
 		mutant = new Permutation(p);
 		mutant.removeAndInsert(2, 1, 10);
-		assertEquals("move 1 to end", p2, mutant);
+		assertEquals(p2, mutant);
 		Permutation p3 = new Permutation(a3);
 		mutant = new Permutation(p);
 		mutant.removeAndInsert(7, 2, 0);
-		assertEquals("move 2 to front", p3, mutant);
+		assertEquals(p3, mutant);
 		Permutation p4 = new Permutation(a4);
 		mutant = new Permutation(p);
 		mutant.removeAndInsert(1, 2, 9);
-		assertEquals("move 2 to end", p4, mutant);
+		assertEquals(p4, mutant);
 		Permutation p5 = new Permutation(a5);
 		mutant = new Permutation(p);
 		mutant.removeAndInsert(1, 2, 6);
-		assertEquals("move 2 later", p5, mutant);
+		assertEquals(p5, mutant);
 		Permutation p6 = new Permutation(a6);
 		mutant = new Permutation(p);
 		mutant.removeAndInsert(7, 2, 1);
-		assertEquals("move 2 earlier", p6, mutant);
+		assertEquals(p6, mutant);
 		
 		mutant = new Permutation(p);
 		mutant.removeAndInsert(1, 0, 3);
@@ -599,35 +610,35 @@ public void testPermutationReverse() {
 		Permutation copy = new Permutation(p);
 		copy.reverse();
 		for (int i = 0; i < p.length(); i++) {
-			assertEquals("elements should be in reverse order", p.get(i), copy.get(p.length()-1-i));
+			assertEquals(p.get(i), copy.get(p.length()-1-i));
 		}
 		for (int j = 0; j < p.length(); j++) {
 			for (int k = j+1; k < p.length(); k++) {
 				copy = new Permutation(p);
 				copy.reverse(j, k);
 				for (int i = 0; i < j; i++) {
-					assertEquals("elements before should not change", p.get(i), copy.get(i));
+					assertEquals(p.get(i), copy.get(i));
 				}
 				int shift = 0;
 				for (int i = j; i <= k; i++) {
-					assertEquals("elements should be reversed", p.get(i), copy.get(k-shift));
+					assertEquals(p.get(i), copy.get(k-shift));
 					shift++;
 				}
 				for (int i = k+1; i < p.length(); i++) {
-					assertEquals("elements after should not change", p.get(i), copy.get(i));
+					assertEquals(p.get(i), copy.get(i));
 				}
 				copy = new Permutation(p);
 				copy.reverse(k, j);
 				for (int i = 0; i < j; i++) {
-					assertEquals("elements before should not change", p.get(i), copy.get(i));
+					assertEquals(p.get(i), copy.get(i));
 				}
 				shift = 0;
 				for (int i = j; i <= k; i++) {
-					assertEquals("elements should be reversed", p.get(i), copy.get(k-shift));
+					assertEquals(p.get(i), copy.get(k-shift));
 					shift++;
 				}
 				for (int i = k+1; i < p.length(); i++) {
-					assertEquals("elements after should not change", p.get(i), copy.get(i));
+					assertEquals(p.get(i), copy.get(i));
 				}
 			}
 		}
@@ -641,7 +652,7 @@ public void testPermutationRotate() {
 			copy.rotate(r);
 			for (int i = 0; i < p.length(); i++) {
 				int j = (i + r) % p.length();
-				assertEquals("elements should be left rotated " + r + " places", p.get(j), copy.get(i));
+				assertEquals(p.get(j), copy.get(i), "elements should be left rotated " + r + " places");
 			}
 		}
 		Permutation copy = new Permutation(p);
@@ -650,9 +661,9 @@ public void testPermutationRotate() {
 		copy = new Permutation(p);
 		copy.rotate(-1);
 		for (int i = 1; i < p.length(); i++) {
-			assertEquals("elements should be RIGHT rotated 1 place", p.get(i-1), copy.get(i));
+			assertEquals(p.get(i-1), copy.get(i), "elements should be RIGHT rotated 1 place");
 		}
-		assertEquals("elements should be RIGHT rotated 1 place", p.get(p.length()-1), copy.get(0));
+		assertEquals(p.get(p.length()-1), copy.get(0), "elements should be RIGHT rotated 1 place");
 	}
 	
 	@Test
@@ -665,10 +676,10 @@ public void testCycle() {
 			indexes[0] = 0;
 			indexes[1] = i-1;
 			p2.cycle(indexes);
-			assertEquals("case: endpoint swap", p.get(0), p2.get(i-1));
-			assertEquals("case: endpoint swap", p.get(i-1), p2.get(0));
+			assertEquals(p.get(0), p2.get(i-1));
+			assertEquals(p.get(i-1), p2.get(0));
 			for (int j = 1; j < i-1; j++) {
-				assertEquals("non swapped elements should not change", p.get(j), p2.get(j));
+				assertEquals(p.get(j), p2.get(j));
 			}
 		}
 		for (int i = 1; i <= 5; i++) {
@@ -677,10 +688,10 @@ public void testCycle() {
 			indexes[1] = 0;
 			indexes[0] = i-1;
 			p2.cycle(indexes);
-			assertEquals("case: endpoint swap", p.get(0), p2.get(i-1));
-			assertEquals("case: endpoint swap", p.get(i-1), p2.get(0));
+			assertEquals(p.get(0), p2.get(i-1));
+			assertEquals(p.get(i-1), p2.get(0));
 			for (int j = 1; j < i-1; j++) {
-				assertEquals("non swapped elements should not change", p.get(j), p2.get(j));
+				assertEquals(p.get(j), p2.get(j));
 			}
 		}
 		for (int i = 4; i <= 6; i++) {
@@ -689,13 +700,13 @@ public void testCycle() {
 			indexes[0] = (i-1)/2;
 			indexes[1] = indexes[0]+1;
 			p2.cycle(indexes);
-			assertEquals("case: interior swap", p.get(indexes[0]), p2.get(indexes[1]));
-			assertEquals("case: interior swap", p.get(indexes[1]), p2.get(indexes[0]));
+			assertEquals(p.get(indexes[0]), p2.get(indexes[1]));
+			assertEquals(p.get(indexes[1]), p2.get(indexes[0]));
 			for (int j = 0; j < indexes[0]; j++) {
-				assertEquals("non swapped elements should not change", p.get(j), p2.get(j));
+				assertEquals(p.get(j), p2.get(j));
 			}
 			for (int j = indexes[1]+1; j < i; j++) {
-				assertEquals("non swapped elements should not change", p.get(j), p2.get(j));
+				assertEquals(p.get(j), p2.get(j));
 			}
 		}
 		// 3-cycles
@@ -957,45 +968,45 @@ public void testSwap() {
 			Permutation p = new Permutation(i);
 			Permutation p2 = new Permutation(p);
 			p2.swap(0, i-1);
-			assertEquals("case: endpoint swap", p.get(0), p2.get(i-1));
-			assertEquals("case: endpoint swap", p.get(i-1), p2.get(0));
+			assertEquals(p.get(0), p2.get(i-1));
+			assertEquals(p.get(i-1), p2.get(0));
 			for (int j = 1; j < i-1; j++) {
-				assertEquals("non swapped elements should not change", p.get(j), p2.get(j));
+				assertEquals(p.get(j), p2.get(j));
 			}
 		}
 		for (int i = 1; i <= 5; i++) {
 			Permutation p = new Permutation(i);
 			Permutation p2 = new Permutation(p);
 			p2.swap(i-1, 0);
-			assertEquals("case: endpoint swap", p.get(0), p2.get(i-1));
-			assertEquals("case: endpoint swap", p.get(i-1), p2.get(0));
+			assertEquals(p.get(0), p2.get(i-1));
+			assertEquals(p.get(i-1), p2.get(0));
 			for (int j = 1; j < i-1; j++) {
-				assertEquals("non swapped elements should not change", p.get(j), p2.get(j));
+				assertEquals(p.get(j), p2.get(j));
 			}
 		}
 		for (int i = 4; i <= 10; i++) {
 			Permutation p = new Permutation(i);
 			Permutation p2 = new Permutation(p);
 			p2.swap(1, i-2);
-			assertEquals("case: interior swap", p.get(1), p2.get(i-2));
-			assertEquals("case: interior swap", p.get(i-2), p2.get(1));
+			assertEquals(p.get(1), p2.get(i-2));
+			assertEquals(p.get(i-2), p2.get(1));
 			for (int j = 2; j < i-2; j++) {
-				assertEquals("non swapped elements should not change", p.get(j), p2.get(j));
+				assertEquals(p.get(j), p2.get(j));
 			}
-			assertEquals("non swapped elements should not change", p.get(0), p2.get(0));
-			assertEquals("non swapped elements should not change", p.get(i-1), p2.get(i-1));
+			assertEquals(p.get(0), p2.get(0));
+			assertEquals(p.get(i-1), p2.get(i-1));
 		}
 		for (int i = 4; i <= 10; i++) {
 			Permutation p = new Permutation(i);
 			Permutation p2 = new Permutation(p);
 			p2.swap(i-2, 1);
-			assertEquals("case: interior swap", p.get(1), p2.get(i-2));
-			assertEquals("case: interior swap", p.get(i-2), p2.get(1));
+			assertEquals(p.get(1), p2.get(i-2));
+			assertEquals(p.get(i-2), p2.get(1));
 			for (int j = 2; j < i-2; j++) {
-				assertEquals("non swapped elements should not change", p.get(j), p2.get(j));
+				assertEquals(p.get(j), p2.get(j));
 			}
-			assertEquals("non swapped elements should not change", p.get(0), p2.get(0));
-			assertEquals("non swapped elements should not change", p.get(i-1), p2.get(i-1));
+			assertEquals(p.get(0), p2.get(0));
+			assertEquals(p.get(i-1), p2.get(i-1));
 		}
 	}
 	
@@ -1011,13 +1022,13 @@ public void testSwapBlocks() {
 				String s = "(0, " + b + ", " + c + ", 10)"; 
 				int y = 0;
 				for (int x = 11-j; x <= 10; x++, y++) {
-					assertEquals("left block of result, params="+s, a[x], p.get(y));
+					assertEquals(a[x], p.get(y), "left block of result, params="+s);
 				}
 				for (int x = i; x < 11-j; x++, y++) {
-					assertEquals("interior of swapped blocks, params="+s, a[x], p.get(y));
+					assertEquals(a[x], p.get(y), "interior of swapped blocks, params="+s);
 				}
 				for (int x = 0; x < i; x++, y++) {
-					assertEquals("right block of result, params="+s, a[x], p.get(y));
+					assertEquals(a[x], p.get(y), "right block of result, params="+s);
 				}
 			}
 		}
@@ -1029,16 +1040,16 @@ public void testSwapBlocks() {
 				p.swapBlocks(1, b, c, 9);
 				String s = "(1, " + b + ", " + c + ", 9)"; 
 				int y = 1;
-				assertEquals("0th element should not change", a[0], p.get(0));
-				assertEquals("last element should not change", a[10], p.get(10));
+				assertEquals(a[0], p.get(0));
+				assertEquals(a[10], p.get(10));
 				for (int x = c; x <= 9; x++, y++) {
-					assertEquals("left block of result, params="+s, a[x], p.get(y));
+					assertEquals(a[x], p.get(y), "left block of result, params="+s);
 				}
 				for (int x = b+1; x < c; x++, y++) {
-					assertEquals("interior of swapped blocks, params="+s, a[x], p.get(y));
+					assertEquals(a[x], p.get(y), "interior of swapped blocks, params="+s);
 				}
 				for (int x = 1; x <= b; x++, y++) {
-					assertEquals("right block of result, params="+s, a[x], p.get(y));
+					assertEquals(a[x], p.get(y), "right block of result, params="+s);
 				}
 			}
 		}
@@ -1075,15 +1086,15 @@ public void testPermutationIterator() {
 			int count = 0;
 			for (Permutation pPrime : p) {
 				if (!checkedFirst) {
-					assertEquals("first permutation given by Iterator should be p", p, pPrime);
+					assertEquals(p, pPrime);
 					checkedFirst = true;
 				}
 				int permID = pPrime.toInteger();
-				assertFalse("should not give same permutation more than once", found[permID]);
+				assertFalse(found[permID]);
 				found[permID] = true;
 				count++;
 			}
-			assertEquals("Should iterate over all permutations of given length", fact, count);
+			assertEquals(fact, count);
 		}
 		final PermutationIterator iter = new PermutationIterator(4);
 		fact = 24;
@@ -1092,11 +1103,11 @@ public void testPermutationIterator() {
 		while (iter.hasNext()) {
 			Permutation p = iter.next();
 			int permID = p.toInteger();
-			assertFalse("should not give same permutation more than once", found[permID]);
+			assertFalse(found[permID]);
 			found[permID] = true;
 			count++;
 		}
-		assertEquals("Should iterate over all permutations of given length", fact, count);
+		assertEquals(fact, count);
 		NoSuchElementException thrown = assertThrows( 
 			NoSuchElementException.class,
 			() -> iter.next()
@@ -1236,10 +1247,10 @@ public void testUniformityOfConstructors() {
 			if (chiSquare(counts2) > 146.567) tooHigh2++;
 		}
 		if (!disableChiSquareTests) {
-			assertTrue("chi square above limit too often: default constructor", tooHigh0 <= 10);
+			assertTrue(tooHigh0 <= 10);
 		}
-		assertTrue("chi square above limit too often: using class Random", tooHigh1 <= 10);
-		assertTrue("chi square above limit too often: using class SplittableRandom", tooHigh2 <= 10);
+		assertTrue(tooHigh1 <= 10);
+		assertTrue(tooHigh2 <= 10);
 	}
 	
 	@Test
@@ -1273,19 +1284,19 @@ public void testUniformityOfScramble() {
 			if (chiSquare(counts2) > 146.567) tooHigh2++;
 		}
 		if (!disableChiSquareTests) {
-			assertTrue("chi square above limit too often: scramble", tooHigh0 <= 10);
+			assertTrue(tooHigh0 <= 10);
 		}
-		assertTrue("chi square above limit too often: using class Random", tooHigh1 <= 10);
-		assertTrue("chi square above limit too often: using class SplittableRandom", tooHigh2 <= 10);
+		assertTrue(tooHigh1 <= 10);
+		assertTrue(tooHigh2 <= 10);
 	}
 	
 	private void validatePermutation(Permutation p, int n) {
-		assertEquals("permutation length", n, p.length());
+		assertEquals(n, p.length());
 		boolean[] inP = new boolean[n];
 		for (int i = 0; i < p.length(); i++) {
 			int el = p.get(i);
-			assertTrue("permutation element values", el >= 0 && el < n);
-			assertFalse("permutation elements shouldn't be duplicated", inP[el]);
+			assertTrue(el >= 0 && el < n);
+			assertFalse(inP[el]);
 			inP[el] = true;
 		}
 	}
diff --git a/src/test/java/org/cicirello/permutations/distance/PermutationDistanceMaxTests.java b/src/test/java/org/cicirello/permutations/distance/PermutationDistanceMaxTests.java
index 28ddbf87..2a2f58fe 100644
--- a/src/test/java/org/cicirello/permutations/distance/PermutationDistanceMaxTests.java
+++ b/src/test/java/org/cicirello/permutations/distance/PermutationDistanceMaxTests.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2019-2021 Vincent A. Cicirello, <https://www.cicirello.org/>.
+ * Copyright 2019-2022 Vincent A. Cicirello, <https://www.cicirello.org/>.
  *
  * This file is part of JavaPermutationTools (https://jpt.cicirello.org/).
  *
@@ -17,16 +17,15 @@
  *
  * You should have received a copy of the GNU General Public License
  * along with JavaPermutationTools.  If not, see <http://www.gnu.org/licenses/>.
- *
  */
 package org.cicirello.permutations.distance;
 
-import org.junit.*;
-import static org.junit.Assert.*;
+import org.junit.jupiter.api.*;
+import static org.junit.jupiter.api.Assertions.*;
 import org.cicirello.permutations.*;
 
 /**
- * JUnit 4 tests for the max method of various classes that implement permutation distance metrics.
+ * JUnit tests for the max method of various classes that implement permutation distance metrics.
  */
 public class PermutationDistanceMaxTests {
 	
@@ -67,8 +66,8 @@ public void testBlockInterchangeDistance() {
 		BlockInterchangeDistance d = new BlockInterchangeDistance();
 		for (int n = 0; n <= 7; n++) {
 			int expected = bruteForceComputeMax(d,n);
-			assertEquals("Failed on length: " + n, expected, d.max(n));
-			assertEquals("Failed on length: " + n, 1.0*expected, d.maxf(n), EPSILON);
+			assertEquals(expected, d.max(n), "Failed on length: " + n);
+			assertEquals(1.0*expected, d.maxf(n), EPSILON, "Failed on length: " + n);
 		}
 	}
 	
@@ -77,8 +76,8 @@ public void testAcyclicEdgeDistance() {
 		AcyclicEdgeDistance d = new AcyclicEdgeDistance();
 		for (int n = 0; n <= 7; n++) {
 			int expected = bruteForceComputeMax(d,n);
-			assertEquals("Failed on length: " + n, expected, d.max(n));
-			assertEquals("Failed on length: " + n, 1.0*expected, d.maxf(n), EPSILON);
+			assertEquals(expected, d.max(n), "Failed on length: " + n);
+			assertEquals(1.0*expected, d.maxf(n), EPSILON, "Failed on length: " + n);
 		}
 	}
 	
@@ -87,8 +86,8 @@ public void testCyclicEdgeDistance() {
 		CyclicEdgeDistance d = new CyclicEdgeDistance();
 		for (int n = 0; n <= 7; n++) {
 			int expected = bruteForceComputeMax(d,n);
-			assertEquals("Failed on length: " + n, expected, d.max(n));
-			assertEquals("Failed on length: " + n, 1.0*expected, d.maxf(n), EPSILON);
+			assertEquals(expected, d.max(n), "Failed on length: " + n);
+			assertEquals(1.0*expected, d.maxf(n), EPSILON, "Failed on length: " + n);
 		}
 	}
 	
@@ -97,8 +96,8 @@ public void testCyclicRTypeDistance() {
 		CyclicRTypeDistance d = new CyclicRTypeDistance();
 		for (int n = 0; n <= 7; n++) {
 			int expected = bruteForceComputeMax(d,n);
-			assertEquals("Failed on length: " + n, expected, d.max(n));
-			assertEquals("Failed on length: " + n, 1.0*expected, d.maxf(n), EPSILON);
+			assertEquals(expected, d.max(n), "Failed on length: " + n);
+			assertEquals(1.0*expected, d.maxf(n), EPSILON, "Failed on length: " + n);
 		}
 	}
 	
@@ -107,8 +106,8 @@ public void testRTypeDistance() {
 		RTypeDistance d = new RTypeDistance();
 		for (int n = 0; n <= 7; n++) {
 			int expected = bruteForceComputeMax(d,n);
-			assertEquals("Failed on length: " + n, expected, d.max(n));
-			assertEquals("Failed on length: " + n, 1.0*expected, d.maxf(n), EPSILON);
+			assertEquals(expected, d.max(n), "Failed on length: " + n);
+			assertEquals(1.0*expected, d.maxf(n), EPSILON, "Failed on length: " + n);
 		}
 	}
 	
@@ -117,8 +116,8 @@ public void testDeviationDistance() {
 		DeviationDistance d = new DeviationDistance();
 		for (int n = 0; n <= 7; n++) {
 			int expected = bruteForceComputeMax(d,n);
-			assertEquals("Failed on length: " + n, expected, d.max(n));
-			assertEquals("Failed on length: " + n, 1.0*expected, d.maxf(n), EPSILON);
+			assertEquals(expected, d.max(n), "Failed on length: " + n);
+			assertEquals(1.0*expected, d.maxf(n), EPSILON, "Failed on length: " + n);
 		}
 	}
 	
@@ -126,7 +125,7 @@ public void testDeviationDistance() {
 	public void testDeviationDistanceNormalized() {
 		DeviationDistanceNormalized d = new DeviationDistanceNormalized();
 		for (int n = 0; n <= 7; n++) {
-			assertEquals("Failed on length: " + n, bruteForceComputeMaxD(d,n), d.maxf(n), EPSILON);
+			assertEquals(bruteForceComputeMaxD(d,n), d.maxf(n), EPSILON, "Failed on length: " + n);
 		}
 	}
 	
@@ -134,7 +133,7 @@ public void testDeviationDistanceNormalized() {
 	public void testDeviationDistanceNormalized2005() {
 		DeviationDistanceNormalized2005 d = new DeviationDistanceNormalized2005();
 		for (int n = 0; n <= 7; n++) {
-			assertEquals("Failed on length: " + n, bruteForceComputeMaxD(d,n), d.maxf(n), EPSILON);
+			assertEquals(bruteForceComputeMaxD(d,n), d.maxf(n), EPSILON, "Failed on length: " + n);
 		}
 	}
 	
@@ -143,8 +142,8 @@ public void testSquaredDeviationDistance() {
 		SquaredDeviationDistance d = new SquaredDeviationDistance();
 		for (int n = 0; n <= 7; n++) {
 			int expected = bruteForceComputeMax(d,n);
-			assertEquals("Failed on length: " + n, expected, d.max(n));
-			assertEquals("Failed on length: " + n, 1.0*expected, d.maxf(n), EPSILON);
+			assertEquals(expected, d.max(n), "Failed on length: " + n);
+			assertEquals(1.0*expected, d.maxf(n), EPSILON, "Failed on length: " + n);
 		}
 	}
 	
@@ -153,8 +152,8 @@ public void testLeeDistance() {
 		LeeDistance d = new LeeDistance();
 		for (int n = 0; n <= 7; n++) {
 			int expected = bruteForceComputeMax(d,n);
-			assertEquals("Failed on length: " + n, expected, d.max(n));
-			assertEquals("Failed on length: " + n, 1.0*expected, d.maxf(n), EPSILON);
+			assertEquals(expected, d.max(n), "Failed on length: " + n);
+			assertEquals(1.0*expected, d.maxf(n), EPSILON, "Failed on length: " + n);
 		}
 	}
 	
@@ -163,8 +162,8 @@ public void testExactMatchDistance() {
 		ExactMatchDistance d = new ExactMatchDistance();
 		for (int n = 0; n <= 7; n++) {
 			int expected = bruteForceComputeMax(d,n);
-			assertEquals("Failed on length: " + n, expected, d.max(n));
-			assertEquals("Failed on length: " + n, 1.0*expected, d.maxf(n), EPSILON);
+			assertEquals(expected, d.max(n), "Failed on length: " + n);
+			assertEquals(1.0*expected, d.maxf(n), EPSILON, "Failed on length: " + n);
 		}
 	}
 	
@@ -173,8 +172,8 @@ public void testInterchangeDistance() {
 		InterchangeDistance d = new InterchangeDistance();
 		for (int n = 0; n <= 7; n++) {
 			int expected = bruteForceComputeMax(d,n);
-			assertEquals("Failed on length: " + n, expected, d.max(n));
-			assertEquals("Failed on length: " + n, 1.0*expected, d.maxf(n), EPSILON);
+			assertEquals(expected, d.max(n), "Failed on length: " + n);
+			assertEquals(1.0*expected, d.maxf(n), EPSILON, "Failed on length: " + n);
 		}
 	}
 	
@@ -183,8 +182,8 @@ public void testKendallTauDistance() {
 		KendallTauDistance d = new KendallTauDistance();
 		for (int n = 0; n <= 7; n++) {
 			int expected = bruteForceComputeMax(d,n);
-			assertEquals("Failed on length: " + n, expected, d.max(n));
-			assertEquals("Failed on length: " + n, 1.0*expected, d.maxf(n), EPSILON);
+			assertEquals(expected, d.max(n), "Failed on length: " + n);
+			assertEquals(1.0*expected, d.maxf(n), EPSILON, "Failed on length: " + n);
 		}
 	}
 	
@@ -194,8 +193,8 @@ public void testReinsertionDistance() {
 		ReinsertionDistance d = new ReinsertionDistance();
 		for (int n = 0; n <= 7; n++) {
 			int expected = bruteForceComputeMax(d,n);
-			assertEquals("Failed on length: " + n, expected, d.max(n));
-			assertEquals("Failed on length: " + n, 1.0*expected, d.maxf(n), EPSILON);
+			assertEquals(expected, d.max(n), "Failed on length: " + n);
+			assertEquals(1.0*expected, d.maxf(n), EPSILON, "Failed on length: " + n);
 		}
 	}
 	
diff --git a/src/test/java/org/cicirello/permutations/distance/PermutationDistanceNormTests.java b/src/test/java/org/cicirello/permutations/distance/PermutationDistanceNormTests.java
index cf66181b..3e3a6743 100644
--- a/src/test/java/org/cicirello/permutations/distance/PermutationDistanceNormTests.java
+++ b/src/test/java/org/cicirello/permutations/distance/PermutationDistanceNormTests.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2019 Vincent A. Cicirello, <https://www.cicirello.org/>.
+ * Copyright 2019-2022 Vincent A. Cicirello, <https://www.cicirello.org/>.
  *
  * This file is part of JavaPermutationTools (https://jpt.cicirello.org/).
  *
@@ -21,12 +21,12 @@
  */
 package org.cicirello.permutations.distance;
 
-import org.junit.*;
-import static org.junit.Assert.*;
+import org.junit.jupiter.api.*;
+import static org.junit.jupiter.api.Assertions.*;
 import org.cicirello.permutations.*;
 
 /**
- * JUnit 4 tests for the normalizedDistance method of various classes that implement permutation distance metrics.
+ * JUnit tests for the normalizedDistance method of various classes that implement permutation distance metrics.
  */
 public class PermutationDistanceNormTests {
 	
@@ -36,7 +36,7 @@ public class PermutationDistanceNormTests {
 	public void testBlockInterchangeDistance() {
 		BlockInterchangeDistance d = new BlockInterchangeDistance();
 		for (int n = 0; n <= 7; n++) {
-			assertEquals("Failed on length: " + n, n<=1 ? 0.0 : 1.0, bruteForceComputeMax(d,n), EPSILON);
+			assertEquals(n<=1 ? 0.0 : 1.0, bruteForceComputeMax(d,n), EPSILON, "Failed on length: " + n);
 		}
 	}
 	
@@ -44,7 +44,7 @@ public void testBlockInterchangeDistance() {
 	public void testAcyclicEdgeDistance() {
 		AcyclicEdgeDistance d = new AcyclicEdgeDistance();
 		for (int n = 0; n <= 7; n++) {
-			assertEquals("Failed on length: " + n, n<=2 ? 0.0 : 1.0, bruteForceComputeMax(d,n), EPSILON);
+			assertEquals(n<=2 ? 0.0 : 1.0, bruteForceComputeMax(d,n), EPSILON, "Failed on length: " + n);
 		}
 	}
 	
@@ -52,7 +52,7 @@ public void testAcyclicEdgeDistance() {
 	public void testCyclicEdgeDistance() {
 		CyclicEdgeDistance d = new CyclicEdgeDistance();
 		for (int n = 0; n <= 7; n++) {
-			assertEquals("Failed on length: " + n, n<=3 ? 0.0 : 1.0, bruteForceComputeMax(d,n), EPSILON);
+			assertEquals(n<=3 ? 0.0 : 1.0, bruteForceComputeMax(d,n), EPSILON, "Failed on length: " + n);
 		}
 	}
 	
@@ -60,7 +60,7 @@ public void testCyclicEdgeDistance() {
 	public void testCyclicRTypeDistance() {
 		CyclicRTypeDistance d = new CyclicRTypeDistance();
 		for (int n = 0; n <= 7; n++) {
-			assertEquals("Failed on length: " + n, n<=2 ? 0.0 : 1.0, bruteForceComputeMax(d,n), EPSILON);
+			assertEquals(n<=2 ? 0.0 : 1.0, bruteForceComputeMax(d,n), EPSILON, "Failed on length: " + n);
 		}
 	}
 	
@@ -68,7 +68,7 @@ public void testCyclicRTypeDistance() {
 	public void testRTypeDistance() {
 		RTypeDistance d = new RTypeDistance();
 		for (int n = 0; n <= 7; n++) {
-			assertEquals("Failed on length: " + n, n<=1 ? 0.0 : 1.0, bruteForceComputeMax(d,n), EPSILON);
+			assertEquals(n<=1 ? 0.0 : 1.0, bruteForceComputeMax(d,n), EPSILON, "Failed on length: " + n);
 		}
 	}
 	
@@ -76,7 +76,7 @@ public void testRTypeDistance() {
 	public void testDeviationDistance() {
 		DeviationDistance d = new DeviationDistance();
 		for (int n = 0; n <= 7; n++) {
-			assertEquals("Failed on length: " + n, n<=1 ? 0.0 : 1.0, bruteForceComputeMax(d,n), EPSILON);
+			assertEquals(n<=1 ? 0.0 : 1.0, bruteForceComputeMax(d,n), EPSILON, "Failed on length: " + n);
 		}
 	}
 	
@@ -84,7 +84,7 @@ public void testDeviationDistance() {
 	public void testDeviationDistanceNormalized() {
 		DeviationDistanceNormalized d = new DeviationDistanceNormalized();
 		for (int n = 0; n <= 7; n++) {
-			assertEquals("Failed on length: " + n, n<=1 ? 0.0 : 1.0, bruteForceComputeMaxD(d,n), EPSILON);
+			assertEquals(n<=1 ? 0.0 : 1.0, bruteForceComputeMaxD(d,n), EPSILON, "Failed on length: " + n);
 		}
 	}
 	
@@ -92,7 +92,7 @@ public void testDeviationDistanceNormalized() {
 	public void testDeviationDistanceNormalized2005() {
 		DeviationDistanceNormalized2005 d = new DeviationDistanceNormalized2005();
 		for (int n = 0; n <= 7; n++) {
-			assertEquals("Failed on length: " + n, n<=1 ? 0.0 : 1.0, bruteForceComputeMaxD(d,n), EPSILON);
+			assertEquals(n<=1 ? 0.0 : 1.0, bruteForceComputeMaxD(d,n), EPSILON, "Failed on length: " + n);
 		}
 	}
 	
@@ -100,7 +100,7 @@ public void testDeviationDistanceNormalized2005() {
 	public void testSquaredDeviationDistance() {
 		SquaredDeviationDistance d = new SquaredDeviationDistance();
 		for (int n = 0; n <= 7; n++) {
-			assertEquals("Failed on length: " + n, n<=1 ? 0.0 : 1.0, bruteForceComputeMax(d,n), EPSILON);
+			assertEquals(n<=1 ? 0.0 : 1.0, bruteForceComputeMax(d,n), EPSILON, "Failed on length: " + n);
 		}
 	}
 	
@@ -108,7 +108,7 @@ public void testSquaredDeviationDistance() {
 	public void testLeeDistance() {
 		LeeDistance d = new LeeDistance();
 		for (int n = 0; n <= 7; n++) {
-			assertEquals("Failed on length: " + n, n<=1 ? 0.0 : 1.0, bruteForceComputeMax(d,n), EPSILON);
+			assertEquals(n<=1 ? 0.0 : 1.0, bruteForceComputeMax(d,n), EPSILON, "Failed on length: " + n);
 		}
 	}
 	
@@ -116,7 +116,7 @@ public void testLeeDistance() {
 	public void testExactMatchDistance() {
 		ExactMatchDistance d = new ExactMatchDistance();
 		for (int n = 0; n <= 7; n++) {
-			assertEquals("Failed on length: " + n, n<=1 ? 0.0 : 1.0, bruteForceComputeMax(d,n), EPSILON);
+			assertEquals(n<=1 ? 0.0 : 1.0, bruteForceComputeMax(d,n), EPSILON, "Failed on length: " + n);
 		}
 	}
 	
@@ -124,7 +124,7 @@ public void testExactMatchDistance() {
 	public void testInterchangeDistance() {
 		InterchangeDistance d = new InterchangeDistance();
 		for (int n = 0; n <= 7; n++) {
-			assertEquals("Failed on length: " + n, n<=1 ? 0.0 : 1.0, bruteForceComputeMax(d,n), EPSILON);
+			assertEquals(n<=1 ? 0.0 : 1.0, bruteForceComputeMax(d,n), EPSILON, "Failed on length: " + n);
 		}
 	}
 	
@@ -132,7 +132,7 @@ public void testInterchangeDistance() {
 	public void testKendallTauDistance() {
 		KendallTauDistance d = new KendallTauDistance();
 		for (int n = 0; n <= 7; n++) {
-			assertEquals("Failed on length: " + n, n<=1 ? 0.0 : 1.0, bruteForceComputeMax(d,n), EPSILON);
+			assertEquals(n<=1 ? 0.0 : 1.0, bruteForceComputeMax(d,n), EPSILON, "Failed on length: " + n);
 		}
 	}
 	
@@ -141,7 +141,7 @@ public void testKendallTauDistance() {
 	public void testReinsertionDistance() {
 		ReinsertionDistance d = new ReinsertionDistance();
 		for (int n = 0; n <= 7; n++) {
-			assertEquals("Failed on length: " + n, n<=1 ? 0.0 : 1.0, bruteForceComputeMax(d,n), EPSILON);
+			assertEquals(n<=1 ? 0.0 : 1.0, bruteForceComputeMax(d,n), EPSILON, "Failed on length: " + n);
 		}
 	}
 	
diff --git a/src/test/java/org/cicirello/permutations/distance/PermutationDistanceTests.java b/src/test/java/org/cicirello/permutations/distance/PermutationDistanceTests.java
index 5436d457..0f98cec7 100644
--- a/src/test/java/org/cicirello/permutations/distance/PermutationDistanceTests.java
+++ b/src/test/java/org/cicirello/permutations/distance/PermutationDistanceTests.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2018-2021 Vincent A. Cicirello, <https://www.cicirello.org/>.
+ * Copyright 2018-2022 Vincent A. Cicirello, <https://www.cicirello.org/>.
  *
  * This file is part of JavaPermutationTools (https://jpt.cicirello.org/).
  *
@@ -21,12 +21,12 @@
  */
 package org.cicirello.permutations.distance;
 
-import org.junit.*;
-import static org.junit.Assert.*;
+import org.junit.jupiter.api.*;
+import static org.junit.jupiter.api.Assertions.*;
 import org.cicirello.permutations.*;
 
 /**
- * JUnit 4 tests for the various classes that implement permutation distance metrics.
+ * JUnit tests for the various classes that implement permutation distance metrics.
  */
 public class PermutationDistanceTests {
 	
@@ -280,8 +280,8 @@ public void testBlockInterchangeDistance() {
 			Permutation p = new Permutation(i);
 			Permutation rev = new Permutation(p);
 			rev.reverse();
-			assertEquals("maximal distance", i/2, d.distance(p, rev));
-			assertEquals("maximal distance", i/2, d.distance(rev, p));
+			assertEquals(i/2, d.distance(p, rev));
+			assertEquals(i/2, d.distance(rev, p));
 		}
 		int[] a = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
 		int[] a1 = {0, 5, 2, 3, 4, 1, 6, 7, 8, 9};
@@ -304,24 +304,24 @@ public void testBlockInterchangeDistance() {
 		Permutation p4 = new Permutation(a4);
 		Permutation p5 = new Permutation(a5);
 		// these cases are all 1 block interchange of varying size blocks
-		assertEquals("1 block interchange length 1", 1, d.distance(p, p1));
-		assertEquals("1 block interchange length 2", 1, d.distance(p, p2));
-		assertEquals("1 block interchange length 3", 1, d.distance(p, p3));
-		assertEquals("1 block interchange length 4", 1, d.distance(p, p4));
-		assertEquals("1 block interchange length 5", 1, d.distance(p, p5));
-		assertEquals("1 block interchange length 1", 1, d.distance(p1, p));
-		assertEquals("1 block interchange length 2", 1, d.distance(p2, p));
-		assertEquals("1 block interchange length 3", 1, d.distance(p3, p));
-		assertEquals("1 block interchange length 4", 1, d.distance(p4, p));
-		assertEquals("1 block interchange length 5", 1, d.distance(p5, p));
-		assertEquals("1 block interchange lengths 1,2", 1, d.distance(p, p12));
-		assertEquals("1 block interchange lengths 1,3", 1, d.distance(p, p13));
-		assertEquals("1 block interchange lengths 1,2", 1, d.distance(p12, p));
-		assertEquals("1 block interchange lengths 1,3", 1, d.distance(p13, p));
-		assertEquals("1 block interchange lengths 2,3", 1, d.distance(p, p23));
-		assertEquals("1 block interchange lengths 2,4", 1, d.distance(p, p24));
-		assertEquals("1 block interchange lengths 2,3", 1, d.distance(p23, p));
-		assertEquals("1 block interchange lengths 2,4", 1, d.distance(p24, p));
+		assertEquals(1, d.distance(p, p1));
+		assertEquals(1, d.distance(p, p2));
+		assertEquals(1, d.distance(p, p3));
+		assertEquals(1, d.distance(p, p4));
+		assertEquals(1, d.distance(p, p5));
+		assertEquals(1, d.distance(p1, p));
+		assertEquals(1, d.distance(p2, p));
+		assertEquals(1, d.distance(p3, p));
+		assertEquals(1, d.distance(p4, p));
+		assertEquals(1, d.distance(p5, p));
+		assertEquals(1, d.distance(p, p12));
+		assertEquals(1, d.distance(p, p13));
+		assertEquals(1, d.distance(p12, p));
+		assertEquals(1, d.distance(p13, p));
+		assertEquals(1, d.distance(p, p23));
+		assertEquals(1, d.distance(p, p24));
+		assertEquals(1, d.distance(p23, p));
+		assertEquals(1, d.distance(p24, p));
 		
 		IllegalArgumentException thrown = assertThrows( 
 			IllegalArgumentException.class,
@@ -340,12 +340,12 @@ public void testAcyclicEdgeDistance() {
 		Permutation p1 = new Permutation(a1);
 		Permutation p2 = new Permutation(a2);
 		Permutation p3 = new Permutation(a3);
-		assertEquals("maximal distance", 5, d.distance(p1, p2));
+		assertEquals(5, d.distance(p1, p2));
 		p2.reverse();
-		assertEquals("reversal invariant maximal distance", 5, d.distance(p1, p2));
-		assertEquals("intermediate distance", 2, d.distance(p1, p3));
+		assertEquals(5, d.distance(p1, p2));
+		assertEquals(2, d.distance(p1, p3));
 		p3.reverse();
-		assertEquals("reversal invariant intermediate distance", 2, d.distance(p1, p3));
+		assertEquals(2, d.distance(p1, p3));
 		
 		IllegalArgumentException thrown = assertThrows( 
 			IllegalArgumentException.class,
@@ -365,21 +365,21 @@ public void testCyclicEdgeDistance() {
 		Permutation p1 = new Permutation(a1);
 		Permutation p2 = new Permutation(a2);
 		Permutation p3 = new Permutation(a3);
-		assertEquals("maximal distance", 6, d.distance(p1, p2));
+		assertEquals(6, d.distance(p1, p2));
 		p2.reverse();
-		assertEquals("reversal invariant maximal distance", 6, d.distance(p1, p2));
+		assertEquals(6, d.distance(p1, p2));
 		p2.reverse();
 		for (int i = 1; i < a1.length; i++) {
 			p2.rotate(1);
-			assertEquals("rotational invariant maximal distance", 6, d.distance(p1, p2));
+			assertEquals(6, d.distance(p1, p2));
 		}
-		assertEquals("intermediate distance", 3, d.distance(p1, p3));
+		assertEquals(3, d.distance(p1, p3));
 		p3.reverse();
-		assertEquals("reversal invariant intermediate distance", 3, d.distance(p1, p3));
+		assertEquals(3, d.distance(p1, p3));
 		p3.reverse();
 		for (int i = 1; i < a1.length; i++) {
 			p3.rotate(1);
-			assertEquals("rotational invariant intermediate distance", 3, d.distance(p1, p3));
+			assertEquals(3, d.distance(p1, p3));
 		}
 		
 		IllegalArgumentException thrown = assertThrows( 
@@ -399,19 +399,19 @@ public void testCyclicRTypeDistance() {
 		Permutation p1 = new Permutation(a1);
 		Permutation p2 = new Permutation(a2);
 		Permutation p3 = new Permutation(a3);
-		assertEquals("maximal distance", 6, d.distance(p1, p2));
+		assertEquals(6, d.distance(p1, p2));
 		for (int i = 1; i < a1.length; i++) {
 			p2.rotate(1);
-			assertEquals("rotational invariant maximal distance", 6, d.distance(p1, p2));
+			assertEquals(6, d.distance(p1, p2));
 		}
-		assertEquals("intermediate distance", 3, d.distance(p1, p3));
+		assertEquals(3, d.distance(p1, p3));
 		for (int i = 1; i < a1.length; i++) {
 			p3.rotate(1);
-			assertEquals("rotational invariant intermediate distance", 3, d.distance(p1, p3));
+			assertEquals(3, d.distance(p1, p3));
 		}
 		Permutation r = new Permutation(p1);
 		r.reverse();
-		assertEquals("reverse is maximal distance", 6, d.distance(p1, r));
+		assertEquals(6, d.distance(p1, r));
 		
 		IllegalArgumentException thrown = assertThrows( 
 			IllegalArgumentException.class,
@@ -429,11 +429,11 @@ public void testRTypeDistance() {
 		Permutation p1 = new Permutation(a1);
 		Permutation p2 = new Permutation(a2);
 		Permutation p3 = new Permutation(a3);
-		assertEquals("maximal distance", 5, d.distance(p1, p2));
-		assertEquals("intermediate distance", 2, d.distance(p1, p3));
+		assertEquals(5, d.distance(p1, p2));
+		assertEquals(2, d.distance(p1, p3));
 		Permutation r = new Permutation(p1);
 		r.reverse();
-		assertEquals("reverse is maximal distance", 5, d.distance(p1, r));
+		assertEquals(5, d.distance(p1, r));
 		
 		IllegalArgumentException thrown = assertThrows( 
 			IllegalArgumentException.class,
@@ -452,7 +452,7 @@ public void testDeviationDistance() {
 				// rotations are a special case that are easy to compute analytically (perfect for unit tests)
 				copy.rotate(1);
 				int expected = 2*i*(n-i);
-				assertEquals("deviation distance", expected, d.distance(p, copy));
+				assertEquals(expected, d.distance(p, copy));
 			}
 		}
 		
@@ -474,7 +474,7 @@ public void testDeviationDistanceNormalized() {
 				copy.rotate(1);
 				int expected = 2*i*(n-i);
 				double expectedD = expected / (n-1.0);
-				assertEquals("deviation distance", expectedD, d.distancef(p, copy), EPSILON);
+				assertEquals(expectedD, d.distancef(p, copy), EPSILON);
 			}
 		}
 		
@@ -501,10 +501,10 @@ public void testDeviationDistanceNormalized2005() {
 				if (n%2==1) norm--;
 				norm /= 2;
 				double expectedD = expected / (norm*1.0);
-				assertEquals("deviation distance", expectedD, d.distancef(p, copy), EPSILON);
+				assertEquals(expectedD, d.distancef(p, copy), EPSILON);
 			}
 			// Reverse of permutation should be distance 1.0 from original.
-			assertEquals("deviation distance", 1, d.distancef(p, reversed), EPSILON);
+			assertEquals(1, d.distancef(p, reversed), EPSILON);
 		}
 		
 		IllegalArgumentException thrown = assertThrows( 
@@ -524,7 +524,7 @@ public void testSquaredDeviationDistance() {
 				// rotations are a special case that are easy to compute analytically (perfect for unit tests)
 				copy.rotate(1);
 				int expected = i*i*(n-i) + i*(n-i)*(n-i);
-				assertEquals("squared deviation distance", expected, d.distance(p, copy));
+				assertEquals(expected, d.distance(p, copy));
 			}
 		}
 		
@@ -545,7 +545,7 @@ public void testLeeDistance() {
 				// rotations are a special case that are easy to compute analytically (perfect for unit tests)
 				copy.rotate(1);
 				int expected = Math.min(i,n-i)*n;
-				assertEquals("Lee distance", expected, d.distance(p, copy));
+				assertEquals(expected, d.distance(p, copy));
 			}
 		}
 		
@@ -567,9 +567,9 @@ public void testExactMatchDistance() {
 		Permutation p2 = new Permutation(a2);
 		Permutation p3 = new Permutation(a3);
 		Permutation p4 = new Permutation(a4);
-		assertEquals("maximal distance", 6, d.distance(p1,p2));
-		assertEquals("end points differ", 2, d.distance(p1,p3));
-		assertEquals("differ in interior positions", 2, d.distance(p1,p4));
+		assertEquals(6, d.distance(p1,p2));
+		assertEquals(2, d.distance(p1,p3));
+		assertEquals(2, d.distance(p1,p4));
 		
 		IllegalArgumentException thrown = assertThrows( 
 			IllegalArgumentException.class,
@@ -592,10 +592,10 @@ public void testInterchangeDistance() {
 		Permutation p4 = new Permutation(a4);
 		Permutation p5 = new Permutation(a5);
 
-		assertEquals("maximal distance, one permutation cycle", 5, d.distance(p1,p2));
-		assertEquals("end points switched", 1, d.distance(p1,p3));
-		assertEquals("one swap different", 1, d.distance(p1,p4));
-		assertEquals("two permutation cycles", 4, d.distance(p1,p5));
+		assertEquals(5, d.distance(p1,p2));
+		assertEquals(1, d.distance(p1,p3));
+		assertEquals(1, d.distance(p1,p4));
+		assertEquals(4, d.distance(p1,p5));
 		
 		IllegalArgumentException thrown = assertThrows( 
 			IllegalArgumentException.class,
@@ -613,15 +613,15 @@ public void testKendallTauDistance() {
 			Permutation copy = new Permutation(p);
 			copy.reverse();
 			int expected = n*(n-1)/2;
-			assertEquals("maximal distance", expected, d.distance(p,copy));
+			assertEquals(expected, d.distance(p,copy));
 			copy.reverse();
 			copy.swap(0,n-1);
 			expected = 2*n-3;
-			assertEquals("end points swapped", expected, d.distance(p,copy));
+			assertEquals(expected, d.distance(p,copy));
 		}
 		Permutation p = new Permutation(6);
 		for (Permutation q : p) {
-			assertEquals("checking consistence with naive implementation", naiveKendalTau(p,q), d.distance(p,q));
+			assertEquals(naiveKendalTau(p,q), d.distance(p,q));
 		}
 		
 		IllegalArgumentException thrown = assertThrows( 
@@ -656,8 +656,8 @@ public void testReinsertionDistance() {
 			Permutation copy = new Permutation(p);
 			copy.reverse();
 			int expected = n-1;
-			assertEquals("maximal distance", expected, d.distance(p,copy));
-			assertEquals("maximal distance", expected, d.distance(copy,p));
+			assertEquals(expected, d.distance(p,copy));
+			assertEquals(expected, d.distance(copy,p));
 		}
 		int[] a1 = {0, 1, 2, 3, 4, 5};
 		int[] a2 = {0, 4, 2, 3, 1, 5};
@@ -667,17 +667,17 @@ public void testReinsertionDistance() {
 		Permutation p2 = new Permutation(a2);
 		Permutation p3 = new Permutation(a3);
 		Permutation p4 = new Permutation(a4);
-		assertEquals("all but 2 on longest common subsequence", 2, d.distance(p1,p2));
-		assertEquals("all but 3 on longest common subsequence", 3, d.distance(p1,p3));
-		assertEquals("all but 3 on longest common subsequence", 3, d.distance(p1,p4));
+		assertEquals(2, d.distance(p1,p2));
+		assertEquals(3, d.distance(p1,p3));
+		assertEquals(3, d.distance(p1,p4));
 		
 		Permutation p = new Permutation(5);
 		EditDistance edit = new EditDistance();
 		for (Permutation q : p) {
 			// NOTE: If this assertion fails, problem is either in ReinsertionDistance or EditDistance
 			// Should correspond if they are both correct.
-			assertEquals("equiv of edit with 0.5 cost removes and inserts", edit.distancef(p,q), d.distancef(p,q), EPSILON);
-			assertEquals("equiv of edit with 0.5 cost removes and inserts", edit.distancef(q,p), d.distancef(q,p), EPSILON);
+			assertEquals(edit.distancef(p,q), d.distancef(p,q), EPSILON);
+			assertEquals(edit.distancef(q,p), d.distancef(q,p), EPSILON);
 		}	
 		
 		IllegalArgumentException thrown = assertThrows( 
@@ -697,7 +697,7 @@ public void testEditDistance() {
 			for (int i = 0; i < 10; i++) {
 				Permutation p1 = new Permutation(n);
 				Permutation p2 = new Permutation(n);
-				assertEquals("equiv of reinsertion", reinsert.distancef(p1,p2), d.distancef(p1,p2), EPSILON);
+				assertEquals(reinsert.distancef(p1,p2), d.distancef(p1,p2), EPSILON);
 			}
 		}
 		// following parameter values result in equivalent of exact match distance (just computed differently).
@@ -707,7 +707,7 @@ public void testEditDistance() {
 			for (int i = 0; i < 10; i++) {
 				Permutation p1 = new Permutation(n);
 				Permutation p2 = new Permutation(n);
-				assertEquals("equiv of exact match", em.distancef(p1,p2), d.distancef(p1,p2), EPSILON);
+				assertEquals(em.distancef(p1,p2), d.distancef(p1,p2), EPSILON);
 			}
 		}
 		// following parameter values result in equivalent of 2.5 * exact match distance.
@@ -716,7 +716,7 @@ public void testEditDistance() {
 			for (int i = 0; i < 10; i++) {
 				Permutation p1 = new Permutation(n);
 				Permutation p2 = new Permutation(n);
-				assertEquals("equiv of 2.5 exact match", 2.5*em.distancef(p1,p2), d.distancef(p1,p2), EPSILON);
+				assertEquals(2.5*em.distancef(p1,p2), d.distancef(p1,p2), EPSILON);
 			}
 		}
 		// following parameter values result in equivalent of 2.25 * reinsertion distance.
@@ -725,7 +725,7 @@ public void testEditDistance() {
 			for (int i = 0; i < 10; i++) {
 				Permutation p1 = new Permutation(n);
 				Permutation p2 = new Permutation(n);
-				assertEquals("equiv of 2.25 reinsertion", 2.25*reinsert.distancef(p1,p2), d.distancef(p1,p2), EPSILON);
+				assertEquals(2.25*reinsert.distancef(p1,p2), d.distancef(p1,p2), EPSILON);
 			}
 		}
 		
@@ -741,8 +741,8 @@ private void identicalPermutations(PermutationDistanceMeasurer d) {
 		for (int n = 0; n <= 10; n++) {
 			Permutation p = new Permutation(n);
 			Permutation copy = new Permutation(p);
-			assertEquals("distance of a permutation to itself should be 0; length was " + n, 0, d.distance(p, copy));
-			assertEquals("distance of a permutation to itself should be 0; length was " + n, 0, d.distance(p, p));
+			assertEquals(0, d.distance(p, copy), "distance of a permutation to itself should be 0; length was " + n);
+			assertEquals(0, d.distance(p, p), "distance of a permutation to itself should be 0; length was " + n);
 		}
 	}
 	
@@ -750,8 +750,8 @@ private void identicalPermutationsDouble(PermutationDistanceMeasurerDouble d) {
 		for (int n = 0; n <= 10; n++) {
 			Permutation p = new Permutation(n);
 			Permutation copy = new Permutation(p);
-			assertEquals("distance of a permutation to itself should be 0; length was " + n, 0.0, d.distancef(p, copy), EPSILON);
-			assertEquals("distance of a permutation to itself should be 0; length was " + n, 0.0, d.distancef(p, p), EPSILON);
+			assertEquals(0.0, d.distancef(p, copy), EPSILON, "distance of a permutation to itself should be 0; length was " + n);
+			assertEquals(0.0, d.distancef(p, p), EPSILON, "distance of a permutation to itself should be 0; length was " + n);
 		}
 	}
 	
@@ -760,7 +760,7 @@ private void reversalInvariance(PermutationDistanceMeasurer d) {
 			Permutation p = new Permutation(n);
 			Permutation copy = new Permutation(p);
 			copy.reverse();
-			assertEquals("reversal invariant distance metric", 0, d.distance(p, copy));
+			assertEquals(0, d.distance(p, copy));
 		}
 	}
 	
@@ -770,7 +770,7 @@ private void rotationalInvariance(PermutationDistanceMeasurer d) {
 			Permutation copy = new Permutation(p);
 			for (int i = 1; i < n; i++) {
 				copy.rotate(1);
-				assertEquals("rotational invariant distance metric", 0, d.distance(p, copy));
+				assertEquals(0, d.distance(p, copy));
 			}
 		}
 	}
diff --git a/src/test/java/org/cicirello/sequences/SequenceSamplerTests.java b/src/test/java/org/cicirello/sequences/SequenceSamplerTests.java
index 53ab0113..0af90b15 100644
--- a/src/test/java/org/cicirello/sequences/SequenceSamplerTests.java
+++ b/src/test/java/org/cicirello/sequences/SequenceSamplerTests.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2019-2021 Vincent A. Cicirello, <https://www.cicirello.org/>.
+ * Copyright 2019-2022 Vincent A. Cicirello, <https://www.cicirello.org/>.
  *
  * This file is part of JavaPermutationTools (https://jpt.cicirello.org/).
  *
@@ -17,17 +17,16 @@
  *
  * You should have received a copy of the GNU General Public License
  * along with JavaPermutationTools.  If not, see <http://www.gnu.org/licenses/>.
- *
  */
 package org.cicirello.sequences;
 
-import org.junit.*;
-import static org.junit.Assert.*;
+import org.junit.jupiter.api.*;
+import static org.junit.jupiter.api.Assertions.*;
 import java.util.HashMap;
 import org.cicirello.math.stats.Statistics;
 
 /**
- * JUnit 4 tests for the SequenceSampler class.
+ * JUnit tests for the SequenceSampler class.
  */
 public class SequenceSamplerTests {
 	
@@ -69,7 +68,7 @@ public void testSamplePTTest() {
 				double t = Math.abs(sqrt*(Statistics.mean(L) - n*p)/stDev);
 				double crit = TTEST_NUM_SAMPLES == 101 ? CRITICAL_VALUE_995 : CRITICAL_VALUE_995_INF;
 				System.out.println("t="+t);
-				assertTrue("t test for sample size, t="+t, t < crit);
+				assertTrue(t < crit, "t test for sample size, t="+t);
 			}
 		}
 	}
@@ -1678,7 +1677,7 @@ public void testSampleO() {
 	// validate (array, sample, k) methods
 	
 	private void validateSample(int[] array, int[] sample, int k) {
-		assertEquals("sample size", k, sample.length);
+		assertEquals(k, sample.length);
 		HashMap<Integer, Integer> counts = new HashMap<Integer, Integer>();
 		for (int i = 0; i < array.length; i++) {
 			if (counts.containsKey(array[i])) {
@@ -1698,7 +1697,7 @@ private void validateSample(int[] array, int[] sample, int k) {
 	}
 	
 	private void validateSample(long[] array, long[] sample, int k) {
-		assertEquals("sample size", k, sample.length);
+		assertEquals(k, sample.length);
 		HashMap<Long, Integer> counts = new HashMap<Long, Integer>();
 		for (int i = 0; i < array.length; i++) {
 			if (counts.containsKey(array[i])) {
@@ -1718,7 +1717,7 @@ private void validateSample(long[] array, long[] sample, int k) {
 	}
 	
 	private void validateSample(short[] array, short[] sample, int k) {
-		assertEquals("sample size", k, sample.length);
+		assertEquals(k, sample.length);
 		HashMap<Short, Integer> counts = new HashMap<Short, Integer>();
 		for (int i = 0; i < array.length; i++) {
 			if (counts.containsKey(array[i])) {
@@ -1738,7 +1737,7 @@ private void validateSample(short[] array, short[] sample, int k) {
 	}
 	
 	private void validateSample(byte[] array, byte[] sample, int k) {
-		assertEquals("sample size", k, sample.length);
+		assertEquals(k, sample.length);
 		HashMap<Byte, Integer> counts = new HashMap<Byte, Integer>();
 		for (int i = 0; i < array.length; i++) {
 			if (counts.containsKey(array[i])) {
@@ -1758,7 +1757,7 @@ private void validateSample(byte[] array, byte[] sample, int k) {
 	}
 	
 	private void validateSample(char[] array, char[] sample, int k) {
-		assertEquals("sample size", k, sample.length);
+		assertEquals(k, sample.length);
 		HashMap<Character, Integer> counts = new HashMap<Character, Integer>();
 		for (int i = 0; i < array.length; i++) {
 			if (counts.containsKey(array[i])) {
@@ -1778,7 +1777,7 @@ private void validateSample(char[] array, char[] sample, int k) {
 	}
 	
 	private void validateSample(double[] array, double[] sample, int k) {
-		assertEquals("sample size", k, sample.length);
+		assertEquals(k, sample.length);
 		HashMap<Double, Integer> counts = new HashMap<Double, Integer>();
 		for (int i = 0; i < array.length; i++) {
 			if (counts.containsKey(array[i])) {
@@ -1798,7 +1797,7 @@ private void validateSample(double[] array, double[] sample, int k) {
 	}
 	
 	private void validateSample(float[] array, float[] sample, int k) {
-		assertEquals("sample size", k, sample.length);
+		assertEquals(k, sample.length);
 		HashMap<Float, Integer> counts = new HashMap<Float, Integer>();
 		for (int i = 0; i < array.length; i++) {
 			if (counts.containsKey(array[i])) {
@@ -1818,7 +1817,7 @@ private void validateSample(float[] array, float[] sample, int k) {
 	}
 	
 	private void validateSample(String[] array, String[] sample, int k) {
-		assertEquals("sample size", k, sample.length);
+		assertEquals(k, sample.length);
 		HashMap<String, Integer> counts = new HashMap<String, Integer>();
 		for (int i = 0; i < array.length; i++) {
 			if (counts.containsKey(array[i])) {
diff --git a/src/test/java/org/cicirello/sequences/distance/SequenceDistanceTests.java b/src/test/java/org/cicirello/sequences/distance/SequenceDistanceTests.java
index 889dfd00..feac7880 100644
--- a/src/test/java/org/cicirello/sequences/distance/SequenceDistanceTests.java
+++ b/src/test/java/org/cicirello/sequences/distance/SequenceDistanceTests.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2018-2021 Vincent A. Cicirello, <https://www.cicirello.org/>.
+ * Copyright 2018-2022 Vincent A. Cicirello, <https://www.cicirello.org/>.
  *
  * This file is part of JavaPermutationTools (https://jpt.cicirello.org/).
  *
@@ -17,12 +17,11 @@
  *
  * You should have received a copy of the GNU General Public License
  * along with JavaPermutationTools.  If not, see <http://www.gnu.org/licenses/>.
- *
  */
 package org.cicirello.sequences.distance;
 
-import org.junit.*;
-import static org.junit.Assert.*;
+import org.junit.jupiter.api.*;
+import static org.junit.jupiter.api.Assertions.*;
 import org.cicirello.sequences.*;
 import java.util.concurrent.ThreadLocalRandom;
 import java.util.ArrayList;
@@ -31,7 +30,7 @@
 import org.cicirello.permutations.Permutation;
 
 /**
- * JUnit 4 tests for the various classes that implement sequence distance metrics.
+ * JUnit tests for the various classes that implement sequence distance metrics.
  */
 public class SequenceDistanceTests {
 	
@@ -42,44 +41,44 @@ public void testEMObjectSequences() {
 		ExactMatchDistance d = new ExactMatchDistance();
 		String[] a0 = {"a", "b", "c", "d", "e", "f"};
 		String[] a1 = {"a", "b", "c", "d", "e", "f"};
-		assertEquals("same", 0, d.distance(a0,a1));
-		assertEquals("same", 0, d.distance(toList(a0),toList(a1)));
+		assertEquals(0, d.distance(a0,a1), "same");
+		assertEquals(0, d.distance(toList(a0),toList(a1)), "same");
 		String[] a2 = {"f", "a", "b", "c", "d", "e"};
 		String[] a3 = {"f", "b", "c", "d", "e", "a"};
 		String[] a4 = {"a", "d", "c", "b", "e", "f"};
-		assertEquals("maximal distance", 6, d.distance(a1,a2));
-		assertEquals("end points differ", 2, d.distance(a1,a3));
-		assertEquals("differ in interior positions", 2, d.distance(a1,a4));
-		assertEquals("maximal distance", 6, d.distancef(a1,a2), EPSILON);
-		assertEquals("end points differ", 2, d.distancef(a1,a3), EPSILON);
-		assertEquals("differ in interior positions", 2, d.distancef(a1,a4), EPSILON);	
-		assertEquals("maximal distance", 6, d.distance(toList(a1),toList(a2)));
-		assertEquals("end points differ", 2, d.distance(toList(a1),toList(a3)));
-		assertEquals("differ in interior positions", 2, d.distance(toList(a1),toList(a4)));
-		assertEquals("maximal distance", 6, d.distancef(toList(a1),toList(a2)), EPSILON);
-		assertEquals("end points differ", 2, d.distancef(toList(a1),toList(a3)), EPSILON);
-		assertEquals("differ in interior positions", 2, d.distancef(toList(a1),toList(a4)), EPSILON);
+		assertEquals(6, d.distance(a1,a2), "maximal distance");
+		assertEquals(2, d.distance(a1,a3), "end points differ");
+		assertEquals(2, d.distance(a1,a4), "differ in interior positions");
+		assertEquals(6, d.distancef(a1,a2), EPSILON, "maximal distance");
+		assertEquals(2, d.distancef(a1,a3), EPSILON, "end points differ");
+		assertEquals(2, d.distancef(a1,a4), EPSILON, "differ in interior positions");	
+		assertEquals(6, d.distance(toList(a1),toList(a2)), "maximal distance");
+		assertEquals(2, d.distance(toList(a1),toList(a3)), "end points differ");
+		assertEquals(2, d.distance(toList(a1),toList(a4)), "differ in interior positions");
+		assertEquals(6, d.distancef(toList(a1),toList(a2)), EPSILON, "maximal distance");
+		assertEquals(2, d.distancef(toList(a1),toList(a3)), EPSILON, "end points differ");
+		assertEquals(2, d.distancef(toList(a1),toList(a4)), EPSILON, "differ in interior positions");
 		String[] b1 = {"a", "b", "c", "d", "e", "f", "g", "h", "i"};
 		String[] b2 = {"f", "a", "b", "c", "d", "e", "g", "h", "i"};
 		String[] b3 = {"f", "b", "c", "d", "e", "a", "g", "h", "i"};
 		String[] b4 = {"a", "d", "c", "b", "e", "f", "g", "h", "i"};
-		assertEquals("identical except for extras", 3, d.distance(a1,b1));
-		assertEquals("maximal distance", 9, d.distance(a1,b2));
-		assertEquals("end points of shorter differ", 5, d.distance(a1,b3));
-		assertEquals("differ in interior positions", 5, d.distance(a1,b4));
-		assertEquals("identical except for extras", 3, d.distance(b1,a1));
-		assertEquals("maximal distance", 9, d.distance(b2,a1));
-		assertEquals("end points of shorter differ", 5, d.distance(b3,a1));
-		assertEquals("differ in interior positions", 5, d.distance(b4,a1));
+		assertEquals(3, d.distance(a1,b1), "identical except for extras");
+		assertEquals(9, d.distance(a1,b2), "maximal distance");
+		assertEquals(5, d.distance(a1,b3), "end points of shorter differ");
+		assertEquals(5, d.distance(a1,b4), "differ in interior positions");
+		assertEquals(3, d.distance(b1,a1), "identical except for extras");
+		assertEquals(9, d.distance(b2,a1), "maximal distance");
+		assertEquals(5, d.distance(b3,a1), "end points of shorter differ");
+		assertEquals(5, d.distance(b4,a1), "differ in interior positions");
 		
-		assertEquals("identical except for extras", 3, d.distance(toList(a1),toList(b1)));
-		assertEquals("maximal distance", 9, d.distance(toList(a1),toList(b2)));
-		assertEquals("end points of shorter differ", 5, d.distance(toList(a1),toList(b3)));
-		assertEquals("differ in interior positions", 5, d.distance(toList(a1),toList(b4)));
-		assertEquals("identical except for extras", 3, d.distance(toList(b1),toList(a1)));
-		assertEquals("maximal distance", 9, d.distance(toList(b2),toList(a1)));
-		assertEquals("end points of shorter differ", 5, d.distance(toList(b3),toList(a1)));
-		assertEquals("differ in interior positions", 5, d.distance(toList(b4),toList(a1)));
+		assertEquals(3, d.distance(toList(a1),toList(b1)), "identical except for extras");
+		assertEquals(9, d.distance(toList(a1),toList(b2)), "maximal distance");
+		assertEquals(5, d.distance(toList(a1),toList(b3)), "end points of shorter differ");
+		assertEquals(5, d.distance(toList(a1),toList(b4)), "differ in interior positions");
+		assertEquals(3, d.distance(toList(b1),toList(a1)), "identical except for extras");
+		assertEquals(9, d.distance(toList(b2),toList(a1)), "maximal distance");
+		assertEquals(5, d.distance(toList(b3),toList(a1)), "end points of shorter differ");
+		assertEquals(5, d.distance(toList(b4),toList(a1)), "differ in interior positions");
 		
 		NonComparable[] c1 = new NonComparable[6];
 		NonComparable[] c2 = new NonComparable[6];
@@ -92,10 +91,10 @@ public void testEMObjectSequences() {
 		NonComparable temp = c3[0];
 		c3[0] = c3[5];
 		c3[5] = temp;
-		assertEquals("maximal distance", 6, d.distance(c1,c2));
-		assertEquals("end points differ", 2, d.distance(c1,c3));
-		assertEquals("maximal distance", 6, d.distance(toList(c1),toList(c2)));
-		assertEquals("end points differ", 2, d.distance(toList(c1),toList(c3)));
+		assertEquals(6, d.distance(c1,c2), "maximal distance");
+		assertEquals(2, d.distance(c1,c3), "end points differ");
+		assertEquals(6, d.distance(toList(c1),toList(c2)), "maximal distance");
+		assertEquals(2, d.distance(toList(c1),toList(c3)), "end points differ");
 	}
 	
 	private ArrayList<String> toList(String[] a) {
@@ -132,228 +131,228 @@ public void testExactMatchDistance() {
 			int[] a2 = {5, 0, 1, 2, 3, 4};
 			int[] a3 = {5, 1, 2, 3, 4, 0};
 			int[] a4 = {0, 3, 2, 1, 4, 5};
-			assertEquals("maximal distance", 6, d.distance(a1,a2));
-			assertEquals("end points differ", 2, d.distance(a1,a3));
-			assertEquals("differ in interior positions", 2, d.distance(a1,a4));
-			assertEquals("maximal distance", 6, d.distancef(a1,a2), EPSILON);
-			assertEquals("end points differ", 2, d.distancef(a1,a3), EPSILON);
-			assertEquals("differ in interior positions", 2, d.distancef(a1,a4), EPSILON);
+			assertEquals(6, d.distance(a1,a2), "maximal distance");
+			assertEquals(2, d.distance(a1,a3), "end points differ");
+			assertEquals(2, d.distance(a1,a4), "differ in interior positions");
+			assertEquals(6, d.distancef(a1,a2), EPSILON, "maximal distance");
+			assertEquals(2, d.distancef(a1,a3), EPSILON, "end points differ");
+			assertEquals(2, d.distancef(a1,a4), EPSILON, "differ in interior positions");
 			int[] b1 = {0, 1, 2, 3, 4, 5, 6, 7, 8};
 			int[] b2 = {5, 0, 1, 2, 3, 4, 6, 7, 8};
 			int[] b3 = {5, 1, 2, 3, 4, 0, 6, 7, 8};
 			int[] b4 = {0, 3, 2, 1, 4, 5, 6, 7, 8};
 			// tests with different length sequences
-			assertEquals("identical except for extras", 3, d.distance(a1,b1));
-			assertEquals("maximal distance", 9, d.distance(a1,b2));
-			assertEquals("end points of shorter differ", 5, d.distance(a1,b3));
-			assertEquals("differ in interior positions", 5, d.distance(a1,b4));
-			assertEquals("identical except for extras", 3, d.distance(b1,a1));
-			assertEquals("maximal distance", 9, d.distance(b2,a1));
-			assertEquals("end points of shorter differ", 5, d.distance(b3,a1));
-			assertEquals("differ in interior positions", 5, d.distance(b4,a1));
+			assertEquals(3, d.distance(a1,b1), "identical except for extras");
+			assertEquals(9, d.distance(a1,b2), "maximal distance");
+			assertEquals(5, d.distance(a1,b3), "end points of shorter differ");
+			assertEquals(5, d.distance(a1,b4), "differ in interior positions");
+			assertEquals(3, d.distance(b1,a1), "identical except for extras");
+			assertEquals(9, d.distance(b2,a1), "maximal distance");
+			assertEquals(5, d.distance(b3,a1), "end points of shorter differ");
+			assertEquals(5, d.distance(b4,a1), "differ in interior positions");
 		}
 		{ // long
 			long[] a1 = {0, 1, 2, 3, 4, 5};
 			long[] a2 = {5, 0, 1, 2, 3, 4};
 			long[] a3 = {5, 1, 2, 3, 4, 0};
 			long[] a4 = {0, 3, 2, 1, 4, 5};
-			assertEquals("maximal distance", 6, d.distance(a1,a2));
-			assertEquals("end points differ", 2, d.distance(a1,a3));
-			assertEquals("differ in interior positions", 2, d.distance(a1,a4));
-			assertEquals("maximal distance", 6, d.distancef(a1,a2), EPSILON);
-			assertEquals("end points differ", 2, d.distancef(a1,a3), EPSILON);
-			assertEquals("differ in interior positions", 2, d.distancef(a1,a4), EPSILON);
+			assertEquals(6, d.distance(a1,a2));
+			assertEquals(2, d.distance(a1,a3));
+			assertEquals(2, d.distance(a1,a4));
+			assertEquals(6, d.distancef(a1,a2), EPSILON);
+			assertEquals(2, d.distancef(a1,a3), EPSILON);
+			assertEquals(2, d.distancef(a1,a4), EPSILON);
 			long[] b1 = {0, 1, 2, 3, 4, 5, 6, 7, 8};
 			long[] b2 = {5, 0, 1, 2, 3, 4, 6, 7, 8};
 			long[] b3 = {5, 1, 2, 3, 4, 0, 6, 7, 8};
 			long[] b4 = {0, 3, 2, 1, 4, 5, 6, 7, 8};
 			// tests with different length sequences
-			assertEquals("identical except for extras", 3, d.distance(a1,b1));
-			assertEquals("maximal distance", 9, d.distance(a1,b2));
-			assertEquals("end points of shorter differ", 5, d.distance(a1,b3));
-			assertEquals("differ in interior positions", 5, d.distance(a1,b4));
-			assertEquals("identical except for extras", 3, d.distance(b1,a1));
-			assertEquals("maximal distance", 9, d.distance(b2,a1));
-			assertEquals("end points of shorter differ", 5, d.distance(b3,a1));
-			assertEquals("differ in interior positions", 5, d.distance(b4,a1));
+			assertEquals(3, d.distance(a1,b1));
+			assertEquals(9, d.distance(a1,b2));
+			assertEquals(5, d.distance(a1,b3));
+			assertEquals(5, d.distance(a1,b4));
+			assertEquals(3, d.distance(b1,a1));
+			assertEquals(9, d.distance(b2,a1));
+			assertEquals(5, d.distance(b3,a1));
+			assertEquals(5, d.distance(b4,a1));
 		}
 		{ // short
 			short[] a1 = {0, 1, 2, 3, 4, 5};
 			short[] a2 = {5, 0, 1, 2, 3, 4};
 			short[] a3 = {5, 1, 2, 3, 4, 0};
 			short[] a4 = {0, 3, 2, 1, 4, 5};
-			assertEquals("maximal distance", 6, d.distance(a1,a2));
-			assertEquals("end points differ", 2, d.distance(a1,a3));
-			assertEquals("differ in interior positions", 2, d.distance(a1,a4));
-			assertEquals("maximal distance", 6, d.distancef(a1,a2), EPSILON);
-			assertEquals("end points differ", 2, d.distancef(a1,a3), EPSILON);
-			assertEquals("differ in interior positions", 2, d.distancef(a1,a4), EPSILON);
+			assertEquals(6, d.distance(a1,a2));
+			assertEquals(2, d.distance(a1,a3));
+			assertEquals(2, d.distance(a1,a4));
+			assertEquals(6, d.distancef(a1,a2), EPSILON);
+			assertEquals(2, d.distancef(a1,a3), EPSILON);
+			assertEquals(2, d.distancef(a1,a4), EPSILON);
 			short[] b1 = {0, 1, 2, 3, 4, 5, 6, 7, 8};
 			short[] b2 = {5, 0, 1, 2, 3, 4, 6, 7, 8};
 			short[] b3 = {5, 1, 2, 3, 4, 0, 6, 7, 8};
 			short[] b4 = {0, 3, 2, 1, 4, 5, 6, 7, 8};
 			// tests with different length sequences
-			assertEquals("identical except for extras", 3, d.distance(a1,b1));
-			assertEquals("maximal distance", 9, d.distance(a1,b2));
-			assertEquals("end points of shorter differ", 5, d.distance(a1,b3));
-			assertEquals("differ in interior positions", 5, d.distance(a1,b4));
-			assertEquals("identical except for extras", 3, d.distance(b1,a1));
-			assertEquals("maximal distance", 9, d.distance(b2,a1));
-			assertEquals("end points of shorter differ", 5, d.distance(b3,a1));
-			assertEquals("differ in interior positions", 5, d.distance(b4,a1));
+			assertEquals(3, d.distance(a1,b1));
+			assertEquals(9, d.distance(a1,b2));
+			assertEquals(5, d.distance(a1,b3));
+			assertEquals(5, d.distance(a1,b4));
+			assertEquals(3, d.distance(b1,a1));
+			assertEquals(9, d.distance(b2,a1));
+			assertEquals(5, d.distance(b3,a1));
+			assertEquals(5, d.distance(b4,a1));
 		}
 		{ // byte
 			byte[] a1 = {0, 1, 2, 3, 4, 5};
 			byte[] a2 = {5, 0, 1, 2, 3, 4};
 			byte[] a3 = {5, 1, 2, 3, 4, 0};
 			byte[] a4 = {0, 3, 2, 1, 4, 5};
-			assertEquals("maximal distance", 6, d.distance(a1,a2));
-			assertEquals("end points differ", 2, d.distance(a1,a3));
-			assertEquals("differ in interior positions", 2, d.distance(a1,a4));
-			assertEquals("maximal distance", 6, d.distancef(a1,a2), EPSILON);
-			assertEquals("end points differ", 2, d.distancef(a1,a3), EPSILON);
-			assertEquals("differ in interior positions", 2, d.distancef(a1,a4), EPSILON);
+			assertEquals(6, d.distance(a1,a2));
+			assertEquals(2, d.distance(a1,a3));
+			assertEquals(2, d.distance(a1,a4));
+			assertEquals(6, d.distancef(a1,a2), EPSILON);
+			assertEquals(2, d.distancef(a1,a3), EPSILON);
+			assertEquals(2, d.distancef(a1,a4), EPSILON);
 			byte[] b1 = {0, 1, 2, 3, 4, 5, 6, 7, 8};
 			byte[] b2 = {5, 0, 1, 2, 3, 4, 6, 7, 8};
 			byte[] b3 = {5, 1, 2, 3, 4, 0, 6, 7, 8};
 			byte[] b4 = {0, 3, 2, 1, 4, 5, 6, 7, 8};
 			// tests with different length sequences
-			assertEquals("identical except for extras", 3, d.distance(a1,b1));
-			assertEquals("maximal distance", 9, d.distance(a1,b2));
-			assertEquals("end points of shorter differ", 5, d.distance(a1,b3));
-			assertEquals("differ in interior positions", 5, d.distance(a1,b4));
-			assertEquals("identical except for extras", 3, d.distance(b1,a1));
-			assertEquals("maximal distance", 9, d.distance(b2,a1));
-			assertEquals("end points of shorter differ", 5, d.distance(b3,a1));
-			assertEquals("differ in interior positions", 5, d.distance(b4,a1));
+			assertEquals(3, d.distance(a1,b1));
+			assertEquals(9, d.distance(a1,b2));
+			assertEquals(5, d.distance(a1,b3));
+			assertEquals(5, d.distance(a1,b4));
+			assertEquals(3, d.distance(b1,a1));
+			assertEquals(9, d.distance(b2,a1));
+			assertEquals(5, d.distance(b3,a1));
+			assertEquals(5, d.distance(b4,a1));
 		}
 		{ // char
 			char[] a1 = {0, 1, 2, 3, 4, 5};  
 			char[] a2 = {5, 0, 1, 2, 3, 4};
 			char[] a3 = {5, 1, 2, 3, 4, 0};
 			char[] a4 = {0, 3, 2, 1, 4, 5};
-			assertEquals("maximal distance", 6, d.distance(a1,a2));
-			assertEquals("end points differ", 2, d.distance(a1,a3));
-			assertEquals("differ in interior positions", 2, d.distance(a1,a4));
-			assertEquals("maximal distance", 6, d.distancef(a1,a2), EPSILON);
-			assertEquals("end points differ", 2, d.distancef(a1,a3), EPSILON);
-			assertEquals("differ in interior positions", 2, d.distancef(a1,a4), EPSILON);
+			assertEquals(6, d.distance(a1,a2));
+			assertEquals(2, d.distance(a1,a3));
+			assertEquals(2, d.distance(a1,a4));
+			assertEquals(6, d.distancef(a1,a2), EPSILON);
+			assertEquals(2, d.distancef(a1,a3), EPSILON);
+			assertEquals(2, d.distancef(a1,a4), EPSILON);
 			String s1 = new String(a1);
 			String s2 = new String(a2);
 			String s3 = new String(a3);
 			String s4 = new String(a4);
-			assertEquals("maximal distance", 6, d.distance(s1,s2));
-			assertEquals("end points differ", 2, d.distance(s1,s3));
-			assertEquals("differ in interior positions", 2, d.distance(s1,s4));
+			assertEquals(6, d.distance(s1,s2));
+			assertEquals(2, d.distance(s1,s3));
+			assertEquals(2, d.distance(s1,s4));
 			char[] b1 = {0, 1, 2, 3, 4, 5, 6, 7, 8};
 			char[] b2 = {5, 0, 1, 2, 3, 4, 6, 7, 8};
 			char[] b3 = {5, 1, 2, 3, 4, 0, 6, 7, 8};
 			char[] b4 = {0, 3, 2, 1, 4, 5, 6, 7, 8};
 			// tests with different length sequences
-			assertEquals("identical except for extras", 3, d.distance(a1,b1));
-			assertEquals("maximal distance", 9, d.distance(a1,b2));
-			assertEquals("end points of shorter differ", 5, d.distance(a1,b3));
-			assertEquals("differ in interior positions", 5, d.distance(a1,b4));
-			assertEquals("identical except for extras", 3, d.distance(b1,a1));
-			assertEquals("maximal distance", 9, d.distance(b2,a1));
-			assertEquals("end points of shorter differ", 5, d.distance(b3,a1));
-			assertEquals("differ in interior positions", 5, d.distance(b4,a1));
+			assertEquals(3, d.distance(a1,b1));
+			assertEquals(9, d.distance(a1,b2));
+			assertEquals(5, d.distance(a1,b3));
+			assertEquals(5, d.distance(a1,b4));
+			assertEquals(3, d.distance(b1,a1));
+			assertEquals(9, d.distance(b2,a1));
+			assertEquals(5, d.distance(b3,a1));
+			assertEquals(5, d.distance(b4,a1));
 			String t1 = new String(b1);
 			String t2 = new String(b2);
 			String t3 = new String(b3);
 			String t4 = new String(b4);
-			assertEquals("identical except for extras", 3, d.distance(s1,t1));
-			assertEquals("maximal distance", 9, d.distance(s1,t2));
-			assertEquals("end points of shorter differ", 5, d.distance(s1,t3));
-			assertEquals("differ in interior positions", 5, d.distance(s1,t4));
-			assertEquals("identical except for extras", 3, d.distance(t1,s1));
-			assertEquals("maximal distance", 9, d.distance(t2,s1));
-			assertEquals("end points of shorter differ", 5, d.distance(t3,s1));
-			assertEquals("differ in interior positions", 5, d.distance(t4,s1));
+			assertEquals(3, d.distance(s1,t1));
+			assertEquals(9, d.distance(s1,t2));
+			assertEquals(5, d.distance(s1,t3));
+			assertEquals(5, d.distance(s1,t4));
+			assertEquals(3, d.distance(t1,s1));
+			assertEquals(9, d.distance(t2,s1));
+			assertEquals(5, d.distance(t3,s1));
+			assertEquals(5, d.distance(t4,s1));
 			
-			assertEquals("identical except for extras", 3, d.distancef(s1,t1), EPSILON);
-			assertEquals("maximal distance", 9, d.distancef(s1,t2), EPSILON);
-			assertEquals("end points of shorter differ", 5, d.distancef(s1,t3), EPSILON);
-			assertEquals("differ in interior positions", 5, d.distancef(s1,t4), EPSILON);
-			assertEquals("identical except for extras", 3, d.distancef(t1,s1), EPSILON);
-			assertEquals("maximal distance", 9, d.distancef(t2,s1), EPSILON);
-			assertEquals("end points of shorter differ", 5, d.distancef(t3,s1), EPSILON);
-			assertEquals("differ in interior positions", 5, d.distancef(t4,s1), EPSILON);
+			assertEquals(3, d.distancef(s1,t1), EPSILON);
+			assertEquals(9, d.distancef(s1,t2), EPSILON);
+			assertEquals(5, d.distancef(s1,t3), EPSILON);
+			assertEquals(5, d.distancef(s1,t4), EPSILON);
+			assertEquals(3, d.distancef(t1,s1), EPSILON);
+			assertEquals(9, d.distancef(t2,s1), EPSILON);
+			assertEquals(5, d.distancef(t3,s1), EPSILON);
+			assertEquals(5, d.distancef(t4,s1), EPSILON);
 		}
 		{ // double
 			double[] a1 = {0, 1, 2, 3, 4, 5};
 			double[] a2 = {5, 0, 1, 2, 3, 4};
 			double[] a3 = {5, 1, 2, 3, 4, 0};
 			double[] a4 = {0, 3, 2, 1, 4, 5};
-			assertEquals("maximal distance", 6, d.distance(a1,a2));
-			assertEquals("end points differ", 2, d.distance(a1,a3));
-			assertEquals("differ in interior positions", 2, d.distance(a1,a4));
-			assertEquals("maximal distance", 6, d.distancef(a1,a2), EPSILON);
-			assertEquals("end points differ", 2, d.distancef(a1,a3), EPSILON);
-			assertEquals("differ in interior positions", 2, d.distancef(a1,a4), EPSILON);
+			assertEquals(6, d.distance(a1,a2));
+			assertEquals(2, d.distance(a1,a3));
+			assertEquals(2, d.distance(a1,a4));
+			assertEquals(6, d.distancef(a1,a2), EPSILON);
+			assertEquals(2, d.distancef(a1,a3), EPSILON);
+			assertEquals(2, d.distancef(a1,a4), EPSILON);
 			double[] b1 = {0, 1, 2, 3, 4, 5, 6, 7, 8};
 			double[] b2 = {5, 0, 1, 2, 3, 4, 6, 7, 8};
 			double[] b3 = {5, 1, 2, 3, 4, 0, 6, 7, 8};
 			double[] b4 = {0, 3, 2, 1, 4, 5, 6, 7, 8};
 			// tests with different length sequences
-			assertEquals("identical except for extras", 3, d.distance(a1,b1));
-			assertEquals("maximal distance", 9, d.distance(a1,b2));
-			assertEquals("end points of shorter differ", 5, d.distance(a1,b3));
-			assertEquals("differ in interior positions", 5, d.distance(a1,b4));
-			assertEquals("identical except for extras", 3, d.distance(b1,a1));
-			assertEquals("maximal distance", 9, d.distance(b2,a1));
-			assertEquals("end points of shorter differ", 5, d.distance(b3,a1));
-			assertEquals("differ in interior positions", 5, d.distance(b4,a1));
+			assertEquals(3, d.distance(a1,b1));
+			assertEquals(9, d.distance(a1,b2));
+			assertEquals(5, d.distance(a1,b3));
+			assertEquals(5, d.distance(a1,b4));
+			assertEquals(3, d.distance(b1,a1));
+			assertEquals(9, d.distance(b2,a1));
+			assertEquals(5, d.distance(b3,a1));
+			assertEquals(5, d.distance(b4,a1));
 		}
 		{ // float
 			float[] a1 = {0, 1, 2, 3, 4, 5};
 			float[] a2 = {5, 0, 1, 2, 3, 4};
 			float[] a3 = {5, 1, 2, 3, 4, 0};
 			float[] a4 = {0, 3, 2, 1, 4, 5};
-			assertEquals("maximal distance", 6, d.distance(a1,a2));
-			assertEquals("end points differ", 2, d.distance(a1,a3));
-			assertEquals("differ in interior positions", 2, d.distance(a1,a4));
-			assertEquals("maximal distance", 6, d.distancef(a1,a2), EPSILON);
-			assertEquals("end points differ", 2, d.distancef(a1,a3), EPSILON);
-			assertEquals("differ in interior positions", 2, d.distancef(a1,a4), EPSILON);
+			assertEquals(6, d.distance(a1,a2));
+			assertEquals(2, d.distance(a1,a3));
+			assertEquals(2, d.distance(a1,a4));
+			assertEquals(6, d.distancef(a1,a2), EPSILON);
+			assertEquals(2, d.distancef(a1,a3), EPSILON);
+			assertEquals(2, d.distancef(a1,a4), EPSILON);
 			float[] b1 = {0, 1, 2, 3, 4, 5, 6, 7, 8};
 			float[] b2 = {5, 0, 1, 2, 3, 4, 6, 7, 8};
 			float[] b3 = {5, 1, 2, 3, 4, 0, 6, 7, 8};
 			float[] b4 = {0, 3, 2, 1, 4, 5, 6, 7, 8};
 			// tests with different length sequences
-			assertEquals("identical except for extras", 3, d.distance(a1,b1));
-			assertEquals("maximal distance", 9, d.distance(a1,b2));
-			assertEquals("end points of shorter differ", 5, d.distance(a1,b3));
-			assertEquals("differ in interior positions", 5, d.distance(a1,b4));
-			assertEquals("identical except for extras", 3, d.distance(b1,a1));
-			assertEquals("maximal distance", 9, d.distance(b2,a1));
-			assertEquals("end points of shorter differ", 5, d.distance(b3,a1));
-			assertEquals("differ in interior positions", 5, d.distance(b4,a1));
+			assertEquals(3, d.distance(a1,b1));
+			assertEquals(9, d.distance(a1,b2));
+			assertEquals(5, d.distance(a1,b3));
+			assertEquals(5, d.distance(a1,b4));
+			assertEquals(3, d.distance(b1,a1));
+			assertEquals(9, d.distance(b2,a1));
+			assertEquals(5, d.distance(b3,a1));
+			assertEquals(5, d.distance(b4,a1));
 		}
 		{ // boolean
 			boolean[] a1 = {false, true, false, true, false, true};
 			boolean[] a2 = {true, false, true, false, true, false};
 			boolean[] a3 = {true, true, false, true, false, false};
 			boolean[] a4 = {false, true, true, false, false, true};
-			assertEquals("maximal distance", 6, d.distance(a1,a2));
-			assertEquals("end points differ", 2, d.distance(a1,a3));
-			assertEquals("differ in interior positions", 2, d.distance(a1,a4));
-			assertEquals("maximal distance", 6, d.distancef(a1,a2), EPSILON);
-			assertEquals("end points differ", 2, d.distancef(a1,a3), EPSILON);
-			assertEquals("differ in interior positions", 2, d.distancef(a1,a4), EPSILON);
+			assertEquals(6, d.distance(a1,a2));
+			assertEquals(2, d.distance(a1,a3));
+			assertEquals(2, d.distance(a1,a4));
+			assertEquals(6, d.distancef(a1,a2), EPSILON);
+			assertEquals(2, d.distancef(a1,a3), EPSILON);
+			assertEquals(2, d.distancef(a1,a4), EPSILON);
 			boolean[] b1 = {false, true, false, true, false, true, true, true, true};
 			boolean[] b2 = {true, false, true, false, true, false, false, false, false};
 			boolean[] b3 = {true, true, false, true, false, false, true, true, true};
 			boolean[] b4 = {false, true, true, false, false, true, true, true, true};
 			// tests with different length sequences
-			assertEquals("identical except for extras", 3, d.distance(a1,b1));
-			assertEquals("maximal distance", 9, d.distance(a1,b2));
-			assertEquals("end points of shorter differ", 5, d.distance(a1,b3));
-			assertEquals("differ in interior positions", 5, d.distance(a1,b4));
-			assertEquals("identical except for extras", 3, d.distance(b1,a1));
-			assertEquals("maximal distance", 9, d.distance(b2,a1));
-			assertEquals("end points of shorter differ", 5, d.distance(b3,a1));
-			assertEquals("differ in interior positions", 5, d.distance(b4,a1));
+			assertEquals(3, d.distance(a1,b1));
+			assertEquals(9, d.distance(a1,b2));
+			assertEquals(5, d.distance(a1,b3));
+			assertEquals(5, d.distance(a1,b4));
+			assertEquals(3, d.distance(b1,a1));
+			assertEquals(9, d.distance(b2,a1));
+			assertEquals(5, d.distance(b3,a1));
+			assertEquals(5, d.distance(b4,a1));
 		}
 	}
 	
@@ -860,16 +859,18 @@ public void testTauObjectSequences() {
 			}
 			s3[0] = s2[0];
 			s3[n-1] = s2[n-1];
+			// maximal distance
 			int expected = n*(n-1)/2;
-			assertEquals("maximal distance", expected, d.distance(s1,s2));
-			assertEquals("maximal distance", expected, d.distance(s2,s1));
-			assertEquals("maximal distance", expected, d.distance(toList(s1),toList(s2)));
-			assertEquals("maximal distance", expected, d.distance(toList(s2),toList(s1)));
+			assertEquals(expected, d.distance(s1,s2));
+			assertEquals(expected, d.distance(s2,s1));
+			assertEquals(expected, d.distance(toList(s1),toList(s2)));
+			assertEquals(expected, d.distance(toList(s2),toList(s1)));
+			// end points swapped
 			expected = 2*n-3;
-			assertEquals("end points swapped", expected, d.distance(s1,s3));
-			assertEquals("end points swapped", expected, d.distance(s3,s1));
-			assertEquals("end points swapped", expected, d.distance(toList(s1),toList(s3)));
-			assertEquals("end points swapped", expected, d.distance(toList(s3),toList(s1)));
+			assertEquals(expected, d.distance(s1,s3));
+			assertEquals(expected, d.distance(s3,s1));
+			assertEquals(expected, d.distance(toList(s1),toList(s3)));
+			assertEquals(expected, d.distance(toList(s3),toList(s1)));
 		}
 		for (int n = 2; n <= 8; n++) {
 			//maximal distance if all unique elements (i.e., a permutation) is reversed sequence
@@ -882,15 +883,15 @@ public void testTauObjectSequences() {
 			s3[0] = s2[0];
 			s3[n-1] = s2[n-1];
 			int expected = n*(n-1)/2;
-			assertEquals("maximal distance", expected, d.distance(s1,s2));
-			assertEquals("maximal distance", expected, d.distance(s2,s1));
-			assertEquals("maximal distance", expected, d.distance(toList(s1),toList(s2)));
-			assertEquals("maximal distance", expected, d.distance(toList(s2),toList(s1)));
+			assertEquals(expected, d.distance(s1,s2));
+			assertEquals(expected, d.distance(s2,s1));
+			assertEquals(expected, d.distance(toList(s1),toList(s2)));
+			assertEquals(expected, d.distance(toList(s2),toList(s1)));
 			expected = 2*n-3;
-			assertEquals("end points swapped", expected, d.distance(s1,s3));
-			assertEquals("end points swapped", expected, d.distance(s3,s1));
-			assertEquals("end points swapped", expected, d.distance(toList(s1),toList(s3)));
-			assertEquals("end points swapped", expected, d.distance(toList(s3),toList(s1)));
+			assertEquals(expected, d.distance(s1,s3));
+			assertEquals(expected, d.distance(s3,s1));
+			assertEquals(expected, d.distance(toList(s1),toList(s3)));
+			assertEquals(expected, d.distance(toList(s3),toList(s1)));
 		}
 	}
 	
@@ -909,16 +910,18 @@ public void testTauAlg2ObjectSequences() {
 			}
 			s3[0] = s2[0];
 			s3[n-1] = s2[n-1];
+			// maximal distance
 			int expected = n*(n-1)/2;
-			assertEquals("maximal distance", expected, d.distance(s1,s2));
-			assertEquals("maximal distance", expected, d.distance(s2,s1));
-			assertEquals("maximal distance", expected, d.distance(toList(s1),toList(s2)));
-			assertEquals("maximal distance", expected, d.distance(toList(s2),toList(s1)));
+			assertEquals(expected, d.distance(s1,s2));
+			assertEquals(expected, d.distance(s2,s1));
+			assertEquals(expected, d.distance(toList(s1),toList(s2)));
+			assertEquals(expected, d.distance(toList(s2),toList(s1)));
+			// end points swapped
 			expected = 2*n-3;
-			assertEquals("end points swapped", expected, d.distance(s1,s3));
-			assertEquals("end points swapped", expected, d.distance(s3,s1));
-			assertEquals("end points swapped", expected, d.distance(toList(s1),toList(s3)));
-			assertEquals("end points swapped", expected, d.distance(toList(s3),toList(s1)));
+			assertEquals(expected, d.distance(s1,s3));
+			assertEquals(expected, d.distance(s3,s1));
+			assertEquals(expected, d.distance(toList(s1),toList(s3)));
+			assertEquals(expected, d.distance(toList(s3),toList(s1)));
 		}
 		for (int n = 2; n <= 8; n++) {
 			//maximal distance if all unique elements (i.e., a permutation) is reversed sequence
@@ -931,15 +934,15 @@ public void testTauAlg2ObjectSequences() {
 			s3[0] = s2[0];
 			s3[n-1] = s2[n-1];
 			int expected = n*(n-1)/2;
-			assertEquals("maximal distance", expected, d.distance(s1,s2));
-			assertEquals("maximal distance", expected, d.distance(s2,s1));
-			assertEquals("maximal distance", expected, d.distance(toList(s1),toList(s2)));
-			assertEquals("maximal distance", expected, d.distance(toList(s2),toList(s1)));
+			assertEquals(expected, d.distance(s1,s2));
+			assertEquals(expected, d.distance(s2,s1));
+			assertEquals(expected, d.distance(toList(s1),toList(s2)));
+			assertEquals(expected, d.distance(toList(s2),toList(s1)));
 			expected = 2*n-3;
-			assertEquals("end points swapped", expected, d.distance(s1,s3));
-			assertEquals("end points swapped", expected, d.distance(s3,s1));
-			assertEquals("end points swapped", expected, d.distance(toList(s1),toList(s3)));
-			assertEquals("end points swapped", expected, d.distance(toList(s3),toList(s1)));
+			assertEquals(expected, d.distance(s1,s3));
+			assertEquals(expected, d.distance(s3,s1));
+			assertEquals(expected, d.distance(toList(s1),toList(s3)));
+			assertEquals(expected, d.distance(toList(s3),toList(s1)));
 		}
 	}
 	
@@ -1174,12 +1177,14 @@ private void helperForKendallTauCases(KendallTauSequenceDistance d) {
 			}
 			s3[0] = s2[0];
 			s3[n-1] = s2[n-1];
+			// maximal distance
 			int expected = n*(n-1)/2;
-			assertEquals("maximal distance", expected, d.distance(s1,s2));
-			assertEquals("maximal distance", expected, d.distance(s2,s1));
+			assertEquals(expected, d.distance(s1,s2));
+			assertEquals(expected, d.distance(s2,s1));
+			// end points swapped
 			expected = 2*n-3;
-			assertEquals("end points swapped", expected, d.distance(s1,s3));
-			assertEquals("end points swapped", expected, d.distance(s3,s1));
+			assertEquals(expected, d.distance(s1,s3));
+			assertEquals(expected, d.distance(s3,s1));
 			// test with negative values. rationale: default algorithm
 			// relies on hash tables, so make sure negatives don't break hash table.
 			int[] neg1 = new int[n];
@@ -1191,11 +1196,11 @@ private void helperForKendallTauCases(KendallTauSequenceDistance d) {
 				neg3[i] = -s3[i];
 			}
 			expected = n*(n-1)/2;
-			assertEquals("maximal distance", expected, d.distance(neg1,neg2));
-			assertEquals("maximal distance", expected, d.distance(neg2,neg1));
+			assertEquals(expected, d.distance(neg1,neg2));
+			assertEquals(expected, d.distance(neg2,neg1));
 			expected = 2*n-3;
-			assertEquals("end points swapped", expected, d.distance(neg1,neg3));
-			assertEquals("end points swapped", expected, d.distance(neg3,neg1));
+			assertEquals(expected, d.distance(neg1,neg3));
+			assertEquals(expected, d.distance(neg3,neg1));
 			{ // long
 				long[] t1 = new long[n];
 				long[] t2 = new long[n];
@@ -1204,11 +1209,11 @@ private void helperForKendallTauCases(KendallTauSequenceDistance d) {
 					t1[i] = s1[i]; t2[i] = s2[i]; t3[i] = s3[i];
 				}
 				expected = n*(n-1)/2;
-				assertEquals("maximal distance", expected, d.distance(t1,t2));
-				assertEquals("maximal distance", expected, d.distance(t2,t1));
+				assertEquals(expected, d.distance(t1,t2));
+				assertEquals(expected, d.distance(t2,t1));
 				expected = 2*n-3;
-				assertEquals("end points swapped", expected, d.distance(t1,t3));
-				assertEquals("end points swapped", expected, d.distance(t3,t1));
+				assertEquals(expected, d.distance(t1,t3));
+				assertEquals(expected, d.distance(t3,t1));
 				// test with negative values. rationale: default algorithm
 				// relies on hash tables, so make sure negatives don't break hash table.	
 				for (int i = 0; i < n; i++) {
@@ -1217,11 +1222,11 @@ private void helperForKendallTauCases(KendallTauSequenceDistance d) {
 					t3[i] = -t3[i];
 				}
 				expected = n*(n-1)/2;
-				assertEquals("maximal distance", expected, d.distance(t1,t2));
-				assertEquals("maximal distance", expected, d.distance(t2,t1));
+				assertEquals(expected, d.distance(t1,t2));
+				assertEquals(expected, d.distance(t2,t1));
 				expected = 2*n-3;
-				assertEquals("end points swapped", expected, d.distance(t1,t3));
-				assertEquals("end points swapped", expected, d.distance(t3,t1));
+				assertEquals(expected, d.distance(t1,t3));
+				assertEquals(expected, d.distance(t3,t1));
 			}
 			{ // short
 				short[] t1 = new short[n];
@@ -1231,11 +1236,11 @@ private void helperForKendallTauCases(KendallTauSequenceDistance d) {
 					t1[i] = (short)s1[i]; t2[i] = (short)s2[i]; t3[i] = (short)s3[i];
 				}
 				expected = n*(n-1)/2;
-				assertEquals("maximal distance", expected, d.distance(t1,t2));
-				assertEquals("maximal distance", expected, d.distance(t2,t1));
+				assertEquals(expected, d.distance(t1,t2));
+				assertEquals(expected, d.distance(t2,t1));
 				expected = 2*n-3;
-				assertEquals("end points swapped", expected, d.distance(t1,t3));
-				assertEquals("end points swapped", expected, d.distance(t3,t1));
+				assertEquals(expected, d.distance(t1,t3));
+				assertEquals(expected, d.distance(t3,t1));
 				// test with negative values. rationale: default algorithm
 				// relies on hash tables, so make sure negatives don't break hash table.	
 				for (int i = 0; i < n; i++) {
@@ -1244,11 +1249,11 @@ private void helperForKendallTauCases(KendallTauSequenceDistance d) {
 					t3[i] = (short)(-1 * t3[i]);
 				}
 				expected = n*(n-1)/2;
-				assertEquals("maximal distance", expected, d.distance(t1,t2));
-				assertEquals("maximal distance", expected, d.distance(t2,t1));
+				assertEquals(expected, d.distance(t1,t2));
+				assertEquals(expected, d.distance(t2,t1));
 				expected = 2*n-3;
-				assertEquals("end points swapped", expected, d.distance(t1,t3));
-				assertEquals("end points swapped", expected, d.distance(t3,t1));
+				assertEquals(expected, d.distance(t1,t3));
+				assertEquals(expected, d.distance(t3,t1));
 			}
 			{ // byte
 				byte[] t1 = new byte[n];
@@ -1258,11 +1263,11 @@ private void helperForKendallTauCases(KendallTauSequenceDistance d) {
 					t1[i] = (byte)s1[i]; t2[i] = (byte)s2[i]; t3[i] = (byte)s3[i];
 				}
 				expected = n*(n-1)/2;
-				assertEquals("maximal distance", expected, d.distance(t1,t2));
-				assertEquals("maximal distance", expected, d.distance(t2,t1));
+				assertEquals(expected, d.distance(t1,t2));
+				assertEquals(expected, d.distance(t2,t1));
 				expected = 2*n-3;
-				assertEquals("end points swapped", expected, d.distance(t1,t3));
-				assertEquals("end points swapped", expected, d.distance(t3,t1));
+				assertEquals(expected, d.distance(t1,t3));
+				assertEquals(expected, d.distance(t3,t1));
 				// test with negative values. rationale: default algorithm
 				// relies on hash tables, so make sure negatives don't break hash table.	
 				for (int i = 0; i < n; i++) {
@@ -1271,11 +1276,11 @@ private void helperForKendallTauCases(KendallTauSequenceDistance d) {
 					t3[i] = (byte)(-1 * t3[i]);
 				}
 				expected = n*(n-1)/2;
-				assertEquals("maximal distance", expected, d.distance(t1,t2));
-				assertEquals("maximal distance", expected, d.distance(t2,t1));
+				assertEquals(expected, d.distance(t1,t2));
+				assertEquals(expected, d.distance(t2,t1));
 				expected = 2*n-3;
-				assertEquals("end points swapped", expected, d.distance(t1,t3));
-				assertEquals("end points swapped", expected, d.distance(t3,t1));
+				assertEquals(expected, d.distance(t1,t3));
+				assertEquals(expected, d.distance(t3,t1));
 			}
 			{ // char
 				char[] t1 = new char[n];
@@ -1285,20 +1290,20 @@ private void helperForKendallTauCases(KendallTauSequenceDistance d) {
 					t1[i] = (char)s1[i]; t2[i] = (char)s2[i]; t3[i] = (char)s3[i];
 				}
 				expected = n*(n-1)/2;
-				assertEquals("maximal distance", expected, d.distance(t1,t2));
-				assertEquals("maximal distance", expected, d.distance(t2,t1));
+				assertEquals(expected, d.distance(t1,t2));
+				assertEquals(expected, d.distance(t2,t1));
 				expected = 2*n-3;
-				assertEquals("end points swapped", expected, d.distance(t1,t3));
-				assertEquals("end points swapped", expected, d.distance(t3,t1));
+				assertEquals(expected, d.distance(t1,t3));
+				assertEquals(expected, d.distance(t3,t1));
 				String u1 = new String(t1);
 				String u2 = new String(t2);
 				String u3 = new String(t3);
 				expected = n*(n-1)/2;
-				assertEquals("maximal distance", expected, d.distance(u1,u2));
-				assertEquals("maximal distance", expected, d.distance(u2,u1));
+				assertEquals(expected, d.distance(u1,u2));
+				assertEquals(expected, d.distance(u2,u1));
 				expected = 2*n-3;
-				assertEquals("end points swapped", expected, d.distance(u1,u3));
-				assertEquals("end points swapped", expected, d.distance(u3,u1));
+				assertEquals(expected, d.distance(u1,u3));
+				assertEquals(expected, d.distance(u3,u1));
 			}
 			{ // float
 				float[] t1 = new float[n];
@@ -1308,11 +1313,11 @@ private void helperForKendallTauCases(KendallTauSequenceDistance d) {
 					t1[i] = s1[i]; t2[i] = s2[i]; t3[i] = s3[i];
 				}
 				expected = n*(n-1)/2;
-				assertEquals("maximal distance", expected, d.distance(t1,t2));
-				assertEquals("maximal distance", expected, d.distance(t2,t1));
+				assertEquals(expected, d.distance(t1,t2));
+				assertEquals(expected, d.distance(t2,t1));
 				expected = 2*n-3;
-				assertEquals("end points swapped", expected, d.distance(t1,t3));
-				assertEquals("end points swapped", expected, d.distance(t3,t1));
+				assertEquals(expected, d.distance(t1,t3));
+				assertEquals(expected, d.distance(t3,t1));
 				// test with negative values. rationale: default algorithm
 				// relies on hash tables, so make sure negatives don't break hash table.	
 				for (int i = 0; i < n; i++) {
@@ -1321,11 +1326,11 @@ private void helperForKendallTauCases(KendallTauSequenceDistance d) {
 					t3[i] = -t3[i];
 				}
 				expected = n*(n-1)/2;
-				assertEquals("maximal distance", expected, d.distance(t1,t2));
-				assertEquals("maximal distance", expected, d.distance(t2,t1));
+				assertEquals(expected, d.distance(t1,t2));
+				assertEquals(expected, d.distance(t2,t1));
 				expected = 2*n-3;
-				assertEquals("end points swapped", expected, d.distance(t1,t3));
-				assertEquals("end points swapped", expected, d.distance(t3,t1));
+				assertEquals(expected, d.distance(t1,t3));
+				assertEquals(expected, d.distance(t3,t1));
 			}
 			{ // double
 				double[] t1 = new double[n];
@@ -1335,11 +1340,11 @@ private void helperForKendallTauCases(KendallTauSequenceDistance d) {
 					t1[i] = s1[i]; t2[i] = s2[i]; t3[i] = s3[i];
 				}
 				expected = n*(n-1)/2;
-				assertEquals("maximal distance", expected, d.distance(t1,t2));
-				assertEquals("maximal distance", expected, d.distance(t2,t1));
+				assertEquals(expected, d.distance(t1,t2));
+				assertEquals(expected, d.distance(t2,t1));
 				expected = 2*n-3;
-				assertEquals("end points swapped", expected, d.distance(t1,t3));
-				assertEquals("end points swapped", expected, d.distance(t3,t1));
+				assertEquals(expected, d.distance(t1,t3));
+				assertEquals(expected, d.distance(t3,t1));
 				// test with negative values. rationale: default algorithm
 				// relies on hash tables, so make sure negatives don't break hash table.	
 				for (int i = 0; i < n; i++) {
@@ -1348,11 +1353,11 @@ private void helperForKendallTauCases(KendallTauSequenceDistance d) {
 					t3[i] = -t3[i];
 				}
 				expected = n*(n-1)/2;
-				assertEquals("maximal distance", expected, d.distance(t1,t2));
-				assertEquals("maximal distance", expected, d.distance(t2,t1));
+				assertEquals(expected, d.distance(t1,t2));
+				assertEquals(expected, d.distance(t2,t1));
 				expected = 2*n-3;
-				assertEquals("end points swapped", expected, d.distance(t1,t3));
-				assertEquals("end points swapped", expected, d.distance(t3,t1));
+				assertEquals(expected, d.distance(t1,t3));
+				assertEquals(expected, d.distance(t3,t1));
 			}
 		}
 		Permutation p = new Permutation(6);
@@ -1362,8 +1367,8 @@ private void helperForKendallTauCases(KendallTauSequenceDistance d) {
 		for (Permutation q : p) {
 			for (int i = 0; i < 6; i++) s2[i] = q.get(i);
 			int expected = naiveKendalTau(s1,s2);
-			assertEquals("checking consistence with naive implementation of unique element version", expected, d.distance(s1,s2));
-			assertEquals("checking consistence with naive implementation of unique element version", expected, d.distance(s2,s1));
+			assertEquals(expected, d.distance(s1,s2), "checking consistence with naive implementation of unique element version");
+			assertEquals(expected, d.distance(s2,s1), "checking consistence with naive implementation of unique element version");
 		}
 		{ // long
 			s1 = new int[5];
@@ -1375,8 +1380,8 @@ private void helperForKendallTauCases(KendallTauSequenceDistance d) {
 			for (Permutation q : r) {
 				for (int i = 0; i < 5; i++) t2[i] = s2[i] = q.get(i);
 				int expected = naiveKendalTau(s1,s2);
-				assertEquals("checking consistence with naive implementation of unique element version", expected, d.distance(t1,t2));
-				assertEquals("checking consistence with naive implementation of unique element version", expected, d.distance(t2,t1));
+				assertEquals(expected, d.distance(t1,t2));
+				assertEquals(expected, d.distance(t2,t1));
 			}
 		}
 		{ // short
@@ -1389,8 +1394,8 @@ private void helperForKendallTauCases(KendallTauSequenceDistance d) {
 			for (Permutation q : r) {
 				for (int i = 0; i < 5; i++) s2[i] = t2[i] = (short)q.get(i);
 				int expected = naiveKendalTau(s1,s2);
-				assertEquals("checking consistence with naive implementation of unique element version", expected, d.distance(t1,t2));
-				assertEquals("checking consistence with naive implementation of unique element version", expected, d.distance(t2,t1));
+				assertEquals(expected, d.distance(t1,t2));
+				assertEquals(expected, d.distance(t2,t1));
 			}
 		}
 		{ // byte
@@ -1403,8 +1408,8 @@ private void helperForKendallTauCases(KendallTauSequenceDistance d) {
 			for (Permutation q : r) {
 				for (int i = 0; i < 5; i++) s2[i] = t2[i] = (byte)q.get(i);
 				int expected = naiveKendalTau(s1,s2);
-				assertEquals("checking consistence with naive implementation of unique element version", expected, d.distance(t1,t2));
-				assertEquals("checking consistence with naive implementation of unique element version", expected, d.distance(t2,t1));
+				assertEquals(expected, d.distance(t1,t2));
+				assertEquals(expected, d.distance(t2,t1));
 			}
 		}
 		{ // char
@@ -1419,10 +1424,10 @@ private void helperForKendallTauCases(KendallTauSequenceDistance d) {
 				for (int i = 0; i < 5; i++) s2[i] = t2[i] = (char)q.get(i);
 				String u2 = new String(t2);
 				int expected = naiveKendalTau(s1,s2);
-				assertEquals("checking consistence with naive implementation of unique element version", expected, d.distance(t1,t2));
-				assertEquals("checking consistence with naive implementation of unique element version", expected, d.distance(t2,t1));
-				assertEquals("checking consistence with naive implementation of unique element version", expected, d.distance(u1,u2));
-				assertEquals("checking consistence with naive implementation of unique element version", expected, d.distance(u2,u1));
+				assertEquals(expected, d.distance(t1,t2));
+				assertEquals(expected, d.distance(t2,t1));
+				assertEquals(expected, d.distance(u1,u2));
+				assertEquals(expected, d.distance(u2,u1));
 			}
 		}
 		{ // float
@@ -1435,8 +1440,8 @@ private void helperForKendallTauCases(KendallTauSequenceDistance d) {
 			for (Permutation q : r) {
 				for (int i = 0; i < 5; i++) t2[i] = s2[i] = q.get(i);
 				int expected = naiveKendalTau(s1,s2);
-				assertEquals("checking consistence with naive implementation of unique element version", expected, d.distance(t1,t2));
-				assertEquals("checking consistence with naive implementation of unique element version", expected, d.distance(t2,t1));
+				assertEquals(expected, d.distance(t1,t2));
+				assertEquals(expected, d.distance(t2,t1));
 			}
 		}
 		{ // double
@@ -1449,15 +1454,15 @@ private void helperForKendallTauCases(KendallTauSequenceDistance d) {
 			for (Permutation q : r) {
 				for (int i = 0; i < 5; i++) t2[i] = s2[i] = q.get(i);
 				int expected = naiveKendalTau(s1,s2);
-				assertEquals("checking consistence with naive implementation of unique element version", expected, d.distance(t1,t2));
-				assertEquals("checking consistence with naive implementation of unique element version", expected, d.distance(t2,t1));
+				assertEquals(expected, d.distance(t1,t2));
+				assertEquals(expected, d.distance(t2,t1));
 			}
 		}
 		// Now test with duplicate elements
 		String t1 = "abcdaabb";
 		String t2 = "dcbababa";
-		assertEquals("case where discordant pair counting fails", 9, d.distance(t1,t2));
-		assertEquals("case where discordant pair counting fails", 9, d.distance(t2,t1));
+		assertEquals(9, d.distance(t1,t2), "case where discordant pair counting fails");
+		assertEquals(9, d.distance(t2,t1), "case where discordant pair counting fails");
 		char[] c1 = t1.toCharArray();
 		char[] c2 = t2.toCharArray();
 		long[] L1 = new long[c1.length];
@@ -1482,20 +1487,21 @@ private void helperForKendallTauCases(KendallTauSequenceDistance d) {
 			sh2[i] = (short)c2[i];
 			b2[i] = (byte)c2[i];
 		}
-		assertEquals("case where discordant pair counting fails", 9, d.distance(c1,c2));
-		assertEquals("case where discordant pair counting fails", 9, d.distance(c2,c1));
-		assertEquals("case where discordant pair counting fails", 9, d.distance(L1,L2));
-		assertEquals("case where discordant pair counting fails", 9, d.distance(L2,L1));
-		assertEquals("case where discordant pair counting fails", 9, d.distance(sh1,sh2));
-		assertEquals("case where discordant pair counting fails", 9, d.distance(sh2,sh1));
-		assertEquals("case where discordant pair counting fails", 9, d.distance(b1,b2));
-		assertEquals("case where discordant pair counting fails", 9, d.distance(b2,b1));
-		assertEquals("case where discordant pair counting fails", 9, d.distance(i1,i2));
-		assertEquals("case where discordant pair counting fails", 9, d.distance(i2,i1));
-		assertEquals("case where discordant pair counting fails", 9, d.distance(f1,f2));
-		assertEquals("case where discordant pair counting fails", 9, d.distance(f2,f1));
-		assertEquals("case where discordant pair counting fails", 9, d.distance(d1,d2));
-		assertEquals("case where discordant pair counting fails", 9, d.distance(d2,d1));
+		// case where discordant pair counting fails
+		assertEquals(9, d.distance(c1,c2));
+		assertEquals(9, d.distance(c2,c1));
+		assertEquals(9, d.distance(L1,L2));
+		assertEquals(9, d.distance(L2,L1));
+		assertEquals(9, d.distance(sh1,sh2));
+		assertEquals(9, d.distance(sh2,sh1));
+		assertEquals(9, d.distance(b1,b2));
+		assertEquals(9, d.distance(b2,b1));
+		assertEquals(9, d.distance(i1,i2));
+		assertEquals(9, d.distance(i2,i1));
+		assertEquals(9, d.distance(f1,f2));
+		assertEquals(9, d.distance(f2,f1));
+		assertEquals(9, d.distance(d1,d2));
+		assertEquals(9, d.distance(d2,d1));
 		for (int n = 2; n < 8; n++) {
 			for (int i = 1; i < n; i++) {
 				boolean[] a1 = new boolean[n];
@@ -1504,8 +1510,8 @@ private void helperForKendallTauCases(KendallTauSequenceDistance d) {
 					a2[j] = a1[n-1-j] = true;
 				}
 				int expected = i * (n-i);
-				assertEquals("boolean case", expected, d.distance(a2,a1));
-				assertEquals("boolean case", expected, d.distance(a1,a2));
+				assertEquals(expected, d.distance(a2,a1));
+				assertEquals(expected, d.distance(a1,a2));
 			}
 		}
 	}
@@ -1555,15 +1561,16 @@ private void identicalSequences(SequenceDistanceMeasurer d) {
 				a8[i] = ThreadLocalRandom.current().nextBoolean();
 			}
 			String a9 = new String(a5);
-			assertEquals("distance of a sequence to itself should be 0", 0, d.distance(a1, a1.clone()));
-			assertEquals("distance of a sequence to itself should be 0", 0, d.distance(a2, a2.clone()));
-			assertEquals("distance of a sequence to itself should be 0", 0, d.distance(a3, a3.clone()));
-			assertEquals("distance of a sequence to itself should be 0", 0, d.distance(a4, a4.clone()));
-			assertEquals("distance of a sequence to itself should be 0", 0, d.distance(a5, a5.clone()));
-			assertEquals("distance of a sequence to itself should be 0", 0, d.distance(a6, a6.clone()));
-			assertEquals("distance of a sequence to itself should be 0", 0, d.distance(a7, a7.clone()));
-			assertEquals("distance of a sequence to itself should be 0", 0, d.distance(a8, a8.clone()));
-			assertEquals("distance of a sequence to itself should be 0", 0, d.distance(a9, new String(a9)));
+			// distance of a sequence to itself should be 0
+			assertEquals(0, d.distance(a1, a1.clone()));
+			assertEquals(0, d.distance(a2, a2.clone()));
+			assertEquals(0, d.distance(a3, a3.clone()));
+			assertEquals(0, d.distance(a4, a4.clone()));
+			assertEquals(0, d.distance(a5, a5.clone()));
+			assertEquals(0, d.distance(a6, a6.clone()));
+			assertEquals(0, d.distance(a7, a7.clone()));
+			assertEquals(0, d.distance(a8, a8.clone()));
+			assertEquals(0, d.distance(a9, new String(a9)));
 		}
 	}
 	
@@ -1588,15 +1595,16 @@ private void identicalSequencesD(SequenceDistanceMeasurerDouble d) {
 				a8[i] = ThreadLocalRandom.current().nextBoolean();
 			}
 			String a9 = new String(a5);
-			assertEquals("distance of a sequence to itself should be 0", 0.0, d.distancef(a1, a1.clone()), EPSILON);
-			assertEquals("distance of a sequence to itself should be 0", 0.0, d.distancef(a2, a2.clone()), EPSILON);
-			assertEquals("distance of a sequence to itself should be 0", 0.0, d.distancef(a3, a3.clone()), EPSILON);
-			assertEquals("distance of a sequence to itself should be 0", 0.0, d.distancef(a4, a4.clone()), EPSILON);
-			assertEquals("distance of a sequence to itself should be 0", 0.0, d.distancef(a5, a5.clone()), EPSILON);
-			assertEquals("distance of a sequence to itself should be 0", 0.0, d.distancef(a6, a6.clone()), EPSILON);
-			assertEquals("distance of a sequence to itself should be 0", 0.0, d.distancef(a7, a7.clone()), EPSILON);
-			assertEquals("distance of a sequence to itself should be 0", 0.0, d.distancef(a8, a8.clone()), EPSILON);
-			assertEquals("distance of a sequence to itself should be 0", 0.0, d.distancef(a9, new String(a9)), EPSILON);
+			// distance of a sequence to itself should be 0
+			assertEquals(0.0, d.distancef(a1, a1.clone()), EPSILON);
+			assertEquals(0.0, d.distancef(a2, a2.clone()), EPSILON);
+			assertEquals(0.0, d.distancef(a3, a3.clone()), EPSILON);
+			assertEquals(0.0, d.distancef(a4, a4.clone()), EPSILON);
+			assertEquals(0.0, d.distancef(a5, a5.clone()), EPSILON);
+			assertEquals(0.0, d.distancef(a6, a6.clone()), EPSILON);
+			assertEquals(0.0, d.distancef(a7, a7.clone()), EPSILON);
+			assertEquals(0.0, d.distancef(a8, a8.clone()), EPSILON);
+			assertEquals(0.0, d.distancef(a9, new String(a9)), EPSILON);
 		}
 	}