From 19886eff894c410e9f4592ee867b1fc9249dc7ff Mon Sep 17 00:00:00 2001 From: Andreas Huber Date: Fri, 17 Aug 2018 18:44:38 +0200 Subject: [PATCH] update to Junit 5 --- build.gradle | 2 +- .../org/lucares/collections/IntListTest.java | 547 +++++++++--------- .../org/lucares/collections/LongListTest.java | 547 +++++++++--------- 3 files changed, 547 insertions(+), 549 deletions(-) diff --git a/build.gradle b/build.gradle index 0b78139..a868f2d 100644 --- a/build.gradle +++ b/build.gradle @@ -47,7 +47,7 @@ subprojects { // dependencies that all sub-projects have dependencies { - testCompile group: 'junit', name: 'junit', version: '4.12' + testCompile 'org.junit.jupiter:junit-jupiter-api:5.2.0' } } diff --git a/primitiveCollections/src/test/java/org/lucares/collections/IntListTest.java b/primitiveCollections/src/test/java/org/lucares/collections/IntListTest.java index 0011d81..d77c3a6 100644 --- a/primitiveCollections/src/test/java/org/lucares/collections/IntListTest.java +++ b/primitiveCollections/src/test/java/org/lucares/collections/IntListTest.java @@ -13,8 +13,8 @@ import java.util.concurrent.ThreadLocalRandom; import java.util.stream.Collectors; import java.util.stream.IntStream; -import org.junit.Assert; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; public class IntListTest { @@ -22,7 +22,7 @@ public class IntListTest { public void testEmptyList() { final IntList list = new IntList(); - Assert.assertEquals(true, list.isEmpty()); + Assertions.assertEquals(true, list.isEmpty()); } @Test @@ -32,14 +32,14 @@ public class IntListTest { final IntList copy = new IntList(list); - Assert.assertArrayEquals(copy.toArray(), list.toArray()); + Assertions.assertArrayEquals(copy.toArray(), list.toArray()); } @Test public void testInvalidInitialCapacity() { try { new IntList(-1); - Assert.fail(); + Assertions.fail(); } catch (final IllegalArgumentException e) { // expected } @@ -53,14 +53,14 @@ public class IntListTest { list.add(1); - Assert.assertFalse(list.isEmpty()); - Assert.assertEquals(1, list.size()); + Assertions.assertFalse(list.isEmpty()); + Assertions.assertEquals(1, list.size()); list.add(2); - Assert.assertEquals(2, list.size()); + Assertions.assertEquals(2, list.size()); - Assert.assertEquals(1, list.get(0)); - Assert.assertEquals(2, list.get(1)); + Assertions.assertEquals(1, list.get(0)); + Assertions.assertEquals(2, list.get(1)); } @Test @@ -68,25 +68,25 @@ public class IntListTest { final IntList list = new IntList(); list.insert(0); - Assert.assertArrayEquals(new int[] {}, list.toArray()); + Assertions.assertArrayEquals(new int[] {}, list.toArray()); list.insert(0, 1); - Assert.assertArrayEquals(new int[] { 1 }, list.toArray()); + Assertions.assertArrayEquals(new int[] { 1 }, list.toArray()); list.insert(1, 2, 2, 2); - Assert.assertArrayEquals(new int[] { 1, 2, 2, 2 }, list.toArray()); + Assertions.assertArrayEquals(new int[] { 1, 2, 2, 2 }, list.toArray()); list.insert(1, 3); - Assert.assertArrayEquals(new int[] { 1, 3, 2, 2, 2 }, list.toArray()); + Assertions.assertArrayEquals(new int[] { 1, 3, 2, 2, 2 }, list.toArray()); list.insert(2, 4, 4, 4); - Assert.assertArrayEquals(new int[] { 1, 3, 4, 4, 4, 2, 2, 2 }, list.toArray()); + Assertions.assertArrayEquals(new int[] { 1, 3, 4, 4, 4, 2, 2, 2 }, list.toArray()); list.insert(2); - Assert.assertArrayEquals(new int[] { 1, 3, 4, 4, 4, 2, 2, 2 }, list.toArray()); + Assertions.assertArrayEquals(new int[] { 1, 3, 4, 4, 4, 2, 2, 2 }, list.toArray()); list.insert(8, 5, 5); - Assert.assertArrayEquals(new int[] { 1, 3, 4, 4, 4, 2, 2, 2, 5, 5 }, list.toArray()); + Assertions.assertArrayEquals(new int[] { 1, 3, 4, 4, 4, 2, 2, 2, 5, 5 }, list.toArray()); } @Test @@ -94,14 +94,14 @@ public class IntListTest { final IntList list = new IntList(); try { list.insert(-1, 1); - Assert.fail(); + Assertions.fail(); } catch (final IndexOutOfBoundsException e) { // expected } try { list.insert(1, 1); - Assert.fail(); + Assertions.fail(); } catch (final IndexOutOfBoundsException e) { // expected } @@ -109,7 +109,7 @@ public class IntListTest { try { list.add(1); list.insert(2, 2); - Assert.fail(); + Assertions.fail(); } catch (final IndexOutOfBoundsException e) { // expected } @@ -120,7 +120,7 @@ public class IntListTest { final IntList list = new IntList(); try { list.insert(0, null); - Assert.fail(); + Assertions.fail(); } catch (final NullPointerException e) { // expected } @@ -132,13 +132,13 @@ public class IntListTest { list.addAll(0, 1, 2, 3, 4, 5); list.set(0, 10); - Assert.assertArrayEquals(new int[] { 10, 1, 2, 3, 4, 5 }, list.toArray()); + Assertions.assertArrayEquals(new int[] { 10, 1, 2, 3, 4, 5 }, list.toArray()); list.set(1, 11); - Assert.assertArrayEquals(new int[] { 10, 11, 2, 3, 4, 5 }, list.toArray()); + Assertions.assertArrayEquals(new int[] { 10, 11, 2, 3, 4, 5 }, list.toArray()); list.set(5, 55); - Assert.assertArrayEquals(new int[] { 10, 11, 2, 3, 4, 55 }, list.toArray()); + Assertions.assertArrayEquals(new int[] { 10, 11, 2, 3, 4, 55 }, list.toArray()); } @Test @@ -146,14 +146,14 @@ public class IntListTest { final IntList list = new IntList(); try { list.set(-1, 1); - Assert.fail(); + Assertions.fail(); } catch (final IndexOutOfBoundsException e) { // expected } try { list.set(1, 1); - Assert.fail(); + Assertions.fail(); } catch (final IndexOutOfBoundsException e) { // expected } @@ -162,7 +162,7 @@ public class IntListTest { try { list.set(6, 1); - Assert.fail(); + Assertions.fail(); } catch (final IndexOutOfBoundsException e) { // expected } @@ -176,10 +176,10 @@ public class IntListTest { for (int i = 0; i < size; i++) { list.add(i); } - Assert.assertEquals(size, list.size()); + Assertions.assertEquals(size, list.size()); for (int i = 0; i < size; i++) { - Assert.assertEquals(i, list.get(i)); + Assertions.assertEquals(i, list.get(i)); } } @@ -191,10 +191,10 @@ public class IntListTest { for (int i = 0; i < size; i++) { list.add(i); } - Assert.assertEquals(size, list.size()); + Assertions.assertEquals(size, list.size()); for (int i = 0; i < size; i++) { - Assert.assertEquals(i, list.get(i)); + Assertions.assertEquals(i, list.get(i)); } } @@ -203,24 +203,24 @@ public class IntListTest { final IntList list = new IntList(); list.addAll(); - Assert.assertTrue(list.isEmpty()); - Assert.assertEquals(0, list.size()); + Assertions.assertTrue(list.isEmpty()); + Assertions.assertEquals(0, list.size()); final int size = 100; final int[] ints = ThreadLocalRandom.current().ints(size).toArray(); list.addAll(ints); - Assert.assertEquals(size, list.size()); + Assertions.assertEquals(size, list.size()); for (int i = 0; i < size; i++) { - Assert.assertEquals(ints[i], list.get(i)); + Assertions.assertEquals(ints[i], list.get(i)); } final int[] anotherInts = ThreadLocalRandom.current().ints(size).toArray(); list.addAll(anotherInts); - Assert.assertEquals(size * 2, list.size()); + Assertions.assertEquals(size * 2, list.size()); for (int i = 0; i < size; i++) { - Assert.assertEquals(anotherInts[i], list.get(size + i)); + Assertions.assertEquals(anotherInts[i], list.get(size + i)); } } @@ -230,55 +230,55 @@ public class IntListTest { // adding empty list with no capacity list.addAll(IntList.of()); - Assert.assertEquals(new IntList(), list); - Assert.assertTrue(list.isSorted()); + Assertions.assertEquals(new IntList(), list); + Assertions.assertTrue(list.isSorted()); // adding empty list with capacity 2 list.addAll(new IntList(2)); - Assert.assertEquals(new IntList(), list); - Assert.assertTrue(list.isSorted()); + Assertions.assertEquals(new IntList(), list); + Assertions.assertTrue(list.isSorted()); // adding sorted list to an empty list list.addAll(IntList.of(1, 2, 3)); - Assert.assertEquals(IntList.of(1, 2, 3), list); - Assert.assertTrue(list.isSorted()); + Assertions.assertEquals(IntList.of(1, 2, 3), list); + Assertions.assertTrue(list.isSorted()); // add empty list to a sorted list list.addAll(IntList.of()); - Assert.assertEquals(IntList.of(1, 2, 3), list); - Assert.assertTrue(list.isSorted()); + Assertions.assertEquals(IntList.of(1, 2, 3), list); + Assertions.assertTrue(list.isSorted()); // adding sorted list to a sorted list so that the list stays sorted list.addAll(IntList.of(3, 4, 5)); - Assert.assertEquals(IntList.of(1, 2, 3, 3, 4, 5), list); - Assert.assertTrue(list.isSorted()); + Assertions.assertEquals(IntList.of(1, 2, 3, 3, 4, 5), list); + Assertions.assertTrue(list.isSorted()); // adding sorted list to a sorted list, but the new list is not sorted list.clear(); list.addAll(IntList.of(1, 2, 3)); list.addAll(IntList.of(0)); - Assert.assertEquals(IntList.of(1, 2, 3, 0), list); - Assert.assertFalse(list.isSorted()); + Assertions.assertEquals(IntList.of(1, 2, 3, 0), list); + Assertions.assertFalse(list.isSorted()); // adding unsorted list to a sorted list list.clear(); list.addAll(IntList.of(1, 2, 3)); list.addAll(IntList.of(6, 5, 4)); - Assert.assertEquals(IntList.of(1, 2, 3, 6, 5, 4), list); - Assert.assertFalse(list.isSorted()); + Assertions.assertEquals(IntList.of(1, 2, 3, 6, 5, 4), list); + Assertions.assertFalse(list.isSorted()); // adding unsorted list to an empty list list.clear(); list.addAll(IntList.of(3, 2, 1)); - Assert.assertEquals(IntList.of(3, 2, 1), list); - Assert.assertFalse(list.isSorted()); + Assertions.assertEquals(IntList.of(3, 2, 1), list); + Assertions.assertFalse(list.isSorted()); // adding sorted list to an unsorted list list.clear(); list.addAll(IntList.of(3, 2, 1)); list.addAll(IntList.of(1, 2, 3)); - Assert.assertEquals(IntList.of(3, 2, 1, 1, 2, 3), list); - Assert.assertFalse(list.isSorted()); + Assertions.assertEquals(IntList.of(3, 2, 1, 1, 2, 3), list); + Assertions.assertFalse(list.isSorted()); } @@ -296,8 +296,8 @@ public class IntListTest { final int[] actualInts = list.get(from, length); for (int i = 0; i < length; i++) { - Assert.assertEquals(actualInts[i], list.get(from + i)); - Assert.assertEquals(actualInts[i], ints[from + i]); + Assertions.assertEquals(actualInts[i], list.get(from + i)); + Assertions.assertEquals(actualInts[i], ints[from + i]); } } @@ -309,13 +309,13 @@ public class IntListTest { try { list.get(-1); - Assert.fail(); + Assertions.fail(); } catch (final IndexOutOfBoundsException e) { // expected } try { list.get(4); - Assert.fail(); + Assertions.fail(); } catch (final IndexOutOfBoundsException e) { // expected } @@ -329,25 +329,25 @@ public class IntListTest { try { list.get(-1, 1); - Assert.fail(); + Assertions.fail(); } catch (final IndexOutOfBoundsException e) { // expected } try { list.get(1, -1); - Assert.fail(); + Assertions.fail(); } catch (final IndexOutOfBoundsException e) { // expected } try { list.get(3, 2); - Assert.fail(); + Assertions.fail(); } catch (final IndexOutOfBoundsException e) { // expected } try { list.get(4, 1); - Assert.fail(); + Assertions.fail(); } catch (final IndexOutOfBoundsException e) { // expected } @@ -358,7 +358,7 @@ public class IntListTest { final IntList list = new IntList(); final int[] actual = list.toArray(); - Assert.assertArrayEquals(actual, new int[0]); + Assertions.assertArrayEquals(actual, new int[0]); } @Test @@ -370,16 +370,16 @@ public class IntListTest { final int[] input = new int[1]; final int[] actual = list.toArray(input); // input is too short -> new array returned - Assert.assertNotSame(input, actual); - Assert.assertArrayEquals(list.toArray(), actual); + Assertions.assertNotSame(input, actual); + Assertions.assertArrayEquals(list.toArray(), actual); } { final int[] input = new int[list.size()]; final int[] actual = list.toArray(input); // input fits exactly -> input returned - Assert.assertSame(input, actual); - Assert.assertArrayEquals(list.toArray(), actual); + Assertions.assertSame(input, actual); + Assertions.assertArrayEquals(list.toArray(), actual); } { @@ -387,8 +387,8 @@ public class IntListTest { final int[] expected = { 1, 2, 3, 4, 5, 6, 0 }; final int[] actual = list.toArray(input); // input too big -> input returned - Assert.assertSame(input, actual); - Assert.assertArrayEquals(expected, actual); + Assertions.assertSame(input, actual); + Assertions.assertArrayEquals(expected, actual); } } @@ -400,8 +400,8 @@ public class IntListTest { final int[] input = new int[0]; final int[] actual = list.toArray(input); // input fits exactly -> input returned - Assert.assertSame(input, actual); - Assert.assertArrayEquals(list.toArray(), actual); + Assertions.assertSame(input, actual); + Assertions.assertArrayEquals(list.toArray(), actual); } { @@ -409,8 +409,8 @@ public class IntListTest { final int[] expected = { 0 }; final int[] actual = list.toArray(input); // input too big -> input returned - Assert.assertSame(input, actual); - Assert.assertArrayEquals(expected, actual); + Assertions.assertSame(input, actual); + Assertions.assertArrayEquals(expected, actual); } } @@ -428,32 +428,32 @@ public class IntListTest { // remove nothing list.remove(2, 2); - Assert.assertArrayEquals(ints, list.toArray()); + Assertions.assertArrayEquals(ints, list.toArray()); // remove the last element list.remove(9, 10); final int[] expectedA = removeElements(ints, 9); - Assert.assertArrayEquals(expectedA, list.toArray()); + Assertions.assertArrayEquals(expectedA, list.toArray()); // remove the first element list.remove(0, 1); final int[] expectedB = removeElements(expectedA, 0); - Assert.assertArrayEquals(expectedB, list.toArray()); + Assertions.assertArrayEquals(expectedB, list.toArray()); // remove single element in the middle list.remove(3, 4); final int[] expectedC = removeElements(expectedB, 3); - Assert.assertArrayEquals(expectedC, list.toArray()); + Assertions.assertArrayEquals(expectedC, list.toArray()); // remove several elements in the middle list.remove(2, 5); final int[] expectedD = removeElements(expectedC, 2, 3, 4); - Assert.assertArrayEquals(expectedD, list.toArray()); + Assertions.assertArrayEquals(expectedD, list.toArray()); // remove all elements list.remove(0, 4); final int[] expectedE = removeElements(expectedD, 0, 1, 2, 3); - Assert.assertArrayEquals(expectedE, list.toArray()); + Assertions.assertArrayEquals(expectedE, list.toArray()); } @Test @@ -464,25 +464,25 @@ public class IntListTest { try { list.remove(-1, 1); - Assert.fail(); + Assertions.fail(); } catch (final IndexOutOfBoundsException e) { // expected } try { list.remove(1, 0); - Assert.fail(); + Assertions.fail(); } catch (final IndexOutOfBoundsException e) { // expected } try { list.remove(3, 5); - Assert.fail(); + Assertions.fail(); } catch (final IndexOutOfBoundsException e) { // expected } try { list.remove(4, 5); - Assert.fail(); + Assertions.fail(); } catch (final IndexOutOfBoundsException e) { // expected } @@ -495,7 +495,7 @@ public class IntListTest { list.addAll(0, 1, 2, 3); list.trim(); - Assert.assertEquals(4, list.getCapacity()); + Assertions.assertEquals(4, list.getCapacity()); } @Test @@ -503,7 +503,7 @@ public class IntListTest { final IntList list = new IntList(); list.trim(); - Assert.assertEquals(0, list.getCapacity()); + Assertions.assertEquals(0, list.getCapacity()); } @Test @@ -511,9 +511,9 @@ public class IntListTest { final IntList list = IntList.of(2, 0, 1); // unsorted list list.clear(); - Assert.assertEquals(0, list.size()); - Assert.assertEquals(0, list.getCapacity()); - Assert.assertTrue(list.isSorted()); + Assertions.assertEquals(0, list.size()); + Assertions.assertEquals(0, list.getCapacity()); + Assertions.assertTrue(list.isSorted()); } @SuppressWarnings("unlikely-arg-type") @@ -523,46 +523,46 @@ public class IntListTest { final IntList b = new IntList(); // on empty lists - Assert.assertTrue(a.equals(b)); - Assert.assertEquals(a.hashCode(), b.hashCode()); + Assertions.assertTrue(a.equals(b)); + Assertions.assertEquals(a.hashCode(), b.hashCode()); // on equal lists a.addAll(1, 2, 3, 4); b.addAll(1, 2, 3, 4); - Assert.assertTrue(a.equals(b)); - Assert.assertEquals(a.hashCode(), b.hashCode()); + Assertions.assertTrue(a.equals(b)); + Assertions.assertEquals(a.hashCode(), b.hashCode()); // trim only one of them // we want to compare the actual content a.trim(); - Assert.assertTrue(a.equals(b)); - Assert.assertEquals(a.hashCode(), b.hashCode()); + Assertions.assertTrue(a.equals(b)); + Assertions.assertEquals(a.hashCode(), b.hashCode()); // change one value a.remove(2, 3); a.insert(2, 99); - Assert.assertFalse(a.equals(b)); - Assert.assertNotEquals(a.hashCode(), b.hashCode()); + Assertions.assertFalse(a.equals(b)); + Assertions.assertNotEquals(a.hashCode(), b.hashCode()); // have different length a.add(66); - Assert.assertFalse(a.equals(b)); - Assert.assertNotEquals(a.hashCode(), b.hashCode()); + Assertions.assertFalse(a.equals(b)); + Assertions.assertNotEquals(a.hashCode(), b.hashCode()); // same object - Assert.assertTrue(a.equals(a)); + Assertions.assertTrue(a.equals(a)); // other is null - Assert.assertFalse(a.equals(null)); + Assertions.assertFalse(a.equals(null)); // equals with a different class - Assert.assertFalse(a.equals("not an IntList")); + Assertions.assertFalse(a.equals("not an IntList")); // sorted and unsorted lists with same length final IntList sorted = IntList.of(1, 2, 3, 4); final IntList unsorted = IntList.of(4, 3, 2, 1); - Assert.assertFalse(sorted.equals(unsorted)); - Assert.assertNotEquals(sorted.hashCode(), unsorted.hashCode()); + Assertions.assertFalse(sorted.equals(unsorted)); + Assertions.assertNotEquals(sorted.hashCode(), unsorted.hashCode()); } @Test @@ -573,7 +573,7 @@ public class IntListTest { list.sort(); final int[] expected = new int[] { 1, 2, 3, 4 }; - Assert.assertArrayEquals(expected, list.toArray()); + Assertions.assertArrayEquals(expected, list.toArray()); } @Test @@ -584,7 +584,7 @@ public class IntListTest { list.parallelSort(); final int[] expected = new int[] { 1, 2, 3, 4 }; - Assert.assertArrayEquals(expected, list.toArray()); + Assertions.assertArrayEquals(expected, list.toArray()); } @Test @@ -596,13 +596,13 @@ public class IntListTest { final Random random = new Random(1); list.shuffle(random); - Assert.assertEquals(original.size(), list.size()); + Assertions.assertEquals(original.size(), list.size()); original.removeAll(list); - Assert.assertTrue("original minus shuffled list: " + original, original.isEmpty()); + Assertions.assertTrue(original.isEmpty(), "original minus shuffled list: " + original); list.removeAll(original2); - Assert.assertTrue("shuffled list minus original: " + list, list.isEmpty()); + Assertions.assertTrue(list.isEmpty(), "shuffled list minus original: " + list); } @Test @@ -610,7 +610,7 @@ public class IntListTest { final IntList list = IntList.of(); list.shuffle(); - Assert.assertTrue("an empty list is sorted", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "an empty list is sorted"); } @Test @@ -618,7 +618,7 @@ public class IntListTest { final IntList list = IntList.of(1); list.shuffle(); - Assert.assertTrue("a shuffled list of size 1 is sorted", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "a shuffled list of size 1 is sorted"); } @Test @@ -626,7 +626,7 @@ public class IntListTest { final IntList list = IntList.of(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1); list.shuffle(); - Assert.assertTrue("a shuffled list with identical elements is sorted", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "a shuffled list with identical elements is sorted"); } @Test @@ -642,11 +642,11 @@ public class IntListTest { sorted += IntList.of(1, 2, 3).equals(list) ? 1 : 0; unsorted += IntList.of(1, 2, 3).equals(list) ? 0 : 1; - Assert.assertEquals(IntList.of(1, 2, 3).equals(list), list.isSorted()); + Assertions.assertEquals(IntList.of(1, 2, 3).equals(list), list.isSorted()); } - Assert.assertTrue(sorted > 0); - Assert.assertTrue(unsorted > 0); + Assertions.assertTrue(sorted > 0); + Assertions.assertTrue(unsorted > 0); } private int[] removeElements(final int[] data, final int... removedIndices) { @@ -692,12 +692,11 @@ public class IntListTest { ObjectInputStream in = new ObjectInputStream(byteInputStream)) { final IntList actual = (IntList) in.readObject(); - Assert.assertEquals(list, actual); + Assertions.assertEquals(list, actual); - Assert.assertEquals( + Assertions.assertEquals(list.size(), actual.getCapacity(), "The capacity of the deserialized list. Should be equal to the number of inserted " - + "values, because we don't want to serialize the unused part of the array", - list.size(), actual.getCapacity()); + + "values, because we don't want to serialize the unused part of the array"); } } @@ -708,10 +707,10 @@ public class IntListTest { final IntList clone = list.clone(); - Assert.assertEquals(list, clone); + Assertions.assertEquals(list, clone); list.set(1, 0); - Assert.assertNotEquals(list, clone); + Assertions.assertNotEquals(list, clone); } @Test @@ -719,7 +718,7 @@ public class IntListTest { final IntList list = new IntList(); final IntList clone = list.clone(); - Assert.assertEquals(list, clone); + Assertions.assertEquals(list, clone); } @Test @@ -727,7 +726,7 @@ public class IntListTest { final IntList list = IntList.of(3, 2, 1); final IntList clone = list.clone(); - Assert.assertEquals(list.isSorted(), clone.isSorted()); + Assertions.assertEquals(list.isSorted(), clone.isSorted()); } @Test @@ -735,17 +734,17 @@ public class IntListTest { final IntList list = IntList.of(1, 2, 3); final IntList clone = list.clone(); - Assert.assertEquals(list.isSorted(), clone.isSorted()); + Assertions.assertEquals(list.isSorted(), clone.isSorted()); } @Test public void testToString() { - Assert.assertEquals("[]", new IntList().toString()); + Assertions.assertEquals("[]", new IntList().toString()); final IntList list = new IntList(); list.addAll(-2, -1, 0, 1, 2); - Assert.assertEquals("[-2, -1, 0, 1, 2]", list.toString()); - Assert.assertEquals("same result as Arrays.toString()", Arrays.toString(list.toArray()), list.toString()); + Assertions.assertEquals("[-2, -1, 0, 1, 2]", list.toString()); + Assertions.assertEquals("same result as Arrays.toString()", Arrays.toString(list.toArray()), list.toString()); } @Test @@ -755,17 +754,17 @@ public class IntListTest { final IntList list = new IntList(); list.addAll(0, 1, 2, 3, 4, 5, 6); final IntStream stream = list.stream(); - Assert.assertEquals(list.size(), stream.count()); + Assertions.assertEquals(list.size(), stream.count()); } { final IntList list = new IntList(); list.addAll(0, 1, 2, 3, 4, 5); final IntStream stream = list.stream(); - Assert.assertEquals(15, stream.sum()); + Assertions.assertEquals(15, stream.sum()); } { final IntList emptyList = new IntList(); - Assert.assertEquals(0, emptyList.stream().count()); + Assertions.assertEquals(0, emptyList.stream().count()); } } @@ -787,122 +786,122 @@ public class IntListTest { .boxed()// .collect(Collectors.toList()); - Assert.assertEquals("should be sequential, when using collect", actualList.toString(), list.toString()); - Assert.assertNotEquals("should use parallelism during computation", processingOrder.toString(), + Assertions.assertEquals("should be sequential, when using collect", actualList.toString(), list.toString()); + Assertions.assertNotEquals("should use parallelism during computation", processingOrder.toString(), list.toString()); } @Test public void testIndexOfOnSortedList() { final IntList list = new IntList(); - Assert.assertEquals(-1, list.indexOf(0)); + Assertions.assertEquals(-1, list.indexOf(0)); list.add(1); - Assert.assertEquals(-1, list.indexOf(0)); - Assert.assertEquals(0, list.indexOf(1)); + Assertions.assertEquals(-1, list.indexOf(0)); + Assertions.assertEquals(0, list.indexOf(1)); list.add(2); - Assert.assertEquals(-1, list.indexOf(0)); - Assert.assertEquals(0, list.indexOf(1)); - Assert.assertEquals(1, list.indexOf(2)); + Assertions.assertEquals(-1, list.indexOf(0)); + Assertions.assertEquals(0, list.indexOf(1)); + Assertions.assertEquals(1, list.indexOf(2)); } @Test public void testIndexOfOnSortedListReturnsFirstMatch() { final IntList list = IntList.of(0, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 4); - Assert.assertEquals(2, list.indexOf(2)); - Assert.assertEquals(4, list.indexOf(2, 4)); + Assertions.assertEquals(2, list.indexOf(2)); + Assertions.assertEquals(4, list.indexOf(2, 4)); } @Test public void testIndexOfOnUnsortedList() { final IntList list = IntList.of(2, 0, 1); - Assert.assertEquals(1, list.indexOf(0)); + Assertions.assertEquals(1, list.indexOf(0)); - Assert.assertEquals(0, list.indexOf(2)); - Assert.assertEquals(2, list.indexOf(1)); - Assert.assertEquals(-1, list.indexOf(3)); + Assertions.assertEquals(0, list.indexOf(2)); + Assertions.assertEquals(2, list.indexOf(1)); + Assertions.assertEquals(-1, list.indexOf(3)); } @Test public void testIndexOfWithOffsetOnSortedList() { final IntList list = new IntList(); list.addAll(1, 1, 2, 3, 3); - Assert.assertEquals(0, list.indexOf(1, 0)); - Assert.assertEquals(1, list.indexOf(1, 1)); - Assert.assertEquals(2, list.indexOf(2, 2)); - Assert.assertEquals(-1, list.indexOf(2, 3)); - Assert.assertEquals(3, list.indexOf(3, 2)); + Assertions.assertEquals(0, list.indexOf(1, 0)); + Assertions.assertEquals(1, list.indexOf(1, 1)); + Assertions.assertEquals(2, list.indexOf(2, 2)); + Assertions.assertEquals(-1, list.indexOf(2, 3)); + Assertions.assertEquals(3, list.indexOf(3, 2)); } @Test public void testIndexOfWithOffsetOnSortedListWithOffsetOutOfRange() { final IntList list = new IntList(); list.addAll(1); - Assert.assertEquals(0, list.indexOf(1, -1)); - Assert.assertEquals(-1, list.indexOf(1, list.size())); + Assertions.assertEquals(0, list.indexOf(1, -1)); + Assertions.assertEquals(-1, list.indexOf(1, list.size())); } @Test public void testIndexOfWithOffsetOnUnsortedList() { final IntList list = new IntList(); list.addAll(0, 2, 0, 2); - Assert.assertEquals(1, list.indexOf(2, 0)); - Assert.assertEquals(1, list.indexOf(2, 1)); - Assert.assertEquals(3, list.indexOf(2, 2)); - Assert.assertEquals(3, list.indexOf(2, 3)); - Assert.assertEquals(-1, list.indexOf(2, 4)); + Assertions.assertEquals(1, list.indexOf(2, 0)); + Assertions.assertEquals(1, list.indexOf(2, 1)); + Assertions.assertEquals(3, list.indexOf(2, 2)); + Assertions.assertEquals(3, list.indexOf(2, 3)); + Assertions.assertEquals(-1, list.indexOf(2, 4)); // indexed returned by indexOf() are consistent with get() - Assert.assertEquals(list.get(list.indexOf(2, 0)), 2); - Assert.assertEquals(list.get(list.indexOf(2, 1)), 2); - Assert.assertEquals(list.get(list.indexOf(2, 2)), 2); - Assert.assertEquals(list.get(list.indexOf(2, 3)), 2); + Assertions.assertEquals(list.get(list.indexOf(2, 0)), 2); + Assertions.assertEquals(list.get(list.indexOf(2, 1)), 2); + Assertions.assertEquals(list.get(list.indexOf(2, 2)), 2); + Assertions.assertEquals(list.get(list.indexOf(2, 3)), 2); } @Test public void testLastIndexOfWithOffsetOnEmptyList() { final IntList list = IntList.of(); - Assert.assertEquals(-1, list.lastIndexOf(3, list.size())); + Assertions.assertEquals(-1, list.lastIndexOf(3, list.size())); } @Test public void testLastIndexOfWithOffsetOnSortedList() { final IntList list = IntList.of(1, 2, 2, 3, 4, 5, 6, 7, 8, 9); - Assert.assertEquals(3, list.lastIndexOf(3, list.size())); - Assert.assertEquals(2, list.lastIndexOf(2, list.size())); - Assert.assertEquals(0, list.lastIndexOf(1, list.size())); + Assertions.assertEquals(3, list.lastIndexOf(3, list.size())); + Assertions.assertEquals(2, list.lastIndexOf(2, list.size())); + Assertions.assertEquals(0, list.lastIndexOf(1, list.size())); - Assert.assertEquals(2, list.lastIndexOf(2, 2)); // fromIndex == result - Assert.assertEquals(1, list.lastIndexOf(2, 1)); // fromIndex == result && the next element would be a hit + Assertions.assertEquals(2, list.lastIndexOf(2, 2)); // fromIndex == result + Assertions.assertEquals(1, list.lastIndexOf(2, 1)); // fromIndex == result && the next element would be a hit - Assert.assertEquals(0, list.lastIndexOf(1, 0)); // fromIndex 0; found - Assert.assertEquals(-1, list.lastIndexOf(99, 0)); // fromIndex 0; not found - Assert.assertEquals(-1, list.lastIndexOf(99, list.size())); // fromIndex larger than list && not found + Assertions.assertEquals(0, list.lastIndexOf(1, 0)); // fromIndex 0; found + Assertions.assertEquals(-1, list.lastIndexOf(99, 0)); // fromIndex 0; not found + Assertions.assertEquals(-1, list.lastIndexOf(99, list.size())); // fromIndex larger than list && not found } @Test public void testLastIndexOfOnSortedListReturnsFirstMatch() { final IntList list = IntList.of(0, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 4); - Assert.assertEquals(13, list.lastIndexOf(2)); - Assert.assertEquals(10, list.lastIndexOf(2, 10)); + Assertions.assertEquals(13, list.lastIndexOf(2)); + Assertions.assertEquals(10, list.lastIndexOf(2, 10)); } @Test public void testLastIndexOfWithOffsetOnUnsortedList() { final IntList list = IntList.of(1, 2, 3, 1, 2, 3); - Assert.assertEquals(5, list.lastIndexOf(3, list.size())); - Assert.assertEquals(4, list.lastIndexOf(2, list.size())); - Assert.assertEquals(3, list.lastIndexOf(1, list.size())); - Assert.assertEquals(-1, list.lastIndexOf(99, list.size())); - Assert.assertEquals(-1, list.lastIndexOf(99, 0)); + Assertions.assertEquals(5, list.lastIndexOf(3, list.size())); + Assertions.assertEquals(4, list.lastIndexOf(2, list.size())); + Assertions.assertEquals(3, list.lastIndexOf(1, list.size())); + Assertions.assertEquals(-1, list.lastIndexOf(99, list.size())); + Assertions.assertEquals(-1, list.lastIndexOf(99, 0)); - Assert.assertEquals(2, list.lastIndexOf(3, list.size() - 2)); - Assert.assertEquals(4, list.lastIndexOf(2, list.size() - 1)); - Assert.assertEquals(1, list.lastIndexOf(2, list.lastIndexOf(2) - 1)); + Assertions.assertEquals(2, list.lastIndexOf(3, list.size() - 2)); + Assertions.assertEquals(4, list.lastIndexOf(2, list.size() - 1)); + Assertions.assertEquals(1, list.lastIndexOf(2, list.lastIndexOf(2) - 1)); } @Test @@ -911,7 +910,7 @@ public class IntListTest { list.addAll(1, 2, 3); list.replaceAll(i -> i * 2); - Assert.assertArrayEquals(new int[] { 2, 4, 6 }, list.toArray()); + Assertions.assertArrayEquals(new int[] { 2, 4, 6 }, list.toArray()); } @Test @@ -919,7 +918,7 @@ public class IntListTest { final IntList list = new IntList(); list.replaceAll(i -> i * 3); - Assert.assertArrayEquals(new int[0], list.toArray()); + Assertions.assertArrayEquals(new int[0], list.toArray()); } @Test @@ -928,8 +927,8 @@ public class IntListTest { final IntList remove = IntList.of(-1, 2, 4, 5); list.removeAll(remove); - Assert.assertArrayEquals(new int[] { -2, 0, 1, 3, 6 }, list.toArray()); - Assert.assertArrayEquals(new int[] { -1, 2, 4, 5 }, remove.toArray()); + Assertions.assertArrayEquals(new int[] { -2, 0, 1, 3, 6 }, list.toArray()); + Assertions.assertArrayEquals(new int[] { -1, 2, 4, 5 }, remove.toArray()); } @Test @@ -938,8 +937,8 @@ public class IntListTest { final IntList remove = new IntList(); list.removeAll(remove); - Assert.assertArrayEquals(new int[] { 1, 2, 3, 4, 5, 6 }, list.toArray()); - Assert.assertArrayEquals(new int[] {}, remove.toArray()); + Assertions.assertArrayEquals(new int[] { 1, 2, 3, 4, 5, 6 }, list.toArray()); + Assertions.assertArrayEquals(new int[] {}, remove.toArray()); } @Test @@ -948,8 +947,8 @@ public class IntListTest { final IntList remove = IntList.of(1); list.removeAll(remove); - Assert.assertArrayEquals(new int[] {}, list.toArray()); - Assert.assertEquals(0, list.size()); + Assertions.assertArrayEquals(new int[] {}, list.toArray()); + Assertions.assertEquals(0, list.size()); } @Test @@ -958,8 +957,8 @@ public class IntListTest { final IntList retain = IntList.of(-1, 2, 4, 5, 99); list.retainAll(retain); - Assert.assertArrayEquals(new int[] { -1, 2, 4, 5 }, list.toArray()); - Assert.assertArrayEquals(new int[] { -1, 2, 4, 5, 99 }, retain.toArray()); + Assertions.assertArrayEquals(new int[] { -1, 2, 4, 5 }, list.toArray()); + Assertions.assertArrayEquals(new int[] { -1, 2, 4, 5, 99 }, retain.toArray()); } @Test @@ -968,8 +967,8 @@ public class IntListTest { final IntList retain = IntList.of(-1, 2, 4, 5, 99); list.retainAll(retain); - Assert.assertArrayEquals(new int[] {}, list.toArray()); - Assert.assertArrayEquals(new int[] { -1, 2, 4, 5, 99 }, retain.toArray()); + Assertions.assertArrayEquals(new int[] {}, list.toArray()); + Assertions.assertArrayEquals(new int[] { -1, 2, 4, 5, 99 }, retain.toArray()); } @Test @@ -978,8 +977,8 @@ public class IntListTest { final IntList retain = IntList.of(); list.retainAll(retain); - Assert.assertArrayEquals(new int[] {}, list.toArray()); - Assert.assertArrayEquals(new int[] {}, retain.toArray()); + Assertions.assertArrayEquals(new int[] {}, list.toArray()); + Assertions.assertArrayEquals(new int[] {}, retain.toArray()); } @Test @@ -987,7 +986,7 @@ public class IntListTest { final IntList list = IntList.of(1, 2, 3, 4, 5, 6); list.removeIf((value, index) -> value % 2 == 0); - Assert.assertArrayEquals(new int[] { 1, 3, 5 }, list.toArray()); + Assertions.assertArrayEquals(new int[] { 1, 3, 5 }, list.toArray()); } @Test @@ -996,7 +995,7 @@ public class IntListTest { final IntPredicate predicate = (value, index) -> value % 2 == 0; list.removeIf(predicate.negate()); - Assert.assertArrayEquals(new int[] { 2, 4, 6 }, list.toArray()); + Assertions.assertArrayEquals(new int[] { 2, 4, 6 }, list.toArray()); } @Test @@ -1006,7 +1005,7 @@ public class IntListTest { final IntPredicate predicateA = (value, index) -> value % 2 == 0; final IntPredicate predicateB = (value, index) -> value == 3 || value == 4; list.removeIf(predicateA.and(predicateB)); - Assert.assertArrayEquals(new int[] { 1, 2, 3, 5, 6 }, list.toArray()); + Assertions.assertArrayEquals(new int[] { 1, 2, 3, 5, 6 }, list.toArray()); } @Test @@ -1016,7 +1015,7 @@ public class IntListTest { final IntPredicate predicateA = (value, index) -> value % 2 == 0; final IntPredicate predicateB = (value, index) -> value == 3 || value == 4; list.removeIf(predicateA.or(predicateB)); - Assert.assertArrayEquals(new int[] { 1, 5 }, list.toArray()); + Assertions.assertArrayEquals(new int[] { 1, 5 }, list.toArray()); } @Test @@ -1024,29 +1023,29 @@ public class IntListTest { final IntList list = IntList.of(); list.removeIf((value, index) -> false); - Assert.assertArrayEquals(new int[] {}, list.toArray()); + Assertions.assertArrayEquals(new int[] {}, list.toArray()); } @Test public void testSortedFlagSort() { - Assert.assertTrue("empty list is sorted", new IntList().isSorted()); + Assertions.assertTrue(new IntList().isSorted(), "empty list is sorted"); final IntList list = new IntList(); list.addAll(2, 0, 1); list.sort(); - Assert.assertTrue("is sorted after calling sort", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "is sorted after calling sort"); } @Test public void testSortedFlagEmptyList() { - Assert.assertTrue("empty list is sorted", new IntList().isSorted()); + Assertions.assertTrue(new IntList().isSorted(), "empty list is sorted"); final IntList list = new IntList(); list.addAll(2, 0, 1); list.remove(0, list.size()); - Assert.assertTrue("unsorted list initialized by addAll", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "unsorted list initialized by addAll"); } @Test @@ -1054,15 +1053,15 @@ public class IntListTest { final IntList list = new IntList(); list.add(1); - Assert.assertTrue("[1]", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "[1]"); list.add(2); - Assert.assertTrue("[1,2]", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "[1,2]"); list.add(2); - Assert.assertTrue("[1,2,2]", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "[1,2,2]"); list.add(1); - Assert.assertFalse("[1,2,2,1]", list.isSorted()); + Assertions.assertFalse(list.isSorted(), "[1,2,2,1]"); list.add(1); - Assert.assertFalse("[1,2,2,1,1]", list.isSorted()); + Assertions.assertFalse(list.isSorted(), "[1,2,2,1,1]"); } @Test @@ -1071,19 +1070,19 @@ public class IntListTest { { final IntList list = new IntList(); list.addAll(2, 0); - Assert.assertFalse("unsorted list initialized by addAll", list.isSorted()); + Assertions.assertFalse(list.isSorted(), "unsorted list initialized by addAll"); } { final IntList list = new IntList(); list.addAll(1); - Assert.assertTrue("list with one element is sorted", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "list with one element is sorted"); } { final IntList list = new IntList(); list.addAll(1, 1); - Assert.assertTrue("list with all the same elements is sorted", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "list with all the same elements is sorted"); } } @@ -1096,35 +1095,35 @@ public class IntListTest { { final IntList list = new IntList(); list.insert(0, 1, 2, 3); - Assert.assertTrue("insert sorted values into empty list", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "insert sorted values into empty list"); } { final IntList list = IntList.of(1, 1); list.insert(0, 2, 2); // -> [2,2,1,1] - Assert.assertFalse("insert before: unsorted", list.isSorted()); + Assertions.assertFalse(list.isSorted(), "insert before: unsorted"); } { final IntList list = IntList.of(3, 3); list.insert(0, 2, 2); // -> [2,2,3,3] - Assert.assertTrue("insert sorted values before: sorted", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "insert sorted values before: sorted"); } { final IntList list = IntList.of(4, 4); list.insert(2, 2, 2); // -> [4,4,2,2] - Assert.assertFalse("insert sorted values at end: unsorted", list.isSorted()); + Assertions.assertFalse(list.isSorted(), "insert sorted values at end: unsorted"); } { final IntList list = IntList.of(1, 1); list.insert(2, 2, 2); // -> [1,1,2,2] - Assert.assertTrue("insert sorted values at end: sorted", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "insert sorted values at end: sorted"); } { final IntList list = IntList.of(1, 4); list.insert(1, 2, 2); // -> [1,2,2,4] - Assert.assertTrue("insert sorted values in middle: sorted", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "insert sorted values in middle: sorted"); } /* @@ -1133,39 +1132,39 @@ public class IntListTest { { final IntList list = IntList.of(1, 4); list.insert(1, 5); // -> [1,5,4] - Assert.assertFalse("insert sorted values in middle: unsorted", list.isSorted()); + Assertions.assertFalse(list.isSorted(), "insert sorted values in middle: unsorted"); } { final IntList list = IntList.of(1, 4); list.insert(1, 6, 6); // -> [1,6,6,4] - Assert.assertFalse("insert sorted values in middle: unsorted", list.isSorted()); + Assertions.assertFalse(list.isSorted(), "insert sorted values in middle: unsorted"); } { final IntList list = IntList.of(1, 4); list.insert(1, 0); // -> [1,0,4] - Assert.assertFalse("insert sorted values in middle: unsorted", list.isSorted()); + Assertions.assertFalse(list.isSorted(), "insert sorted values in middle: unsorted"); } { final IntList list = IntList.of(1, 4); list.insert(1, 0, 0); // -> [1,0,0,4] - Assert.assertFalse("insert sorted values in middle: unsorted", list.isSorted()); + Assertions.assertFalse(list.isSorted(), "insert sorted values in middle: unsorted"); } { final IntList list = IntList.of(3, 4); list.insert(0, 2, 1); // -> [2,1,3,4] - Assert.assertFalse("insert unsorted at begin: unsorted", list.isSorted()); + Assertions.assertFalse(list.isSorted(), "insert unsorted at begin: unsorted"); } { final IntList list = IntList.of(1, 4); list.insert(1, 2, 1); // -> [1,2,1,4] - Assert.assertFalse("insert unsorted middle: unsorted", list.isSorted()); + Assertions.assertFalse(list.isSorted(), "insert unsorted middle: unsorted"); } { final IntList list = IntList.of(3, 4); list.insert(2, 6, 5); // -> [13,4,6,5] - Assert.assertFalse("insert unsorted at end: unsorted", list.isSorted()); + Assertions.assertFalse(list.isSorted(), "insert unsorted at end: unsorted"); } } @@ -1176,40 +1175,40 @@ public class IntListTest { { final IntList list = IntList.of(0, 1, 2); list.set(0, -1); - Assert.assertTrue("set first element: [-1,1,2] sorted", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "set first element: [-1,1,2] sorted"); list.set(0, 1); - Assert.assertTrue("set first element: [1,1,2] sorted", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "set first element: [1,1,2] sorted"); list.set(0, 2); - Assert.assertFalse("set first element: [2,1,2] not sorted", list.isSorted()); + Assertions.assertFalse(list.isSorted(), "set first element: [2,1,2] not sorted"); } { final IntList sortedList = IntList.of(0, 2, 4); sortedList.set(1, 3); - Assert.assertTrue("set middle element: [0,3,4] sorteed", sortedList.isSorted()); + Assertions.assertTrue(sortedList.isSorted(), "set middle element: [0,3,4] sorteed"); sortedList.set(1, 4); - Assert.assertTrue("set middle element: [0,4,4] sorteed", sortedList.isSorted()); + Assertions.assertTrue(sortedList.isSorted(), "set middle element: [0,4,4] sorteed"); sortedList.set(1, 0); - Assert.assertTrue("set middle element: [0,0,4] sorteed", sortedList.isSorted()); + Assertions.assertTrue(sortedList.isSorted(), "set middle element: [0,0,4] sorteed"); sortedList.set(1, 5); - Assert.assertFalse("set middle element: [0,5,4] not sorteed", sortedList.isSorted()); + Assertions.assertFalse(sortedList.isSorted(), "set middle element: [0,5,4] not sorteed"); } { final IntList sortedList = IntList.of(0, 1, 2); sortedList.set(2, 3); - Assert.assertTrue("set last element: [0,1,3] sorteed", sortedList.isSorted()); + Assertions.assertTrue(sortedList.isSorted(), "set last element: [0,1,3] sorteed"); sortedList.set(2, 1); - Assert.assertTrue("set last element: [0,1,1] sorteed", sortedList.isSorted()); + Assertions.assertTrue(sortedList.isSorted(), "set last element: [0,1,1] sorteed"); sortedList.set(2, 0); - Assert.assertFalse("set last element: [0,1,0] not sorteed", sortedList.isSorted()); + Assertions.assertFalse(sortedList.isSorted(), "set last element: [0,1,0] not sorteed"); } { final IntList sortedList = IntList.of(0, 1, 2); sortedList.set(2, 0); sortedList.set(2, 2); - Assert.assertFalse("unsorted lists stay unsorted", sortedList.isSorted()); + Assertions.assertFalse(sortedList.isSorted(), "unsorted lists stay unsorted"); } } @@ -1218,14 +1217,14 @@ public class IntListTest { final IntList list = IntList.of(4, 3, 2, 1); list.remove(0, 2); // removes 4,3 - Assert.assertFalse("unsorted list with two elements is not sorted", list.isSorted()); + Assertions.assertFalse(list.isSorted(), "unsorted list with two elements is not sorted"); list.remove(0, 1); - Assert.assertTrue("unsorted list with one element becomes sorted", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "unsorted list with one element becomes sorted"); list.add(-1); // make list unsorted again list.remove(0, 2); // remove both elements - Assert.assertTrue("unsorted list with no elements becomes sorted", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "unsorted list with no elements becomes sorted"); } @Test @@ -1233,7 +1232,7 @@ public class IntListTest { final IntList list = IntList.of(4, 3, 2, 1); list.remove(0, 4); // removes all - Assert.assertTrue("empty list is sorted", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "empty list is sorted"); } @Test @@ -1241,7 +1240,7 @@ public class IntListTest { final IntList list = IntList.of(4, 3, 2, 1); list.remove(1, 4); // removes 3,2,1 - Assert.assertTrue("list with one element is", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "list with one element is"); } @Test @@ -1249,7 +1248,7 @@ public class IntListTest { final IntList list = IntList.of(1, 2, 777, 4, 5); list.remove(2, 3); // removes 777 - Assert.assertTrue("list is sorted after remove", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "list is sorted after remove"); } @Test @@ -1257,14 +1256,14 @@ public class IntListTest { final IntList list = IntList.of(4, 3, 2, 1); list.removeAll(IntList.of(4, 3)); - Assert.assertFalse("unsorted list with two elements is not sorted", list.isSorted()); + Assertions.assertFalse(list.isSorted(), "unsorted list with two elements is not sorted"); list.removeAll(IntList.of(2)); - Assert.assertTrue("unsorted list with one element becomes sorted", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "unsorted list with one element becomes sorted"); list.add(-1); // make list unsorted again list.removeAll(IntList.of(-1, 2)); // remove both elements - Assert.assertTrue("unsorted list with no elements becomes sorted", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "unsorted list with no elements becomes sorted"); } @Test @@ -1272,14 +1271,14 @@ public class IntListTest { final IntList list = IntList.of(4, 3, 2, 1); list.removeIf((value, index) -> value >= 3); // removes 3 and 4 - Assert.assertFalse("unsorted list with two elements is not sorted", list.isSorted()); + Assertions.assertFalse(list.isSorted(), "unsorted list with two elements is not sorted"); list.removeIf((value, index) -> value >= 2); // removes 2 - Assert.assertTrue("unsorted list with one element becomes sorted", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "unsorted list with one element becomes sorted"); list.add(-1); // make list unsorted again list.removeIf((value, index) -> true); // remove both elements - Assert.assertTrue("unsorted list with no elements becomes sorted", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "unsorted list with no elements becomes sorted"); } @Test @@ -1287,8 +1286,8 @@ public class IntListTest { final IntList list = IntList.of(1, 3, 2); list.removeIf((value, index) -> true); // makes the list sorted - Assert.assertTrue("list is empty", list.isEmpty()); - Assert.assertTrue("empty list is sorted", list.isSorted()); + Assertions.assertTrue(list.isEmpty(), "list is empty"); + Assertions.assertTrue(list.isSorted(), "empty list is sorted"); } @Test @@ -1296,7 +1295,7 @@ public class IntListTest { final IntList list = IntList.of(1, 3, 2); list.removeIf((value, index) -> value > 1); // makes the list sorted - Assert.assertTrue("list with one element is sorted", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "list with one element is sorted"); } @Test @@ -1304,7 +1303,7 @@ public class IntListTest { final IntList list = IntList.of(1, 2, 3, 777, 4, 5); list.removeIf((value, index) -> value == 777); // makes the list sorted - Assert.assertTrue("unsorted list becomes sorted", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "unsorted list becomes sorted"); } @Test @@ -1312,13 +1311,13 @@ public class IntListTest { final IntList list = IntList.of(1, 2, 3, 4); list.replaceAll(v -> v >= 3 ? 2 : v); // replace 3 and 4 with 2 -> [1,2,2,2] - Assert.assertTrue("sorted list still sorted after replace", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "sorted list still sorted after replace"); list.replaceAll(v -> v == 1 ? 3 : v); // replace 1 with 3 -> [3,2,2,2] - Assert.assertFalse("sorted list becomes unsorted after replace", list.isSorted()); + Assertions.assertFalse(list.isSorted(), "sorted list becomes unsorted after replace"); list.replaceAll(v -> 2); // replace all with 2 -> [2,2,2,2] - Assert.assertFalse("unsorted list stays unsorted", list.isSorted()); + Assertions.assertFalse(list.isSorted(), "unsorted list stays unsorted"); } @Test @@ -1327,14 +1326,14 @@ public class IntListTest { final IntList a = IntList.of(0, 1, 2, 3, 4); final IntList b = IntList.of(2, 4, 5); final IntList actual = IntList.intersection(a, b); - Assert.assertEquals(IntList.of(2, 4), actual); + Assertions.assertEquals(IntList.of(2, 4), actual); } { final IntList a = IntList.of(0, 2, 4, 6); final IntList b = IntList.of(3, 5); final IntList actual = IntList.intersection(a, b); - Assert.assertEquals(IntList.of(), actual); + Assertions.assertEquals(IntList.of(), actual); } /* @@ -1344,13 +1343,13 @@ public class IntListTest { final IntList a = IntList.of(3, 3, 3); final IntList b = IntList.of(3, 3); final IntList actual = IntList.intersection(a, b); - Assert.assertEquals(IntList.of(3), actual); + Assertions.assertEquals(IntList.of(3), actual); } { final IntList a = IntList.of(4, 4); final IntList b = IntList.of(4, 4, 4); final IntList actual = IntList.intersection(a, b); - Assert.assertEquals(IntList.of(4), actual); + Assertions.assertEquals(IntList.of(4), actual); } } @@ -1363,7 +1362,7 @@ public class IntListTest { b.shuffle(); final IntList actual = IntList.intersection(a, b); actual.sort(); - Assert.assertEquals(IntList.of(2, 4), actual); + Assertions.assertEquals(IntList.of(2, 4), actual); } /* @@ -1373,13 +1372,13 @@ public class IntListTest { final IntList a = IntList.of(3, 5, 3, 3, 1); final IntList b = IntList.of(2, 3, 3); final IntList actual = IntList.intersection(a, b); - Assert.assertEquals(IntList.of(3), actual); + Assertions.assertEquals(IntList.of(3), actual); } { final IntList a = IntList.of(1, 4); final IntList b = IntList.of(4, 3, 4, 4, 2); final IntList actual = IntList.intersection(a, b); - Assert.assertEquals(IntList.of(4), actual); + Assertions.assertEquals(IntList.of(4), actual); } } @@ -1388,8 +1387,8 @@ public class IntListTest { final IntList a = IntList.of(); final IntList b = IntList.of(); - Assert.assertEquals(IntList.of(), IntList.union(a, b)); - Assert.assertEquals(IntList.union(a, b), IntList.union(b, a)); + Assertions.assertEquals(IntList.of(), IntList.union(a, b)); + Assertions.assertEquals(IntList.union(a, b), IntList.union(b, a)); } @Test @@ -1398,8 +1397,8 @@ public class IntListTest { final IntList b = IntList.of(2, 4, 5); final IntList actual = IntList.union(a, b); - Assert.assertEquals(IntList.of(0, 1, 2, 3, 4, 5), actual); - Assert.assertEquals(IntList.union(a, b), IntList.union(b, a)); + Assertions.assertEquals(IntList.of(0, 1, 2, 3, 4, 5), actual); + Assertions.assertEquals(IntList.union(a, b), IntList.union(b, a)); } @Test @@ -1408,8 +1407,8 @@ public class IntListTest { final IntList b = IntList.of(1, 3); final IntList actual = IntList.union(a, b); - Assert.assertEquals(IntList.of(1, 2, 3), actual); - Assert.assertEquals(IntList.union(a, b), IntList.union(b, a)); + Assertions.assertEquals(IntList.of(1, 2, 3), actual); + Assertions.assertEquals(IntList.union(a, b), IntList.union(b, a)); } @Test @@ -1418,8 +1417,8 @@ public class IntListTest { final IntList b = IntList.of(1, 2, 2, 4); final IntList actual = IntList.union(a, b); - Assert.assertEquals(IntList.of(1, 2, 3, 4), actual); - Assert.assertEquals(IntList.union(a, b), IntList.union(b, a)); + Assertions.assertEquals(IntList.of(1, 2, 3, 4), actual); + Assertions.assertEquals(IntList.union(a, b), IntList.union(b, a)); } @Test @@ -1428,8 +1427,8 @@ public class IntListTest { final IntList b = IntList.of(2, 2); final IntList actual = IntList.union(a, b); - Assert.assertEquals(IntList.of(2), actual); - Assert.assertEquals(IntList.union(a, b), IntList.union(b, a)); + Assertions.assertEquals(IntList.of(2), actual); + Assertions.assertEquals(IntList.union(a, b), IntList.union(b, a)); } @Test @@ -1438,8 +1437,8 @@ public class IntListTest { final IntList b = IntList.of(2, 5, 4); final IntList actual = IntList.union(a, b); - Assert.assertEquals(IntList.of(0, 1, 2, 3, 4, 5), actual); - Assert.assertEquals(IntList.union(a, b), IntList.union(b, a)); + Assertions.assertEquals(IntList.of(0, 1, 2, 3, 4, 5), actual); + Assertions.assertEquals(IntList.union(a, b), IntList.union(b, a)); } @Test @@ -1448,7 +1447,7 @@ public class IntListTest { final IntList b = IntList.of(2, 5, 4); final IntList actual = IntList.union(a, b); - Assert.assertEquals(IntList.of(1, 2, 3, 4, 5), actual); - Assert.assertEquals(IntList.union(a, b), IntList.union(b, a)); + Assertions.assertEquals(IntList.of(1, 2, 3, 4, 5), actual); + Assertions.assertEquals(IntList.union(a, b), IntList.union(b, a)); } } diff --git a/primitiveCollections/src/test/java/org/lucares/collections/LongListTest.java b/primitiveCollections/src/test/java/org/lucares/collections/LongListTest.java index 937c148..f353cdf 100644 --- a/primitiveCollections/src/test/java/org/lucares/collections/LongListTest.java +++ b/primitiveCollections/src/test/java/org/lucares/collections/LongListTest.java @@ -13,8 +13,8 @@ import java.util.concurrent.ThreadLocalRandom; import java.util.stream.Collectors; import java.util.stream.LongStream; -import org.junit.Assert; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; public class LongListTest { @@ -22,7 +22,7 @@ public class LongListTest { public void testEmptyList() { final LongList list = new LongList(); - Assert.assertEquals(true, list.isEmpty()); + Assertions.assertEquals(true, list.isEmpty()); } @Test @@ -32,14 +32,14 @@ public class LongListTest { final LongList copy = new LongList(list); - Assert.assertArrayEquals(copy.toArray(), list.toArray()); + Assertions.assertArrayEquals(copy.toArray(), list.toArray()); } @Test public void testInvalidInitialCapacity() { try { new LongList(-1); - Assert.fail(); + Assertions.fail(); } catch (final IllegalArgumentException e) { // expected } @@ -53,14 +53,14 @@ public class LongListTest { list.add(1); - Assert.assertFalse(list.isEmpty()); - Assert.assertEquals(1, list.size()); + Assertions.assertFalse(list.isEmpty()); + Assertions.assertEquals(1, list.size()); list.add(2); - Assert.assertEquals(2, list.size()); + Assertions.assertEquals(2, list.size()); - Assert.assertEquals(1, list.get(0)); - Assert.assertEquals(2, list.get(1)); + Assertions.assertEquals(1, list.get(0)); + Assertions.assertEquals(2, list.get(1)); } @Test @@ -68,25 +68,25 @@ public class LongListTest { final LongList list = new LongList(); list.insert(0); - Assert.assertArrayEquals(new long[] {}, list.toArray()); + Assertions.assertArrayEquals(new long[] {}, list.toArray()); list.insert(0, 1); - Assert.assertArrayEquals(new long[] { 1 }, list.toArray()); + Assertions.assertArrayEquals(new long[] { 1 }, list.toArray()); list.insert(1, 2, 2, 2); - Assert.assertArrayEquals(new long[] { 1, 2, 2, 2 }, list.toArray()); + Assertions.assertArrayEquals(new long[] { 1, 2, 2, 2 }, list.toArray()); list.insert(1, 3); - Assert.assertArrayEquals(new long[] { 1, 3, 2, 2, 2 }, list.toArray()); + Assertions.assertArrayEquals(new long[] { 1, 3, 2, 2, 2 }, list.toArray()); list.insert(2, 4, 4, 4); - Assert.assertArrayEquals(new long[] { 1, 3, 4, 4, 4, 2, 2, 2 }, list.toArray()); + Assertions.assertArrayEquals(new long[] { 1, 3, 4, 4, 4, 2, 2, 2 }, list.toArray()); list.insert(2); - Assert.assertArrayEquals(new long[] { 1, 3, 4, 4, 4, 2, 2, 2 }, list.toArray()); + Assertions.assertArrayEquals(new long[] { 1, 3, 4, 4, 4, 2, 2, 2 }, list.toArray()); list.insert(8, 5, 5); - Assert.assertArrayEquals(new long[] { 1, 3, 4, 4, 4, 2, 2, 2, 5, 5 }, list.toArray()); + Assertions.assertArrayEquals(new long[] { 1, 3, 4, 4, 4, 2, 2, 2, 5, 5 }, list.toArray()); } @Test @@ -94,14 +94,14 @@ public class LongListTest { final LongList list = new LongList(); try { list.insert(-1, 1); - Assert.fail(); + Assertions.fail(); } catch (final IndexOutOfBoundsException e) { // expected } try { list.insert(1, 1); - Assert.fail(); + Assertions.fail(); } catch (final IndexOutOfBoundsException e) { // expected } @@ -109,7 +109,7 @@ public class LongListTest { try { list.add(1); list.insert(2, 2); - Assert.fail(); + Assertions.fail(); } catch (final IndexOutOfBoundsException e) { // expected } @@ -120,7 +120,7 @@ public class LongListTest { final LongList list = new LongList(); try { list.insert(0, null); - Assert.fail(); + Assertions.fail(); } catch (final NullPointerException e) { // expected } @@ -132,13 +132,13 @@ public class LongListTest { list.addAll(0, 1, 2, 3, 4, 5); list.set(0, 10); - Assert.assertArrayEquals(new long[] { 10, 1, 2, 3, 4, 5 }, list.toArray()); + Assertions.assertArrayEquals(new long[] { 10, 1, 2, 3, 4, 5 }, list.toArray()); list.set(1, 11); - Assert.assertArrayEquals(new long[] { 10, 11, 2, 3, 4, 5 }, list.toArray()); + Assertions.assertArrayEquals(new long[] { 10, 11, 2, 3, 4, 5 }, list.toArray()); list.set(5, 55); - Assert.assertArrayEquals(new long[] { 10, 11, 2, 3, 4, 55 }, list.toArray()); + Assertions.assertArrayEquals(new long[] { 10, 11, 2, 3, 4, 55 }, list.toArray()); } @Test @@ -146,14 +146,14 @@ public class LongListTest { final LongList list = new LongList(); try { list.set(-1, 1); - Assert.fail(); + Assertions.fail(); } catch (final IndexOutOfBoundsException e) { // expected } try { list.set(1, 1); - Assert.fail(); + Assertions.fail(); } catch (final IndexOutOfBoundsException e) { // expected } @@ -162,7 +162,7 @@ public class LongListTest { try { list.set(6, 1); - Assert.fail(); + Assertions.fail(); } catch (final IndexOutOfBoundsException e) { // expected } @@ -176,10 +176,10 @@ public class LongListTest { for (int i = 0; i < size; i++) { list.add(i); } - Assert.assertEquals(size, list.size()); + Assertions.assertEquals(size, list.size()); for (int i = 0; i < size; i++) { - Assert.assertEquals(i, list.get(i)); + Assertions.assertEquals(i, list.get(i)); } } @@ -191,10 +191,10 @@ public class LongListTest { for (int i = 0; i < size; i++) { list.add(i); } - Assert.assertEquals(size, list.size()); + Assertions.assertEquals(size, list.size()); for (int i = 0; i < size; i++) { - Assert.assertEquals(i, list.get(i)); + Assertions.assertEquals(i, list.get(i)); } } @@ -203,24 +203,24 @@ public class LongListTest { final LongList list = new LongList(); list.addAll(); - Assert.assertTrue(list.isEmpty()); - Assert.assertEquals(0, list.size()); + Assertions.assertTrue(list.isEmpty()); + Assertions.assertEquals(0, list.size()); final int size = 100; final long[] longs = ThreadLocalRandom.current().longs(size).toArray(); list.addAll(longs); - Assert.assertEquals(size, list.size()); + Assertions.assertEquals(size, list.size()); for (int i = 0; i < size; i++) { - Assert.assertEquals(longs[i], list.get(i)); + Assertions.assertEquals(longs[i], list.get(i)); } final long[] anotherLongs = ThreadLocalRandom.current().longs(size).toArray(); list.addAll(anotherLongs); - Assert.assertEquals(size * 2, list.size()); + Assertions.assertEquals(size * 2, list.size()); for (int i = 0; i < size; i++) { - Assert.assertEquals(anotherLongs[i], list.get(size + i)); + Assertions.assertEquals(anotherLongs[i], list.get(size + i)); } } @@ -230,55 +230,55 @@ public class LongListTest { // adding empty list with no capacity list.addAll(LongList.of()); - Assert.assertEquals(new LongList(), list); - Assert.assertTrue(list.isSorted()); + Assertions.assertEquals(new LongList(), list); + Assertions.assertTrue(list.isSorted()); // adding empty list with capacity 2 list.addAll(new LongList(2)); - Assert.assertEquals(new LongList(), list); - Assert.assertTrue(list.isSorted()); + Assertions.assertEquals(new LongList(), list); + Assertions.assertTrue(list.isSorted()); // adding sorted list to an empty list list.addAll(LongList.of(1, 2, 3)); - Assert.assertEquals(LongList.of(1, 2, 3), list); - Assert.assertTrue(list.isSorted()); + Assertions.assertEquals(LongList.of(1, 2, 3), list); + Assertions.assertTrue(list.isSorted()); // add empty list to a sorted list list.addAll(LongList.of()); - Assert.assertEquals(LongList.of(1, 2, 3), list); - Assert.assertTrue(list.isSorted()); + Assertions.assertEquals(LongList.of(1, 2, 3), list); + Assertions.assertTrue(list.isSorted()); // adding sorted list to a sorted list so that the list stays sorted list.addAll(LongList.of(3, 4, 5)); - Assert.assertEquals(LongList.of(1, 2, 3, 3, 4, 5), list); - Assert.assertTrue(list.isSorted()); + Assertions.assertEquals(LongList.of(1, 2, 3, 3, 4, 5), list); + Assertions.assertTrue(list.isSorted()); // adding sorted list to a sorted list, but the new list is not sorted list.clear(); list.addAll(LongList.of(1, 2, 3)); list.addAll(LongList.of(0)); - Assert.assertEquals(LongList.of(1, 2, 3, 0), list); - Assert.assertFalse(list.isSorted()); + Assertions.assertEquals(LongList.of(1, 2, 3, 0), list); + Assertions.assertFalse(list.isSorted()); // adding unsorted list to a sorted list list.clear(); list.addAll(LongList.of(1, 2, 3)); list.addAll(LongList.of(6, 5, 4)); - Assert.assertEquals(LongList.of(1, 2, 3, 6, 5, 4), list); - Assert.assertFalse(list.isSorted()); + Assertions.assertEquals(LongList.of(1, 2, 3, 6, 5, 4), list); + Assertions.assertFalse(list.isSorted()); // adding unsorted list to an empty list list.clear(); list.addAll(LongList.of(3, 2, 1)); - Assert.assertEquals(LongList.of(3, 2, 1), list); - Assert.assertFalse(list.isSorted()); + Assertions.assertEquals(LongList.of(3, 2, 1), list); + Assertions.assertFalse(list.isSorted()); // adding sorted list to an unsorted list list.clear(); list.addAll(LongList.of(3, 2, 1)); list.addAll(LongList.of(1, 2, 3)); - Assert.assertEquals(LongList.of(3, 2, 1, 1, 2, 3), list); - Assert.assertFalse(list.isSorted()); + Assertions.assertEquals(LongList.of(3, 2, 1, 1, 2, 3), list); + Assertions.assertFalse(list.isSorted()); } @@ -296,8 +296,8 @@ public class LongListTest { final long[] actualLongs = list.get(from, length); for (int i = 0; i < length; i++) { - Assert.assertEquals(actualLongs[i], list.get(from + i)); - Assert.assertEquals(actualLongs[i], longs[from + i]); + Assertions.assertEquals(actualLongs[i], list.get(from + i)); + Assertions.assertEquals(actualLongs[i], longs[from + i]); } } @@ -309,13 +309,13 @@ public class LongListTest { try { list.get(-1); - Assert.fail(); + Assertions.fail(); } catch (final IndexOutOfBoundsException e) { // expected } try { list.get(4); - Assert.fail(); + Assertions.fail(); } catch (final IndexOutOfBoundsException e) { // expected } @@ -329,25 +329,25 @@ public class LongListTest { try { list.get(-1, 1); - Assert.fail(); + Assertions.fail(); } catch (final IndexOutOfBoundsException e) { // expected } try { list.get(1, -1); - Assert.fail(); + Assertions.fail(); } catch (final IndexOutOfBoundsException e) { // expected } try { list.get(3, 2); - Assert.fail(); + Assertions.fail(); } catch (final IndexOutOfBoundsException e) { // expected } try { list.get(4, 1); - Assert.fail(); + Assertions.fail(); } catch (final IndexOutOfBoundsException e) { // expected } @@ -358,7 +358,7 @@ public class LongListTest { final LongList list = new LongList(); final long[] actual = list.toArray(); - Assert.assertArrayEquals(actual, new long[0]); + Assertions.assertArrayEquals(actual, new long[0]); } @Test @@ -370,16 +370,16 @@ public class LongListTest { final long[] input = new long[1]; final long[] actual = list.toArray(input); // input is too short -> new array returned - Assert.assertNotSame(input, actual); - Assert.assertArrayEquals(list.toArray(), actual); + Assertions.assertNotSame(input, actual); + Assertions.assertArrayEquals(list.toArray(), actual); } { final long[] input = new long[list.size()]; final long[] actual = list.toArray(input); // input fits exactly -> input returned - Assert.assertSame(input, actual); - Assert.assertArrayEquals(list.toArray(), actual); + Assertions.assertSame(input, actual); + Assertions.assertArrayEquals(list.toArray(), actual); } { @@ -387,8 +387,8 @@ public class LongListTest { final long[] expected = { 1, 2, 3, 4, 5, 6, 0 }; final long[] actual = list.toArray(input); // input too big -> input returned - Assert.assertSame(input, actual); - Assert.assertArrayEquals(expected, actual); + Assertions.assertSame(input, actual); + Assertions.assertArrayEquals(expected, actual); } } @@ -400,8 +400,8 @@ public class LongListTest { final long[] input = new long[0]; final long[] actual = list.toArray(input); // input fits exactly -> input returned - Assert.assertSame(input, actual); - Assert.assertArrayEquals(list.toArray(), actual); + Assertions.assertSame(input, actual); + Assertions.assertArrayEquals(list.toArray(), actual); } { @@ -409,8 +409,8 @@ public class LongListTest { final long[] expected = { 0 }; final long[] actual = list.toArray(input); // input too big -> input returned - Assert.assertSame(input, actual); - Assert.assertArrayEquals(expected, actual); + Assertions.assertSame(input, actual); + Assertions.assertArrayEquals(expected, actual); } } @@ -428,32 +428,32 @@ public class LongListTest { // remove nothing list.remove(2, 2); - Assert.assertArrayEquals(ints, list.toArray()); + Assertions.assertArrayEquals(ints, list.toArray()); // remove the last element list.remove(9, 10); final long[] expectedA = removeElements(ints, 9); - Assert.assertArrayEquals(expectedA, list.toArray()); + Assertions.assertArrayEquals(expectedA, list.toArray()); // remove the first element list.remove(0, 1); final long[] expectedB = removeElements(expectedA, 0); - Assert.assertArrayEquals(expectedB, list.toArray()); + Assertions.assertArrayEquals(expectedB, list.toArray()); // remove single element in the middle list.remove(3, 4); final long[] expectedC = removeElements(expectedB, 3); - Assert.assertArrayEquals(expectedC, list.toArray()); + Assertions.assertArrayEquals(expectedC, list.toArray()); // remove several elements in the middle list.remove(2, 5); final long[] expectedD = removeElements(expectedC, 2, 3, 4); - Assert.assertArrayEquals(expectedD, list.toArray()); + Assertions.assertArrayEquals(expectedD, list.toArray()); // remove all elements list.remove(0, 4); final long[] expectedE = removeElements(expectedD, 0, 1, 2, 3); - Assert.assertArrayEquals(expectedE, list.toArray()); + Assertions.assertArrayEquals(expectedE, list.toArray()); } @Test @@ -464,25 +464,25 @@ public class LongListTest { try { list.remove(-1, 1); - Assert.fail(); + Assertions.fail(); } catch (final IndexOutOfBoundsException e) { // expected } try { list.remove(1, 0); - Assert.fail(); + Assertions.fail(); } catch (final IndexOutOfBoundsException e) { // expected } try { list.remove(3, 5); - Assert.fail(); + Assertions.fail(); } catch (final IndexOutOfBoundsException e) { // expected } try { list.remove(4, 5); - Assert.fail(); + Assertions.fail(); } catch (final IndexOutOfBoundsException e) { // expected } @@ -495,7 +495,7 @@ public class LongListTest { list.addAll(0, 1, 2, 3); list.trim(); - Assert.assertEquals(4, list.getCapacity()); + Assertions.assertEquals(4, list.getCapacity()); } @Test @@ -503,7 +503,7 @@ public class LongListTest { final LongList list = new LongList(); list.trim(); - Assert.assertEquals(0, list.getCapacity()); + Assertions.assertEquals(0, list.getCapacity()); } @Test @@ -511,9 +511,9 @@ public class LongListTest { final LongList list = LongList.of(2, 0, 1); // unsorted list list.clear(); - Assert.assertEquals(0, list.size()); - Assert.assertEquals(0, list.getCapacity()); - Assert.assertTrue(list.isSorted()); + Assertions.assertEquals(0, list.size()); + Assertions.assertEquals(0, list.getCapacity()); + Assertions.assertTrue(list.isSorted()); } @SuppressWarnings("unlikely-arg-type") @@ -523,46 +523,46 @@ public class LongListTest { final LongList b = new LongList(); // on empty lists - Assert.assertTrue(a.equals(b)); - Assert.assertEquals(a.hashCode(), b.hashCode()); + Assertions.assertTrue(a.equals(b)); + Assertions.assertEquals(a.hashCode(), b.hashCode()); // on equal lists a.addAll(1, 2, 3, 4); b.addAll(1, 2, 3, 4); - Assert.assertTrue(a.equals(b)); - Assert.assertEquals(a.hashCode(), b.hashCode()); + Assertions.assertTrue(a.equals(b)); + Assertions.assertEquals(a.hashCode(), b.hashCode()); // trim only one of them // we want to compare the actual content a.trim(); - Assert.assertTrue(a.equals(b)); - Assert.assertEquals(a.hashCode(), b.hashCode()); + Assertions.assertTrue(a.equals(b)); + Assertions.assertEquals(a.hashCode(), b.hashCode()); // change one value a.remove(2, 3); a.insert(2, 99); - Assert.assertFalse(a.equals(b)); - Assert.assertNotEquals(a.hashCode(), b.hashCode()); + Assertions.assertFalse(a.equals(b)); + Assertions.assertNotEquals(a.hashCode(), b.hashCode()); // have different length a.add(66); - Assert.assertFalse(a.equals(b)); - Assert.assertNotEquals(a.hashCode(), b.hashCode()); + Assertions.assertFalse(a.equals(b)); + Assertions.assertNotEquals(a.hashCode(), b.hashCode()); // same object - Assert.assertTrue(a.equals(a)); + Assertions.assertTrue(a.equals(a)); // other is null - Assert.assertFalse(a.equals(null)); + Assertions.assertFalse(a.equals(null)); // equals with a different class - Assert.assertFalse(a.equals("not an LongList")); + Assertions.assertFalse(a.equals("not an LongList")); // sorted and unsorted lists with same length final LongList sorted = LongList.of(1, 2, 3, 4); final LongList unsorted = LongList.of(4, 3, 2, 1); - Assert.assertFalse(sorted.equals(unsorted)); - Assert.assertNotEquals(sorted.hashCode(), unsorted.hashCode()); + Assertions.assertFalse(sorted.equals(unsorted)); + Assertions.assertNotEquals(sorted.hashCode(), unsorted.hashCode()); } @Test @@ -573,7 +573,7 @@ public class LongListTest { list.sort(); final long[] expected = new long[] { 1, 2, 3, 4 }; - Assert.assertArrayEquals(expected, list.toArray()); + Assertions.assertArrayEquals(expected, list.toArray()); } @Test @@ -584,7 +584,7 @@ public class LongListTest { list.parallelSort(); final long[] expected = new long[] { 1, 2, 3, 4 }; - Assert.assertArrayEquals(expected, list.toArray()); + Assertions.assertArrayEquals(expected, list.toArray()); } @Test @@ -596,13 +596,13 @@ public class LongListTest { final Random random = new Random(1); list.shuffle(random); - Assert.assertEquals(original.size(), list.size()); + Assertions.assertEquals(original.size(), list.size()); original.removeAll(list); - Assert.assertTrue("original minus shuffled list: " + original, original.isEmpty()); + Assertions.assertTrue(original.isEmpty(), "original minus shuffled list: " + original); list.removeAll(original2); - Assert.assertTrue("shuffled list minus original: " + list, list.isEmpty()); + Assertions.assertTrue(list.isEmpty(), "shuffled list minus original: " + list); } @Test @@ -610,7 +610,7 @@ public class LongListTest { final LongList list = LongList.of(); list.shuffle(); - Assert.assertTrue("an empty list is sorted", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "an empty list is sorted"); } @Test @@ -618,7 +618,7 @@ public class LongListTest { final LongList list = LongList.of(1); list.shuffle(); - Assert.assertTrue("a shuffled list of size 1 is sorted", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "a shuffled list of size 1 is sorted"); } @Test @@ -626,7 +626,7 @@ public class LongListTest { final LongList list = LongList.of(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1); list.shuffle(); - Assert.assertTrue("a shuffled list with identical elements is sorted", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "a shuffled list with identical elements is sorted"); } @Test @@ -642,11 +642,11 @@ public class LongListTest { sorted += LongList.of(1, 2, 3).equals(list) ? 1 : 0; unsorted += LongList.of(1, 2, 3).equals(list) ? 0 : 1; - Assert.assertEquals(LongList.of(1, 2, 3).equals(list), list.isSorted()); + Assertions.assertEquals(LongList.of(1, 2, 3).equals(list), list.isSorted()); } - Assert.assertTrue(sorted > 0); - Assert.assertTrue(unsorted > 0); + Assertions.assertTrue(sorted > 0); + Assertions.assertTrue(unsorted > 0); } private long[] removeElements(final long[] data, final int... removedIndices) { @@ -692,12 +692,11 @@ public class LongListTest { ObjectInputStream in = new ObjectInputStream(byteInputStream)) { final LongList actual = (LongList) in.readObject(); - Assert.assertEquals(list, actual); + Assertions.assertEquals(list, actual); - Assert.assertEquals( + Assertions.assertEquals(list.size(), actual.getCapacity(), "The capacity of the deserialized list. Should be equal to the number of inserted " - + "values, because we don't want to serialize the unused part of the array", - list.size(), actual.getCapacity()); + + "values, because we don't want to serialize the unused part of the array"); } } @@ -708,10 +707,10 @@ public class LongListTest { final LongList clone = list.clone(); - Assert.assertEquals(list, clone); + Assertions.assertEquals(list, clone); list.set(1, 0); - Assert.assertNotEquals(list, clone); + Assertions.assertNotEquals(list, clone); } @Test @@ -719,7 +718,7 @@ public class LongListTest { final LongList list = new LongList(); final LongList clone = list.clone(); - Assert.assertEquals(list, clone); + Assertions.assertEquals(list, clone); } @Test @@ -727,7 +726,7 @@ public class LongListTest { final LongList list = LongList.of(3, 2, 1); final LongList clone = list.clone(); - Assert.assertEquals(list.isSorted(), clone.isSorted()); + Assertions.assertEquals(list.isSorted(), clone.isSorted()); } @Test @@ -735,17 +734,17 @@ public class LongListTest { final LongList list = LongList.of(1, 2, 3); final LongList clone = list.clone(); - Assert.assertEquals(list.isSorted(), clone.isSorted()); + Assertions.assertEquals(list.isSorted(), clone.isSorted()); } @Test public void testToString() { - Assert.assertEquals("[]", new LongList().toString()); + Assertions.assertEquals("[]", new LongList().toString()); final LongList list = new LongList(); list.addAll(-2, -1, 0, 1, 2); - Assert.assertEquals("[-2, -1, 0, 1, 2]", list.toString()); - Assert.assertEquals("same result as Arrays.toString()", Arrays.toString(list.toArray()), list.toString()); + Assertions.assertEquals("[-2, -1, 0, 1, 2]", list.toString()); + Assertions.assertEquals("same result as Arrays.toString()", Arrays.toString(list.toArray()), list.toString()); } @Test @@ -755,17 +754,17 @@ public class LongListTest { final LongList list = new LongList(); list.addAll(0, 1, 2, 3, 4, 5, 6); final LongStream stream = list.stream(); - Assert.assertEquals(list.size(), stream.count()); + Assertions.assertEquals(list.size(), stream.count()); } { final LongList list = new LongList(); list.addAll(0, 1, 2, 3, 4, 5); final LongStream stream = list.stream(); - Assert.assertEquals(15, stream.sum()); + Assertions.assertEquals(15, stream.sum()); } { final LongList emptyList = new LongList(); - Assert.assertEquals(0, emptyList.stream().count()); + Assertions.assertEquals(0, emptyList.stream().count()); } } @@ -787,122 +786,122 @@ public class LongListTest { .boxed()// .collect(Collectors.toList()); - Assert.assertEquals("should be sequential, when using collect", actualList.toString(), list.toString()); - Assert.assertNotEquals("should use parallelism during computation", processingOrder.toString(), + Assertions.assertEquals("should be sequential, when using collect", actualList.toString(), list.toString()); + Assertions.assertNotEquals("should use parallelism during computation", processingOrder.toString(), list.toString()); } @Test public void testIndexOfOnSortedList() { final LongList list = new LongList(); - Assert.assertEquals(-1, list.indexOf(0)); + Assertions.assertEquals(-1, list.indexOf(0)); list.add(1); - Assert.assertEquals(-1, list.indexOf(0)); - Assert.assertEquals(0, list.indexOf(1)); + Assertions.assertEquals(-1, list.indexOf(0)); + Assertions.assertEquals(0, list.indexOf(1)); list.add(2); - Assert.assertEquals(-1, list.indexOf(0)); - Assert.assertEquals(0, list.indexOf(1)); - Assert.assertEquals(1, list.indexOf(2)); + Assertions.assertEquals(-1, list.indexOf(0)); + Assertions.assertEquals(0, list.indexOf(1)); + Assertions.assertEquals(1, list.indexOf(2)); } @Test public void testIndexOfOnSortedListReturnsFirstMatch() { final LongList list = LongList.of(0, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 4); - Assert.assertEquals(2, list.indexOf(2)); - Assert.assertEquals(4, list.indexOf(2, 4)); + Assertions.assertEquals(2, list.indexOf(2)); + Assertions.assertEquals(4, list.indexOf(2, 4)); } @Test public void testIndexOfOnUnsortedList() { final LongList list = LongList.of(2, 0, 1); - Assert.assertEquals(1, list.indexOf(0)); + Assertions.assertEquals(1, list.indexOf(0)); - Assert.assertEquals(0, list.indexOf(2)); - Assert.assertEquals(2, list.indexOf(1)); - Assert.assertEquals(-1, list.indexOf(3)); + Assertions.assertEquals(0, list.indexOf(2)); + Assertions.assertEquals(2, list.indexOf(1)); + Assertions.assertEquals(-1, list.indexOf(3)); } @Test public void testIndexOfWithOffsetOnSortedList() { final LongList list = new LongList(); list.addAll(1, 1, 2, 3, 3); - Assert.assertEquals(0, list.indexOf(1, 0)); - Assert.assertEquals(1, list.indexOf(1, 1)); - Assert.assertEquals(2, list.indexOf(2, 2)); - Assert.assertEquals(-1, list.indexOf(2, 3)); - Assert.assertEquals(3, list.indexOf(3, 2)); + Assertions.assertEquals(0, list.indexOf(1, 0)); + Assertions.assertEquals(1, list.indexOf(1, 1)); + Assertions.assertEquals(2, list.indexOf(2, 2)); + Assertions.assertEquals(-1, list.indexOf(2, 3)); + Assertions.assertEquals(3, list.indexOf(3, 2)); } @Test public void testIndexOfWithOffsetOnSortedListWithOffsetOutOfRange() { final LongList list = new LongList(); list.addAll(1); - Assert.assertEquals(0, list.indexOf(1, -1)); - Assert.assertEquals(-1, list.indexOf(1, list.size())); + Assertions.assertEquals(0, list.indexOf(1, -1)); + Assertions.assertEquals(-1, list.indexOf(1, list.size())); } @Test public void testIndexOfWithOffsetOnUnsortedList() { final LongList list = new LongList(); list.addAll(0, 2, 0, 2); - Assert.assertEquals(1, list.indexOf(2, 0)); - Assert.assertEquals(1, list.indexOf(2, 1)); - Assert.assertEquals(3, list.indexOf(2, 2)); - Assert.assertEquals(3, list.indexOf(2, 3)); - Assert.assertEquals(-1, list.indexOf(2, 4)); + Assertions.assertEquals(1, list.indexOf(2, 0)); + Assertions.assertEquals(1, list.indexOf(2, 1)); + Assertions.assertEquals(3, list.indexOf(2, 2)); + Assertions.assertEquals(3, list.indexOf(2, 3)); + Assertions.assertEquals(-1, list.indexOf(2, 4)); // indexed returned by indexOf() are consistent with get() - Assert.assertEquals(list.get(list.indexOf(2, 0)), 2); - Assert.assertEquals(list.get(list.indexOf(2, 1)), 2); - Assert.assertEquals(list.get(list.indexOf(2, 2)), 2); - Assert.assertEquals(list.get(list.indexOf(2, 3)), 2); + Assertions.assertEquals(list.get(list.indexOf(2, 0)), 2); + Assertions.assertEquals(list.get(list.indexOf(2, 1)), 2); + Assertions.assertEquals(list.get(list.indexOf(2, 2)), 2); + Assertions.assertEquals(list.get(list.indexOf(2, 3)), 2); } @Test public void testLastIndexOfWithOffsetOnEmptyList() { final LongList list = LongList.of(); - Assert.assertEquals(-1, list.lastIndexOf(3, list.size())); + Assertions.assertEquals(-1, list.lastIndexOf(3, list.size())); } @Test public void testLastIndexOfWithOffsetOnSortedList() { final LongList list = LongList.of(1, 2, 2, 3, 4, 5, 6, 7, 8, 9); - Assert.assertEquals(3, list.lastIndexOf(3, list.size())); - Assert.assertEquals(2, list.lastIndexOf(2, list.size())); - Assert.assertEquals(0, list.lastIndexOf(1, list.size())); + Assertions.assertEquals(3, list.lastIndexOf(3, list.size())); + Assertions.assertEquals(2, list.lastIndexOf(2, list.size())); + Assertions.assertEquals(0, list.lastIndexOf(1, list.size())); - Assert.assertEquals(2, list.lastIndexOf(2, 2)); // fromIndex == result - Assert.assertEquals(1, list.lastIndexOf(2, 1)); // fromIndex == result && the next element would be a hit + Assertions.assertEquals(2, list.lastIndexOf(2, 2)); // fromIndex == result + Assertions.assertEquals(1, list.lastIndexOf(2, 1)); // fromIndex == result && the next element would be a hit - Assert.assertEquals(0, list.lastIndexOf(1, 0)); // fromIndex 0; found - Assert.assertEquals(-1, list.lastIndexOf(99, 0)); // fromIndex 0; not found - Assert.assertEquals(-1, list.lastIndexOf(99, list.size())); // fromIndex larger than list && not found + Assertions.assertEquals(0, list.lastIndexOf(1, 0)); // fromIndex 0; found + Assertions.assertEquals(-1, list.lastIndexOf(99, 0)); // fromIndex 0; not found + Assertions.assertEquals(-1, list.lastIndexOf(99, list.size())); // fromIndex larger than list && not found } @Test public void testLastIndexOfOnSortedListReturnsFirstMatch() { final LongList list = LongList.of(0, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 4); - Assert.assertEquals(13, list.lastIndexOf(2)); - Assert.assertEquals(10, list.lastIndexOf(2, 10)); + Assertions.assertEquals(13, list.lastIndexOf(2)); + Assertions.assertEquals(10, list.lastIndexOf(2, 10)); } @Test public void testLastIndexOfWithOffsetOnUnsortedList() { final LongList list = LongList.of(1, 2, 3, 1, 2, 3); - Assert.assertEquals(5, list.lastIndexOf(3, list.size())); - Assert.assertEquals(4, list.lastIndexOf(2, list.size())); - Assert.assertEquals(3, list.lastIndexOf(1, list.size())); - Assert.assertEquals(-1, list.lastIndexOf(99, list.size())); - Assert.assertEquals(-1, list.lastIndexOf(99, 0)); + Assertions.assertEquals(5, list.lastIndexOf(3, list.size())); + Assertions.assertEquals(4, list.lastIndexOf(2, list.size())); + Assertions.assertEquals(3, list.lastIndexOf(1, list.size())); + Assertions.assertEquals(-1, list.lastIndexOf(99, list.size())); + Assertions.assertEquals(-1, list.lastIndexOf(99, 0)); - Assert.assertEquals(2, list.lastIndexOf(3, list.size() - 2)); - Assert.assertEquals(4, list.lastIndexOf(2, list.size() - 1)); - Assert.assertEquals(1, list.lastIndexOf(2, list.lastIndexOf(2) - 1)); + Assertions.assertEquals(2, list.lastIndexOf(3, list.size() - 2)); + Assertions.assertEquals(4, list.lastIndexOf(2, list.size() - 1)); + Assertions.assertEquals(1, list.lastIndexOf(2, list.lastIndexOf(2) - 1)); } @Test @@ -911,7 +910,7 @@ public class LongListTest { list.addAll(1, 2, 3); list.replaceAll(i -> i * 2); - Assert.assertArrayEquals(new long[] { 2, 4, 6 }, list.toArray()); + Assertions.assertArrayEquals(new long[] { 2, 4, 6 }, list.toArray()); } @Test @@ -919,7 +918,7 @@ public class LongListTest { final LongList list = new LongList(); list.replaceAll(i -> i * 3); - Assert.assertArrayEquals(new long[0], list.toArray()); + Assertions.assertArrayEquals(new long[0], list.toArray()); } @Test @@ -928,8 +927,8 @@ public class LongListTest { final LongList remove = LongList.of(-1, 2, 4, 5); list.removeAll(remove); - Assert.assertArrayEquals(new long[] { -2, 0, 1, 3, 6 }, list.toArray()); - Assert.assertArrayEquals(new long[] { -1, 2, 4, 5 }, remove.toArray()); + Assertions.assertArrayEquals(new long[] { -2, 0, 1, 3, 6 }, list.toArray()); + Assertions.assertArrayEquals(new long[] { -1, 2, 4, 5 }, remove.toArray()); } @Test @@ -938,8 +937,8 @@ public class LongListTest { final LongList remove = new LongList(); list.removeAll(remove); - Assert.assertArrayEquals(new long[] { 1, 2, 3, 4, 5, 6 }, list.toArray()); - Assert.assertArrayEquals(new long[] {}, remove.toArray()); + Assertions.assertArrayEquals(new long[] { 1, 2, 3, 4, 5, 6 }, list.toArray()); + Assertions.assertArrayEquals(new long[] {}, remove.toArray()); } @Test @@ -948,8 +947,8 @@ public class LongListTest { final LongList remove = LongList.of(1); list.removeAll(remove); - Assert.assertArrayEquals(new long[] {}, list.toArray()); - Assert.assertEquals(0, list.size()); + Assertions.assertArrayEquals(new long[] {}, list.toArray()); + Assertions.assertEquals(0, list.size()); } @Test @@ -958,8 +957,8 @@ public class LongListTest { final LongList retain = LongList.of(-1, 2, 4, 5, 99); list.retainAll(retain); - Assert.assertArrayEquals(new long[] { -1, 2, 4, 5 }, list.toArray()); - Assert.assertArrayEquals(new long[] { -1, 2, 4, 5, 99 }, retain.toArray()); + Assertions.assertArrayEquals(new long[] { -1, 2, 4, 5 }, list.toArray()); + Assertions.assertArrayEquals(new long[] { -1, 2, 4, 5, 99 }, retain.toArray()); } @Test @@ -968,8 +967,8 @@ public class LongListTest { final LongList retain = LongList.of(-1, 2, 4, 5, 99); list.retainAll(retain); - Assert.assertArrayEquals(new long[] {}, list.toArray()); - Assert.assertArrayEquals(new long[] { -1, 2, 4, 5, 99 }, retain.toArray()); + Assertions.assertArrayEquals(new long[] {}, list.toArray()); + Assertions.assertArrayEquals(new long[] { -1, 2, 4, 5, 99 }, retain.toArray()); } @Test @@ -978,8 +977,8 @@ public class LongListTest { final LongList retain = LongList.of(); list.retainAll(retain); - Assert.assertArrayEquals(new long[] {}, list.toArray()); - Assert.assertArrayEquals(new long[] {}, retain.toArray()); + Assertions.assertArrayEquals(new long[] {}, list.toArray()); + Assertions.assertArrayEquals(new long[] {}, retain.toArray()); } @Test @@ -987,7 +986,7 @@ public class LongListTest { final LongList list = LongList.of(1, 2, 3, 4, 5, 6); list.removeIf((value, index) -> value % 2 == 0); - Assert.assertArrayEquals(new long[] { 1, 3, 5 }, list.toArray()); + Assertions.assertArrayEquals(new long[] { 1, 3, 5 }, list.toArray()); } @Test @@ -996,7 +995,7 @@ public class LongListTest { final LongPredicate predicate = (value, index) -> value % 2 == 0; list.removeIf(predicate.negate()); - Assert.assertArrayEquals(new long[] { 2, 4, 6 }, list.toArray()); + Assertions.assertArrayEquals(new long[] { 2, 4, 6 }, list.toArray()); } @Test @@ -1006,7 +1005,7 @@ public class LongListTest { final LongPredicate predicateA = (value, index) -> value % 2 == 0; final LongPredicate predicateB = (value, index) -> value == 3 || value == 4; list.removeIf(predicateA.and(predicateB)); - Assert.assertArrayEquals(new long[] { 1, 2, 3, 5, 6 }, list.toArray()); + Assertions.assertArrayEquals(new long[] { 1, 2, 3, 5, 6 }, list.toArray()); } @Test @@ -1016,7 +1015,7 @@ public class LongListTest { final LongPredicate predicateA = (value, index) -> value % 2 == 0; final LongPredicate predicateB = (value, index) -> value == 3 || value == 4; list.removeIf(predicateA.or(predicateB)); - Assert.assertArrayEquals(new long[] { 1, 5 }, list.toArray()); + Assertions.assertArrayEquals(new long[] { 1, 5 }, list.toArray()); } @Test @@ -1024,29 +1023,29 @@ public class LongListTest { final LongList list = LongList.of(); list.removeIf((value, index) -> false); - Assert.assertArrayEquals(new long[] {}, list.toArray()); + Assertions.assertArrayEquals(new long[] {}, list.toArray()); } @Test public void testSortedFlagSort() { - Assert.assertTrue("empty list is sorted", new LongList().isSorted()); + Assertions.assertTrue(new LongList().isSorted(), "empty list is sorted"); final LongList list = new LongList(); list.addAll(2, 0, 1); list.sort(); - Assert.assertTrue("is sorted after calling sort", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "is sorted after calling sort"); } @Test public void testSortedFlagEmptyList() { - Assert.assertTrue("empty list is sorted", new LongList().isSorted()); + Assertions.assertTrue(new LongList().isSorted(), "empty list is sorted"); final LongList list = new LongList(); list.addAll(2, 0, 1); list.remove(0, list.size()); - Assert.assertTrue("unsorted list initialized by addAll", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "unsorted list initialized by addAll"); } @Test @@ -1054,15 +1053,15 @@ public class LongListTest { final LongList list = new LongList(); list.add(1); - Assert.assertTrue("[1]", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "[1]"); list.add(2); - Assert.assertTrue("[1,2]", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "[1,2]"); list.add(2); - Assert.assertTrue("[1,2,2]", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "[1,2,2]"); list.add(1); - Assert.assertFalse("[1,2,2,1]", list.isSorted()); + Assertions.assertFalse(list.isSorted(), "[1,2,2,1]"); list.add(1); - Assert.assertFalse("[1,2,2,1,1]", list.isSorted()); + Assertions.assertFalse(list.isSorted(), "[1,2,2,1,1]"); } @Test @@ -1071,19 +1070,19 @@ public class LongListTest { { final LongList list = new LongList(); list.addAll(2, 0); - Assert.assertFalse("unsorted list initialized by addAll", list.isSorted()); + Assertions.assertFalse(list.isSorted(), "unsorted list initialized by addAll"); } { final LongList list = new LongList(); list.addAll(1); - Assert.assertTrue("list with one element is sorted", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "list with one element is sorted"); } { final LongList list = new LongList(); list.addAll(1, 1); - Assert.assertTrue("list with all the same elements is sorted", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "list with all the same elements is sorted"); } } @@ -1096,35 +1095,35 @@ public class LongListTest { { final LongList list = new LongList(); list.insert(0, 1, 2, 3); - Assert.assertTrue("insert sorted values into empty list", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "insert sorted values into empty list"); } { final LongList list = LongList.of(1, 1); list.insert(0, 2, 2); // -> [2,2,1,1] - Assert.assertFalse("insert before: unsorted", list.isSorted()); + Assertions.assertFalse(list.isSorted(), "insert before: unsorted"); } { final LongList list = LongList.of(3, 3); list.insert(0, 2, 2); // -> [2,2,3,3] - Assert.assertTrue("insert sorted values before: sorted", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "insert sorted values before: sorted"); } { final LongList list = LongList.of(4, 4); list.insert(2, 2, 2); // -> [4,4,2,2] - Assert.assertFalse("insert sorted values at end: unsorted", list.isSorted()); + Assertions.assertFalse(list.isSorted(), "insert sorted values at end: unsorted"); } { final LongList list = LongList.of(1, 1); list.insert(2, 2, 2); // -> [1,1,2,2] - Assert.assertTrue("insert sorted values at end: sorted", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "insert sorted values at end: sorted"); } { final LongList list = LongList.of(1, 4); list.insert(1, 2, 2); // -> [1,2,2,4] - Assert.assertTrue("insert sorted values in middle: sorted", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "insert sorted values in middle: sorted"); } /* @@ -1133,39 +1132,39 @@ public class LongListTest { { final LongList list = LongList.of(1, 4); list.insert(1, 5); // -> [1,5,4] - Assert.assertFalse("insert sorted values in middle: unsorted", list.isSorted()); + Assertions.assertFalse(list.isSorted(), "insert sorted values in middle: unsorted"); } { final LongList list = LongList.of(1, 4); list.insert(1, 6, 6); // -> [1,6,6,4] - Assert.assertFalse("insert sorted values in middle: unsorted", list.isSorted()); + Assertions.assertFalse(list.isSorted(), "insert sorted values in middle: unsorted"); } { final LongList list = LongList.of(1, 4); list.insert(1, 0); // -> [1,0,4] - Assert.assertFalse("insert sorted values in middle: unsorted", list.isSorted()); + Assertions.assertFalse(list.isSorted(), "insert sorted values in middle: unsorted"); } { final LongList list = LongList.of(1, 4); list.insert(1, 0, 0); // -> [1,0,0,4] - Assert.assertFalse("insert sorted values in middle: unsorted", list.isSorted()); + Assertions.assertFalse(list.isSorted(), "insert sorted values in middle: unsorted"); } { final LongList list = LongList.of(3, 4); list.insert(0, 2, 1); // -> [2,1,3,4] - Assert.assertFalse("insert unsorted at begin: unsorted", list.isSorted()); + Assertions.assertFalse(list.isSorted(), "insert unsorted at begin: unsorted"); } { final LongList list = LongList.of(1, 4); list.insert(1, 2, 1); // -> [1,2,1,4] - Assert.assertFalse("insert unsorted middle: unsorted", list.isSorted()); + Assertions.assertFalse(list.isSorted(), "insert unsorted middle: unsorted"); } { final LongList list = LongList.of(3, 4); list.insert(2, 6, 5); // -> [13,4,6,5] - Assert.assertFalse("insert unsorted at end: unsorted", list.isSorted()); + Assertions.assertFalse(list.isSorted(), "insert unsorted at end: unsorted"); } } @@ -1176,40 +1175,40 @@ public class LongListTest { { final LongList list = LongList.of(0, 1, 2); list.set(0, -1); - Assert.assertTrue("set first element: [-1,1,2] sorted", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "set first element: [-1,1,2] sorted"); list.set(0, 1); - Assert.assertTrue("set first element: [1,1,2] sorted", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "set first element: [1,1,2] sorted"); list.set(0, 2); - Assert.assertFalse("set first element: [2,1,2] not sorted", list.isSorted()); + Assertions.assertFalse(list.isSorted(), "set first element: [2,1,2] not sorted"); } { final LongList sortedList = LongList.of(0, 2, 4); sortedList.set(1, 3); - Assert.assertTrue("set middle element: [0,3,4] sorteed", sortedList.isSorted()); + Assertions.assertTrue(sortedList.isSorted(), "set middle element: [0,3,4] sorteed"); sortedList.set(1, 4); - Assert.assertTrue("set middle element: [0,4,4] sorteed", sortedList.isSorted()); + Assertions.assertTrue(sortedList.isSorted(), "set middle element: [0,4,4] sorteed"); sortedList.set(1, 0); - Assert.assertTrue("set middle element: [0,0,4] sorteed", sortedList.isSorted()); + Assertions.assertTrue(sortedList.isSorted(), "set middle element: [0,0,4] sorteed"); sortedList.set(1, 5); - Assert.assertFalse("set middle element: [0,5,4] not sorteed", sortedList.isSorted()); + Assertions.assertFalse(sortedList.isSorted(), "set middle element: [0,5,4] not sorteed"); } { final LongList sortedList = LongList.of(0, 1, 2); sortedList.set(2, 3); - Assert.assertTrue("set last element: [0,1,3] sorteed", sortedList.isSorted()); + Assertions.assertTrue(sortedList.isSorted(), "set last element: [0,1,3] sorteed"); sortedList.set(2, 1); - Assert.assertTrue("set last element: [0,1,1] sorteed", sortedList.isSorted()); + Assertions.assertTrue(sortedList.isSorted(), "set last element: [0,1,1] sorteed"); sortedList.set(2, 0); - Assert.assertFalse("set last element: [0,1,0] not sorteed", sortedList.isSorted()); + Assertions.assertFalse(sortedList.isSorted(), "set last element: [0,1,0] not sorteed"); } { final LongList sortedList = LongList.of(0, 1, 2); sortedList.set(2, 0); sortedList.set(2, 2); - Assert.assertFalse("unsorted lists stay unsorted", sortedList.isSorted()); + Assertions.assertFalse(sortedList.isSorted(), "unsorted lists stay unsorted"); } } @@ -1218,14 +1217,14 @@ public class LongListTest { final LongList list = LongList.of(4, 3, 2, 1); list.remove(0, 2); // removes 4,3 - Assert.assertFalse("unsorted list with two elements is not sorted", list.isSorted()); + Assertions.assertFalse(list.isSorted(), "unsorted list with two elements is not sorted"); list.remove(0, 1); - Assert.assertTrue("unsorted list with one element becomes sorted", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "unsorted list with one element becomes sorted"); list.add(-1); // make list unsorted again list.remove(0, 2); // remove both elements - Assert.assertTrue("unsorted list with no elements becomes sorted", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "unsorted list with no elements becomes sorted"); } @Test @@ -1233,7 +1232,7 @@ public class LongListTest { final LongList list = LongList.of(4, 3, 2, 1); list.remove(0, 4); // removes all - Assert.assertTrue("empty list is sorted", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "empty list is sorted"); } @Test @@ -1241,7 +1240,7 @@ public class LongListTest { final LongList list = LongList.of(4, 3, 2, 1); list.remove(1, 4); // removes 3,2,1 - Assert.assertTrue("list with one element is", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "list with one element is"); } @Test @@ -1249,7 +1248,7 @@ public class LongListTest { final LongList list = LongList.of(1, 2, 777, 4, 5); list.remove(2, 3); // removes 777 - Assert.assertTrue("list is sorted after remove", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "list is sorted after remove"); } @Test @@ -1257,14 +1256,14 @@ public class LongListTest { final LongList list = LongList.of(4, 3, 2, 1); list.removeAll(LongList.of(4, 3)); - Assert.assertFalse("unsorted list with two elements is not sorted", list.isSorted()); + Assertions.assertFalse(list.isSorted(), "unsorted list with two elements is not sorted"); list.removeAll(LongList.of(2)); - Assert.assertTrue("unsorted list with one element becomes sorted", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "unsorted list with one element becomes sorted"); list.add(-1); // make list unsorted again list.removeAll(LongList.of(-1, 2)); // remove both elements - Assert.assertTrue("unsorted list with no elements becomes sorted", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "unsorted list with no elements becomes sorted"); } @Test @@ -1272,14 +1271,14 @@ public class LongListTest { final LongList list = LongList.of(4, 3, 2, 1); list.removeIf((value, index) -> value >= 3); // removes 3 and 4 - Assert.assertFalse("unsorted list with two elements is not sorted", list.isSorted()); + Assertions.assertFalse(list.isSorted(), "unsorted list with two elements is not sorted"); list.removeIf((value, index) -> value >= 2); // removes 2 - Assert.assertTrue("unsorted list with one element becomes sorted", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "unsorted list with one element becomes sorted"); list.add(-1); // make list unsorted again list.removeIf((value, index) -> true); // remove both elements - Assert.assertTrue("unsorted list with no elements becomes sorted", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "unsorted list with no elements becomes sorted"); } @Test @@ -1287,8 +1286,8 @@ public class LongListTest { final LongList list = LongList.of(1, 3, 2); list.removeIf((value, index) -> true); // makes the list sorted - Assert.assertTrue("list is empty", list.isEmpty()); - Assert.assertTrue("empty list is sorted", list.isSorted()); + Assertions.assertTrue(list.isEmpty(), "list is empty"); + Assertions.assertTrue(list.isSorted(), "empty list is sorted"); } @Test @@ -1296,7 +1295,7 @@ public class LongListTest { final LongList list = LongList.of(1, 3, 2); list.removeIf((value, index) -> value > 1); // makes the list sorted - Assert.assertTrue("list with one element is sorted", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "list with one element is sorted"); } @Test @@ -1304,7 +1303,7 @@ public class LongListTest { final LongList list = LongList.of(1, 2, 3, 777, 4, 5); list.removeIf((value, index) -> value == 777); // makes the list sorted - Assert.assertTrue("unsorted list becomes sorted", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "unsorted list becomes sorted"); } @Test @@ -1312,13 +1311,13 @@ public class LongListTest { final LongList list = LongList.of(1, 2, 3, 4); list.replaceAll(v -> v >= 3 ? 2 : v); // replace 3 and 4 with 2 -> [1,2,2,2] - Assert.assertTrue("sorted list still sorted after replace", list.isSorted()); + Assertions.assertTrue(list.isSorted(), "sorted list still sorted after replace"); list.replaceAll(v -> v == 1 ? 3 : v); // replace 1 with 3 -> [3,2,2,2] - Assert.assertFalse("sorted list becomes unsorted after replace", list.isSorted()); + Assertions.assertFalse(list.isSorted(), "sorted list becomes unsorted after replace"); list.replaceAll(v -> 2); // replace all with 2 -> [2,2,2,2] - Assert.assertFalse("unsorted list stays unsorted", list.isSorted()); + Assertions.assertFalse(list.isSorted(), "unsorted list stays unsorted"); } @Test @@ -1327,14 +1326,14 @@ public class LongListTest { final LongList a = LongList.of(0, 1, 2, 3, 4); final LongList b = LongList.of(2, 4, 5); final LongList actual = LongList.intersection(a, b); - Assert.assertEquals(LongList.of(2, 4), actual); + Assertions.assertEquals(LongList.of(2, 4), actual); } { final LongList a = LongList.of(0, 2, 4, 6); final LongList b = LongList.of(3, 5); final LongList actual = LongList.intersection(a, b); - Assert.assertEquals(LongList.of(), actual); + Assertions.assertEquals(LongList.of(), actual); } /* @@ -1344,13 +1343,13 @@ public class LongListTest { final LongList a = LongList.of(3, 3, 3); final LongList b = LongList.of(3, 3); final LongList actual = LongList.intersection(a, b); - Assert.assertEquals(LongList.of(3), actual); + Assertions.assertEquals(LongList.of(3), actual); } { final LongList a = LongList.of(4, 4); final LongList b = LongList.of(4, 4, 4); final LongList actual = LongList.intersection(a, b); - Assert.assertEquals(LongList.of(4), actual); + Assertions.assertEquals(LongList.of(4), actual); } } @@ -1363,7 +1362,7 @@ public class LongListTest { b.shuffle(); final LongList actual = LongList.intersection(a, b); actual.sort(); - Assert.assertEquals(LongList.of(2, 4), actual); + Assertions.assertEquals(LongList.of(2, 4), actual); } /* @@ -1373,13 +1372,13 @@ public class LongListTest { final LongList a = LongList.of(3, 5, 3, 3, 1); final LongList b = LongList.of(2, 3, 3); final LongList actual = LongList.intersection(a, b); - Assert.assertEquals(LongList.of(3), actual); + Assertions.assertEquals(LongList.of(3), actual); } { final LongList a = LongList.of(1, 4); final LongList b = LongList.of(4, 3, 4, 4, 2); final LongList actual = LongList.intersection(a, b); - Assert.assertEquals(LongList.of(4), actual); + Assertions.assertEquals(LongList.of(4), actual); } } @@ -1388,8 +1387,8 @@ public class LongListTest { final LongList a = LongList.of(); final LongList b = LongList.of(); - Assert.assertEquals(LongList.of(), LongList.union(a, b)); - Assert.assertEquals(LongList.union(a, b), LongList.union(b, a)); + Assertions.assertEquals(LongList.of(), LongList.union(a, b)); + Assertions.assertEquals(LongList.union(a, b), LongList.union(b, a)); } @Test @@ -1398,8 +1397,8 @@ public class LongListTest { final LongList b = LongList.of(2, 4, 5); final LongList actual = LongList.union(a, b); - Assert.assertEquals(LongList.of(0, 1, 2, 3, 4, 5), actual); - Assert.assertEquals(LongList.union(a, b), LongList.union(b, a)); + Assertions.assertEquals(LongList.of(0, 1, 2, 3, 4, 5), actual); + Assertions.assertEquals(LongList.union(a, b), LongList.union(b, a)); } @Test @@ -1408,8 +1407,8 @@ public class LongListTest { final LongList b = LongList.of(1, 3); final LongList actual = LongList.union(a, b); - Assert.assertEquals(LongList.of(1, 2, 3), actual); - Assert.assertEquals(LongList.union(a, b), LongList.union(b, a)); + Assertions.assertEquals(LongList.of(1, 2, 3), actual); + Assertions.assertEquals(LongList.union(a, b), LongList.union(b, a)); } @Test @@ -1418,8 +1417,8 @@ public class LongListTest { final LongList b = LongList.of(1, 2, 2, 4); final LongList actual = LongList.union(a, b); - Assert.assertEquals(LongList.of(1, 2, 3, 4), actual); - Assert.assertEquals(LongList.union(a, b), LongList.union(b, a)); + Assertions.assertEquals(LongList.of(1, 2, 3, 4), actual); + Assertions.assertEquals(LongList.union(a, b), LongList.union(b, a)); } @Test @@ -1428,8 +1427,8 @@ public class LongListTest { final LongList b = LongList.of(2, 2); final LongList actual = LongList.union(a, b); - Assert.assertEquals(LongList.of(2), actual); - Assert.assertEquals(LongList.union(a, b), LongList.union(b, a)); + Assertions.assertEquals(LongList.of(2), actual); + Assertions.assertEquals(LongList.union(a, b), LongList.union(b, a)); } @Test @@ -1438,8 +1437,8 @@ public class LongListTest { final LongList b = LongList.of(2, 5, 4); final LongList actual = LongList.union(a, b); - Assert.assertEquals(LongList.of(0, 1, 2, 3, 4, 5), actual); - Assert.assertEquals(LongList.union(a, b), LongList.union(b, a)); + Assertions.assertEquals(LongList.of(0, 1, 2, 3, 4, 5), actual); + Assertions.assertEquals(LongList.union(a, b), LongList.union(b, a)); } @Test @@ -1448,7 +1447,7 @@ public class LongListTest { final LongList b = LongList.of(2, 5, 4); final LongList actual = LongList.union(a, b); - Assert.assertEquals(LongList.of(1, 2, 3, 4, 5), actual); - Assert.assertEquals(LongList.union(a, b), LongList.union(b, a)); + Assertions.assertEquals(LongList.of(1, 2, 3, 4, 5), actual); + Assertions.assertEquals(LongList.union(a, b), LongList.union(b, a)); } }