Backups/TwelveMonkeys
2
0
Fork 0
mirror of https://github.com/haraldk/TwelveMonkeys.git synced 2026-03-20 00:00:03 -04:00
Code Issues Projects Releases Wiki Activity

Upgrade to Junit5 (#1050)

Browse Source 
* chore: Update to junit5 for servlet package

* chore: Update to junit5 for contrib package

* chore: Update to junit5 for common-image package

* chore: Update to junit5 for common-lang package

* chore: Update to junit5 for entire project files

* fix: test case for JPEGImageReaderTest failed for java 8 and 11

assertEquals was using old signature of junit4.

* Update common/common-io/src/test/java/com/twelvemonkeys/io/InputStreamAbstractTest.java

Co-authored-by: Harald Kuhr <harald.kuhr@gmail.com>

* Update common/common-io/src/test/java/com/twelvemonkeys/io/InputStreamAbstractTest.java

Co-authored-by: Harald Kuhr <harald.kuhr@gmail.com>

* Update imageio/imageio-bmp/src/test/java/com/twelvemonkeys/imageio/plugins/bmp/BMPImageReaderTest.java

Co-authored-by: Harald Kuhr <harald.kuhr@gmail.com>

* Update imageio/imageio-jpeg/src/test/java/com/twelvemonkeys/imageio/plugins/jpeg/JPEGImageReaderTest.java

Co-authored-by: Harald Kuhr <harald.kuhr@gmail.com>

* Update imageio/imageio-tiff/src/test/java/com/twelvemonkeys/imageio/plugins/tiff/TIFFImageMetadataTest.java

Co-authored-by: Harald Kuhr <harald.kuhr@gmail.com>

* Update imageio/imageio-tiff/src/test/java/com/twelvemonkeys/imageio/plugins/tiff/TIFFImageReaderTest.java

Co-authored-by: Harald Kuhr <harald.kuhr@gmail.com>

* Update imageio/imageio-tiff/src/test/java/com/twelvemonkeys/imageio/plugins/tiff/TIFFImageWriterTest.java

Co-authored-by: Harald Kuhr <harald.kuhr@gmail.com>

* Update imageio/imageio-core/src/test/java/com/twelvemonkeys/imageio/stream/BufferedChannelImageInputStreamTest.java

Co-authored-by: Harald Kuhr <harald.kuhr@gmail.com>

* Update imageio/imageio-core/src/test/java/com/twelvemonkeys/imageio/stream/BufferedChannelImageInputStreamTest.java

Co-authored-by: Harald Kuhr <harald.kuhr@gmail.com>

* refactor: few indentation changes and missed test case

- review change related to missing test annotation
- unwanted new lines inside test case
- duplicate assertions

* refactor: moved the lambda expression to method reference

* review: testNotNullWithParameterNull catch block was never executed.

Added the suggested change

* Apply suggestions from code review

chore: adjust suggested indentation

Co-authored-by: Harald Kuhr <harald.kuhr@gmail.com>

* Update imageio/imageio-core/src/test/java/com/twelvemonkeys/imageio/util/ImageReaderAbstractTest.java

Co-authored-by: Harald Kuhr <harald.kuhr@gmail.com>

* Update imageio/imageio-core/src/test/java/com/twelvemonkeys/imageio/util/ImageReaderAbstractTest.java

Co-authored-by: Harald Kuhr <harald.kuhr@gmail.com>

* Update imageio/imageio-core/src/test/java/com/twelvemonkeys/imageio/util/ImageWriterAbstractTest.java

Co-authored-by: Harald Kuhr <harald.kuhr@gmail.com>

* refactor: using assertTimeout doesnot kill the execution, even if the timeout happens.

It is better to use assertTimeoutPreemptively in cases, where we really want to kill the execution after timeout.
https://stackoverflow.com/questions/57116801/how-to-fail-a-test-after-a-timeout-is-exceeded-in-junit-5/57116959#57116959

---------

Co-authored-by: Harald Kuhr <harald.kuhr@gmail.com>
This commit is contained in:
Vyshak Puthusseri
2024-11-12 14:43:15 +05:30
committed by GitHub
parent a67fdd4b80
commit 543acce8a3
194 changed files with 2554 additions and 3086 deletions
Download Patch File Download Diff File Expand all files Collapse all files

25
common/common-lang/src/test/java/com/twelvemonkeys/lang/BeanUtilTest.java
View File

@@ -30,14 +30,13 @@
package com.twelvemonkeys.lang;
import org.junit.Test;
import java.io.Serializable;
import java.lang.reflect.InvocationTargetException;
import java.util.HashMap;
import java.util.Map;
import static org.junit.Assert.*;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;
/**
* BeanUtilTestCase
@@ -161,10 +160,8 @@ public class BeanUtilTest {
}
assertNotNull(bean.getAmbiguous());
assertEquals("String converted rather than invoking setAmbiguous(String), ordering not predictable",
"one", bean.getAmbiguous());
assertSame("String converted rather than invoking setAmbiguous(String), ordering not predictable",
value, bean.getAmbiguous());
assertEquals("one", bean.getAmbiguous(), "String converted rather than invoking setAmbiguous(String), ordering not predictable");
assertSame(value, bean.getAmbiguous(), "String converted rather than invoking setAmbiguous(String), ordering not predictable");
}
@Test
@@ -184,10 +181,10 @@ public class BeanUtilTest {
}
assertNotNull(bean.getAmbiguous());
assertEquals("Integer converted rather than invoking setAmbiguous(Integer), ordering not predictable",
2, bean.getAmbiguous());
assertSame("Integer converted rather than invoking setAmbiguous(Integer), ordering not predictable",
value, bean.getAmbiguous());
assertEquals(2, bean.getAmbiguous(),
"Integer converted rather than invoking setAmbiguous(Integer), ordering not predictable");
assertSame(value, bean.getAmbiguous(),
"Integer converted rather than invoking setAmbiguous(Integer), ordering not predictable");
}
@Test
@@ -207,10 +204,8 @@ public class BeanUtilTest {
}
assertNotNull(bean.getAmbiguous());
assertEquals("Object converted rather than invoking setAmbiguous(Object), ordering not predictable",
value.getClass(), bean.getAmbiguous().getClass());
assertSame("Object converted rather than invoking setAmbiguous(Object), ordering not predictable",
value, bean.getAmbiguous());
assertEquals(value.getClass(), bean.getAmbiguous().getClass(), "Object converted rather than invoking setAmbiguous(Object), ordering not predictable");
assertSame(value, bean.getAmbiguous(), "Object converted rather than invoking setAmbiguous(Object), ordering not predictable");
}
static class TestBean {

29
common/common-lang/src/test/java/com/twelvemonkeys/lang/DateUtilTest.java
View File

@@ -30,16 +30,16 @@
package com.twelvemonkeys.lang;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import java.util.Arrays;
import java.util.Calendar;
import java.util.List;
import java.util.TimeZone;
import static org.junit.Assert.assertEquals;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.MethodSource;
import static org.junit.jupiter.api.Assertions.*;
/**
* DateUtilTest
@@ -48,12 +48,9 @@ import static org.junit.Assert.assertEquals;
* @author last modified by $Author: haraldk$
* @version $Id: DateUtilTest.java,v 1.0 11.04.12 16:21 haraldk Exp$
*/
@RunWith(Parameterized.class)
public class DateUtilTest {
private final TimeZone timeZone;
@Parameterized.Parameters
public static List<Object[]> timeZones() {
return Arrays.asList(new Object[][] {
{TimeZone.getTimeZone("UTC")},
@@ -62,10 +59,6 @@ public class DateUtilTest {
});
}
public DateUtilTest(final TimeZone timeZone) {
this.timeZone = timeZone;
}
private Calendar getCalendar(long time) {
return getCalendar(time, TimeZone.getDefault());
}
@@ -101,8 +94,9 @@ public class DateUtilTest {
assertEquals(0, calendar.get(Calendar.MINUTE));
}
@Test
public void testRoundToHourTZ() {
@ParameterizedTest
@MethodSource("timeZones")
public void testRoundToHourTZ(TimeZone timeZone) {
Calendar calendar = getCalendar(DateUtil.roundToHour(System.currentTimeMillis(), timeZone), timeZone);
assertEquals(0, calendar.get(Calendar.MILLISECOND));
@@ -120,8 +114,9 @@ public class DateUtilTest {
assertEquals(0, calendar.get(Calendar.HOUR_OF_DAY));
}
@Test
public void testRoundToDayTZ() {
@ParameterizedTest
@MethodSource("timeZones")
public void testRoundToDayTZ(TimeZone timeZone) {
Calendar calendar = getCalendar(DateUtil.roundToDay(System.currentTimeMillis(), timeZone), timeZone);
assertEquals(0, calendar.get(Calendar.MILLISECOND));

33
common/common-lang/src/test/java/com/twelvemonkeys/lang/ObjectAbstractTest.java
View File

@@ -30,12 +30,11 @@
package com.twelvemonkeys.lang;
import org.junit.Test;
import java.io.*;
import java.lang.reflect.Method;
import static org.junit.Assert.*;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;
/**
* AbstractObjectTestCase
@@ -79,10 +78,10 @@ public abstract class ObjectAbstractTest {
Class cl = obj.getClass();
if (isEqualsOverriden(cl)) {
assertTrue("Class " + cl.getName() + " implements equals but not hashCode", isHashCodeOverriden(cl));
assertTrue(isHashCodeOverriden(cl), "Class " + cl.getName() + " implements equals but not hashCode");
}
else if (isHashCodeOverriden(cl)) {
assertTrue("Class " + cl.getName() + " implements hashCode but not equals", isEqualsOverriden(cl));
assertTrue(isEqualsOverriden(cl), "Class " + cl.getName() + " implements hashCode but not equals");
}
}
@@ -107,7 +106,7 @@ public abstract class ObjectAbstractTest {
@Test
public void testObjectEqualsSelf() {
Object obj = makeObject();
assertEquals("An Object should equal itself", obj, obj);
assertEquals(obj, obj, "An Object should equal itself");
}
@Test
@@ -115,32 +114,26 @@ public abstract class ObjectAbstractTest {
Object obj = makeObject();
// NOTE: Makes sure this doesn't throw NPE either
//noinspection ObjectEqualsNull
assertFalse("An object should never equal null", obj.equals(null));
assertFalse(obj.equals(null), "An object should never equal null");
}
@Test
public void testObjectHashCodeEqualsSelfHashCode() {
Object obj = makeObject();
assertEquals("hashCode should be repeatable", obj.hashCode(), obj.hashCode());
assertEquals(obj.hashCode(), obj.hashCode(), "hashCode should be repeatable");
}
@Test
public void testObjectHashCodeEqualsContract() {
Object obj1 = makeObject();
if (obj1.equals(obj1)) {
assertEquals(
"[1] When two objects are equal, their hashCodes should be also.",
obj1.hashCode(), obj1.hashCode());
assertEquals(obj1.hashCode(), obj1.hashCode(), "[1] When two objects are equal, their hashCodes should be also.");
}
// TODO: Make sure we create at least one equal object, and one different object
Object obj2 = makeObject();
if (obj1.equals(obj2)) {
assertEquals(
"[2] When two objects are equal, their hashCodes should be also.",
obj1.hashCode(), obj2.hashCode());
assertTrue(
"When obj1.equals(obj2) is true, then obj2.equals(obj1) should also be true",
obj2.equals(obj1));
assertEquals(obj1.hashCode(), obj2.hashCode(), "[2] When two objects are equal, their hashCodes should be also.");
assertTrue(obj2.equals(obj1), "When obj1.equals(obj2) is true, then obj2.equals(obj1) should also be true");
}
}
@@ -169,14 +162,14 @@ public abstract class ObjectAbstractTest {
Object cloned = clone.invoke(obj);
assertNotNull("Cloned object should never be null", cloned);
assertNotNull(cloned, "Cloned object should never be null");
// TODO: This can only be asserted if equals() test is based on
// value equality, not reference (identity) equality
// Maybe it's possible to do a reflective introspection of
// the objects fields?
if (isHashCodeOverriden(cl)) {
assertEquals("Cloned object not equal", obj, cloned);
assertEquals(obj, cloned, "Cloned object not equal");
}
}
}
@@ -235,7 +228,7 @@ public abstract class ObjectAbstractTest {
// Maybe it's possible to do a reflective introspection of
// the objects fields?
if (isEqualsOverriden(obj.getClass())) {
assertEquals("obj != deserialize(serialize(obj))", obj, dest);
assertEquals(obj, dest, "obj != deserialize(serialize(obj))");
}
}
}

12
common/common-lang/src/test/java/com/twelvemonkeys/lang/PlatformTest.java
View File

@@ -30,13 +30,11 @@
package com.twelvemonkeys.lang;
import org.junit.Ignore;
import org.junit.Test;
import java.util.Properties;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;
/**
* PlatformTest
@@ -121,7 +119,7 @@ public class PlatformTest {
assertEquals(Platform.Architecture.X86, platform.getArchitecture());
}
@Ignore("Known issue, needs resolve")
@Disabled("Known issue, needs resolve")
@Test
public void testCreateWindows686() {
Platform platform = new Platform(createProperties("Windows", "5.1", "686"));
@@ -129,7 +127,7 @@ public class PlatformTest {
assertEquals(Platform.Architecture.X86, platform.getArchitecture());
}
@Ignore("Known issue, needs resolve")
@Disabled("Known issue, needs resolve")
@Test
public void testCreateLinuxX86() {
Platform platform = new Platform(createProperties("Linux", "3.0.18", "x86"));

30
common/common-lang/src/test/java/com/twelvemonkeys/lang/StringUtilTest.java
View File

@@ -30,8 +30,6 @@
package com.twelvemonkeys.lang;
import static org.junit.Assert.*;
import java.awt.*;
import java.sql.Timestamp;
import java.text.DateFormat;
@@ -41,8 +39,8 @@ import java.util.Date;
import java.util.GregorianCalendar;
import java.util.Locale;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;
/**
* StringUtilTestCase
*
@@ -165,10 +163,10 @@ public class StringUtilTest {
// Test all alpha-chars
for (int i = 'a'; i < 'z'; i++) {
if (TEST_STRING.indexOf(i) < 0) {
assertFalse(TEST_STRING + " seems to contain '" + (char) i + "', at index " + TEST_STRING.indexOf(i), StringUtil.contains(TEST_STRING, i));
assertFalse(StringUtil.contains(TEST_STRING, i), TEST_STRING + " seems to contain '" + (char) i + "', at index " + TEST_STRING.indexOf(i));
}
else {
assertTrue(TEST_STRING + " seems to not contain '" + (char) i + "', at index " + TEST_STRING.indexOf(i), StringUtil.contains(TEST_STRING, i));
assertTrue(StringUtil.contains(TEST_STRING, i), TEST_STRING + " seems to not contain '" + (char) i + "', at index " + TEST_STRING.indexOf(i));
}
}
}
@@ -199,10 +197,10 @@ public class StringUtilTest {
// Test all alpha-chars
for (int i = 'a'; i < 'z'; i++) {
if ((TEST_STRING.indexOf(i) < 0) && (TEST_STRING.indexOf(Character.toUpperCase((char) i)) < 0)) {
assertFalse(TEST_STRING + " seems to contain '" + (char) i + "', at index " + Math.max(TEST_STRING.indexOf(i), TEST_STRING.indexOf(Character.toUpperCase((char) i))), StringUtil.containsIgnoreCase(TEST_STRING, i));
assertFalse(StringUtil.containsIgnoreCase(TEST_STRING, i), TEST_STRING + " seems to contain '" + (char) i + "', at index " + Math.max(TEST_STRING.indexOf(i), TEST_STRING.indexOf(Character.toUpperCase((char) i))));
}
else {
assertTrue(TEST_STRING + " seems to not contain '" + (char) i + "', at index " + TEST_STRING.indexOf(i), StringUtil.containsIgnoreCase(TEST_STRING, i));
assertTrue(StringUtil.containsIgnoreCase(TEST_STRING, i), TEST_STRING + " seems to not contain '" + (char) i + "', at index " + TEST_STRING.indexOf(i));
}
}
}
@@ -350,10 +348,10 @@ public class StringUtilTest {
// Test all alpha-chars
for (int i = 'a'; i < 'z'; i++) {
if ((TEST_STRING.indexOf(i) < 0) && (TEST_STRING.indexOf(Character.toUpperCase((char) i)) < 0)) {
assertEquals(TEST_STRING + " seems to contain '" + (char) i + "', at index " + Math.max(TEST_STRING.indexOf(i), TEST_STRING.indexOf(Character.toUpperCase((char) i))), -1, StringUtil.indexOfIgnoreCase(TEST_STRING, i));
assertEquals(-1, StringUtil.indexOfIgnoreCase(TEST_STRING, i), TEST_STRING + " seems to contain '" + (char) i + "', at index " + Math.max(TEST_STRING.indexOf(i), TEST_STRING.indexOf(Character.toUpperCase((char) i))));
}
else {
assertTrue(TEST_STRING + " seems to not contain '" + (char) i + "', at index " + TEST_STRING.indexOf(i), 0 <= StringUtil.indexOfIgnoreCase(TEST_STRING, i));
assertTrue(0 <= StringUtil.indexOfIgnoreCase(TEST_STRING, i), TEST_STRING + " seems to not contain '" + (char) i + "', at index " + TEST_STRING.indexOf(i));
}
}
}
@@ -385,10 +383,10 @@ public class StringUtilTest {
// Test all alpha-chars
for (int i = 'a'; i < 'z'; i++) {
if ((TEST_STRING.indexOf(i) < 0) && (TEST_STRING.indexOf(Character.toUpperCase((char) i)) < 0)) {
assertEquals(TEST_STRING + " seems to contain '" + (char) i + "', at index " + Math.max(TEST_STRING.indexOf(i), TEST_STRING.indexOf(Character.toUpperCase((char) i))), -1, StringUtil.indexOfIgnoreCase(TEST_STRING, i, 0));
assertEquals(-1, StringUtil.indexOfIgnoreCase(TEST_STRING, i, 0), TEST_STRING + " seems to contain '" + (char) i + "', at index " + Math.max(TEST_STRING.indexOf(i), TEST_STRING.indexOf(Character.toUpperCase((char) i))));
}
else {
assertTrue(TEST_STRING + " seems to not contain '" + (char) i + "', at index " + TEST_STRING.indexOf(i), 0 <= StringUtil.indexOfIgnoreCase(TEST_STRING, i, 0));
assertTrue(0 <= StringUtil.indexOfIgnoreCase(TEST_STRING, i, 0), TEST_STRING + " seems to not contain '" + (char) i + "', at index " + TEST_STRING.indexOf(i));
}
}
}
@@ -420,10 +418,10 @@ public class StringUtilTest {
// Test all alpha-chars
for (int i = 'a'; i < 'z'; i++) {
if ((TEST_STRING.indexOf(i) < 0) && (TEST_STRING.indexOf(Character.toUpperCase((char) i)) < 0)) {
assertEquals(TEST_STRING + " seems to contain '" + (char) i + "', at index " + Math.max(TEST_STRING.indexOf(i), TEST_STRING.indexOf(Character.toUpperCase((char) i))), -1, StringUtil.lastIndexOfIgnoreCase(TEST_STRING, i));
assertEquals(-1, StringUtil.lastIndexOfIgnoreCase(TEST_STRING, i), TEST_STRING + " seems to contain '" + (char) i + "', at index " + Math.max(TEST_STRING.indexOf(i), TEST_STRING.indexOf(Character.toUpperCase((char) i))));
}
else {
assertTrue(TEST_STRING + " seems to not contain '" + (char) i + "', at index " + TEST_STRING.indexOf(i), 0 <= StringUtil.lastIndexOfIgnoreCase(TEST_STRING, i));
assertTrue(0 <= StringUtil.lastIndexOfIgnoreCase(TEST_STRING, i), TEST_STRING + " seems to not contain '" + (char) i + "', at index " + TEST_STRING.indexOf(i));
}
}
}
@@ -455,10 +453,10 @@ public class StringUtilTest {
// Test all alpha-chars
for (int i = 'a'; i < 'z'; i++) {
if ((TEST_STRING.indexOf(i) < 0) && (TEST_STRING.indexOf(Character.toUpperCase((char) i)) < 0)) {
assertEquals(TEST_STRING + " seems to contain '" + (char) i + "', at index " + Math.max(TEST_STRING.indexOf(i), TEST_STRING.indexOf(Character.toUpperCase((char) i))), -1, StringUtil.lastIndexOfIgnoreCase(TEST_STRING, i, TEST_STRING.length()));
assertEquals(-1, StringUtil.lastIndexOfIgnoreCase(TEST_STRING, i, TEST_STRING.length()), TEST_STRING + " seems to contain '" + (char) i + "', at index " + Math.max(TEST_STRING.indexOf(i), TEST_STRING.indexOf(Character.toUpperCase((char) i))));
}
else {
assertTrue(TEST_STRING + " seems to not contain '" + (char) i + "', at index " + TEST_STRING.indexOf(i), 0 <= StringUtil.lastIndexOfIgnoreCase(TEST_STRING, i, TEST_STRING.length()));
assertTrue(0 <= StringUtil.lastIndexOfIgnoreCase(TEST_STRING, i, TEST_STRING.length()), TEST_STRING + " seems to not contain '" + (char) i + "', at index " + TEST_STRING.indexOf(i));
}
}
}

4
common/common-lang/src/test/java/com/twelvemonkeys/lang/SystemUtilTest.java
View File

@@ -30,7 +30,7 @@
package com.twelvemonkeys.lang;
import org.junit.Ignore;
import org.junit.jupiter.api.Disabled;
/**
* SystemUtilTest
@@ -39,6 +39,6 @@ import org.junit.Ignore;
* @author last modified by $Author: haraldk$
* @version $Id: SystemUtilTest.java,v 1.0 11.04.12 16:21 haraldk Exp$
*/
@Ignore
@Disabled
public class SystemUtilTest {
}

694
common/common-lang/src/test/java/com/twelvemonkeys/lang/ValidateTest.java
View File

File diff suppressed because it is too large Load Diff

228
common/common-lang/src/test/java/com/twelvemonkeys/util/CollectionAbstractTest.java
View File

@@ -45,12 +45,11 @@
package com.twelvemonkeys.util;
import org.junit.Test;
import java.lang.reflect.Array;
import java.util.*;
import static org.junit.Assert.*;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;
/**
* Abstract test class for {@link java.util.Collection} methods and contracts.
@@ -251,11 +250,8 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
*/
public void verifyAll() {
int confirmedSize = confirmed.size();
assertEquals("Collection size should match confirmed collection's",
confirmedSize, collection.size());
assertEquals("Collection isEmpty() result should match confirmed " +
" collection's",
confirmed.isEmpty(), collection.isEmpty());
assertEquals(confirmedSize, collection.size(), "Collection size should match confirmed collection's");
assertEquals(confirmed.isEmpty(), collection.isEmpty(), "Collection isEmpty() result should match confirmed collection's");
// verify the collections are the same by attempting to match each
// object in the collection and confirmed collection. To account for
@@ -521,8 +517,8 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
boolean r = collection.add(elements[i]);
confirmed.add(elements[i]);
verifyAll();
assertTrue("Empty collection changed after add", r);
assertEquals("Collection size is 1 after first add", 1, collection.size());
assertTrue(r, "Empty collection changed after add");
assertEquals(1, collection.size(), "Collection size is 1 after first add");
}
resetEmpty();
@@ -532,10 +528,8 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
confirmed.add(elements[i]);
verifyAll();
if (r) size++;
assertEquals("Collection size should grow after add",
size, collection.size());
assertTrue("Collection should contain added element",
collection.contains(elements[i]));
assertEquals(size, collection.size(), "Collection size should grow after add");
assertTrue(collection.contains(elements[i]), "Collection should contain added element");
}
}
@@ -552,10 +546,9 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
boolean r = collection.addAll(Arrays.asList(elements));
confirmed.addAll(Arrays.asList(elements));
verifyAll();
assertTrue("Empty collection should change after addAll", r);
assertTrue(r, "Empty collection should change after addAll");
for (int i = 0; i < elements.length; i++) {
assertTrue("Collection should contain added element",
collection.contains(elements[i]));
assertTrue(collection.contains(elements[i]), "Collection should contain added element");
}
resetFull();
@@ -564,13 +557,11 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
r = collection.addAll(Arrays.asList(elements));
confirmed.addAll(Arrays.asList(elements));
verifyAll();
assertTrue("Full collection should change after addAll", r);
assertTrue(r, "Full collection should change after addAll");
for (int i = 0; i < elements.length; i++) {
assertTrue("Full collection should contain added element",
collection.contains(elements[i]));
assertTrue(collection.contains(elements[i]), "Full collection should contain added element");
}
assertEquals("Size should increase after addAll",
size + elements.length, collection.size());
assertEquals(size + elements.length, collection.size(), "Size should increase after addAll");
resetFull();
size = collection.size();
@@ -578,11 +569,9 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
confirmed.addAll(Arrays.asList(getFullElements()));
verifyAll();
if (r) {
assertTrue("Size should increase if addAll returns true",
size < collection.size());
assertTrue(size < collection.size(), "Size should increase if addAll returns true");
} else {
assertEquals("Size should not change if addAll returns false",
size, collection.size());
assertEquals(size, collection.size(), "Size should not change if addAll returns false");
}
}
@@ -666,16 +655,14 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
resetEmpty();
elements = getFullElements();
for(int i = 0; i < elements.length; i++) {
assertTrue("Empty collection shouldn't contain element[" + i + "]",
!collection.contains(elements[i]));
assertTrue(!collection.contains(elements[i]), "Empty collection shouldn't contain element[" + i + "]");
}
// make sure calls to "contains" don't change anything
verifyAll();
elements = getOtherElements();
for(int i = 0; i < elements.length; i++) {
assertTrue("Empty collection shouldn't contain element[" + i + "]",
!collection.contains(elements[i]));
assertTrue(!collection.contains(elements[i]), "Empty collection shouldn't contain element[" + i + "]");
}
// make sure calls to "contains" don't change anything
verifyAll();
@@ -683,8 +670,7 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
resetFull();
elements = getFullElements();
for(int i = 0; i < elements.length; i++) {
assertTrue("Full collection should contain element[" + i + "]",
collection.contains(elements[i]));
assertTrue(collection.contains(elements[i]), "Full collection should contain element[" + i + "]");
}
// make sure calls to "contains" don't change anything
verifyAll();
@@ -692,8 +678,7 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
resetFull();
elements = getOtherElements();
for(int i = 0; i < elements.length; i++) {
assertTrue("Full collection shouldn't contain element",
!collection.contains(elements[i]));
assertTrue(!collection.contains(elements[i]), "Full collection shouldn't contain element");
}
}
@@ -705,22 +690,22 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
public void testCollectionContainsAll() {
resetEmpty();
Collection col = new HashSet();
assertTrue("Every Collection should contain all elements of an " +
"empty Collection.", collection.containsAll(col));
assertTrue(collection.containsAll(col),
"Every Collection should contain all elements of an " +
"empty Collection.");
col.addAll(Arrays.asList(getOtherElements()));
assertTrue("Empty Collection shouldn't contain all elements of " +
"a non-empty Collection.", !collection.containsAll(col));
assertTrue(!collection.containsAll(col),
"Empty Collection shouldn't contain all elements of " +
"a non-empty Collection.");
// make sure calls to "containsAll" don't change anything
verifyAll();
resetFull();
assertTrue("Full collection shouldn't contain other elements",
!collection.containsAll(col));
assertTrue(!collection.containsAll(col), "Full collection shouldn't contain other elements");
col.clear();
col.addAll(Arrays.asList(getFullElements()));
assertTrue("Full collection should containAll full elements",
collection.containsAll(col));
assertTrue(collection.containsAll(col), "Full collection should containAll full elements");
// make sure calls to "containsAll" don't change anything
verifyAll();
@@ -728,18 +713,17 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
int max = (getFullElements().length == 1 ? 1 :
(getFullElements().length <= 5 ? getFullElements().length - 1 : 5));
col = Arrays.asList(getFullElements()).subList(min, max);
assertTrue("Full collection should containAll partial full " +
"elements", collection.containsAll(col));
assertTrue("Full collection should containAll itself",
collection.containsAll(collection));
assertTrue(collection.containsAll(col), "Full collection should containAll partial full " +
"elements");
assertTrue(collection.containsAll(collection), "Full collection should containAll itself");
// make sure calls to "containsAll" don't change anything
verifyAll();
col = new ArrayList();
col.addAll(Arrays.asList(getFullElements()));
col.addAll(Arrays.asList(getFullElements()));
assertTrue("Full collection should containAll duplicate full " +
"elements", collection.containsAll(col));
assertTrue(collection.containsAll(col), "Full collection should containAll duplicate full " +
"elements");
// make sure calls to "containsAll" don't change anything
verifyAll();
@@ -751,14 +735,12 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
@Test
public void testCollectionIsEmpty() {
resetEmpty();
assertEquals("New Collection should be empty.",
true, collection.isEmpty());
assertEquals(true, collection.isEmpty(), "New Collection should be empty.");
// make sure calls to "isEmpty() don't change anything
verifyAll();
resetFull();
assertEquals("Full collection shouldn't be empty",
false, collection.isEmpty());
assertEquals(false, collection.isEmpty(), "Full collection shouldn't be empty");
// make sure calls to "isEmpty() don't change anything
verifyAll();
}
@@ -771,8 +753,7 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
public void testCollectionIterator() {
resetEmpty();
Iterator it1 = collection.iterator();
assertEquals("Iterator for empty Collection shouldn't have next.",
false, it1.hasNext());
assertEquals(false, it1.hasNext(), "Iterator for empty Collection shouldn't have next.");
try {
it1.next();
fail("Iterator at end of Collection should throw " +
@@ -786,18 +767,17 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
resetFull();
it1 = collection.iterator();
for (int i = 0; i < collection.size(); i++) {
assertTrue("Iterator for full collection should haveNext",
it1.hasNext());
assertTrue(it1.hasNext(), "Iterator for full collection should haveNext");
it1.next();
}
assertTrue("Iterator should be finished", !it1.hasNext());
assertTrue(!it1.hasNext(), "Iterator should be finished");
ArrayList list = new ArrayList();
it1 = collection.iterator();
for (int i = 0; i < collection.size(); i++) {
Object next = it1.next();
assertTrue("Collection should contain element returned by " +
"its iterator", collection.contains(next));
assertTrue(collection.contains(next), "Collection should contain element returned by " +
"its iterator");
list.add(next);
}
try {
@@ -865,11 +845,10 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
}
size--;
assertEquals("Collection should shrink by one after " +
"iterator.remove", size, collection.size());
assertEquals(size, collection.size(), "Collection should shrink by one after " +
"iterator.remove");
}
assertTrue("Collection should be empty after iterator purge",
collection.isEmpty());
assertTrue(collection.isEmpty(), "Collection should be empty after iterator purge");
resetFull();
iter = collection.iterator();
@@ -894,8 +873,7 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
resetEmpty();
Object[] elements = getFullElements();
for (int i = 0; i < elements.length; i++) {
assertTrue("Shouldn't remove nonexistent element",
!collection.remove(elements[i]));
assertTrue(!collection.remove(elements[i]), "Shouldn't remove nonexistent element");
verifyAll();
}
@@ -903,16 +881,14 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
resetFull();
for (int i = 0; i < other.length; i++) {
assertTrue("Shouldn't remove nonexistent other element",
!collection.remove(other[i]));
assertTrue(!collection.remove(other[i]), "Shouldn't remove nonexistent other element");
verifyAll();
}
int size = collection.size();
for (int i = 0; i < elements.length; i++) {
resetFull();
assertTrue("Collection should remove extant element: " + elements[i],
collection.remove(elements[i]));
assertTrue(collection.remove(elements[i]), "Collection should remove extant element: " + elements[i]);
// if the elements aren't distinguishable, we can just remove a
// matching element from the confirmed collection and verify
@@ -927,8 +903,7 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
verifyAll();
}
assertEquals("Collection should shrink after remove",
size - 1, collection.size());
assertEquals(size - 1, collection.size(), "Collection should shrink after remove");
}
}
@@ -941,28 +916,28 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
if (!isRemoveSupported()) return;
resetEmpty();
assertTrue("Emtpy collection removeAll should return false for " +
"empty input",
!collection.removeAll(Collections.EMPTY_SET));
assertTrue(!collection.removeAll(Collections.EMPTY_SET),
"Emtpy collection removeAll should return false for " +
"empty input");
verifyAll();
assertTrue("Emtpy collection removeAll should return false for " +
"nonempty input",
!collection.removeAll(new ArrayList(collection)));
assertTrue(!collection.removeAll(new ArrayList(collection)),
"Emtpy collection removeAll should return false for " +
"nonempty input");
verifyAll();
resetFull();
assertTrue("Full collection removeAll should return false for " +
"empty input",
!collection.removeAll(Collections.EMPTY_SET));
assertTrue(!collection.removeAll(Collections.EMPTY_SET),
"Full collection removeAll should return false for " +
"empty input");
verifyAll();
assertTrue("Full collection removeAll should return false for other elements",
!collection.removeAll(Arrays.asList(getOtherElements())));
assertTrue(!collection.removeAll(Arrays.asList(getOtherElements())),
"Full collection removeAll should return false for other elements");
verifyAll();
assertTrue("Full collection removeAll should return true for full elements",
collection.removeAll(new HashSet(collection)));
assertTrue(collection.removeAll(new HashSet(collection)),
"Full collection removeAll should return true for full elements");
confirmed.removeAll(new HashSet(confirmed));
verifyAll();
@@ -972,17 +947,14 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
int max = (getFullElements().length == 1 ? 1 :
(getFullElements().length <= 5 ? getFullElements().length - 1 : 5));
Collection all = Arrays.asList(getFullElements()).subList(min, max);
assertTrue("Full collection removeAll should work",
collection.removeAll(all));
assertTrue(collection.removeAll(all), "Full collection removeAll should work");
confirmed.removeAll(all);
verifyAll();
assertTrue("Collection should shrink after removeAll",
collection.size() < size);
assertTrue(collection.size() < size, "Collection should shrink after removeAll");
Iterator iter = all.iterator();
while (iter.hasNext()) {
assertTrue("Collection shouldn't contain removed element",
!collection.contains(iter.next()));
assertTrue(!collection.contains(iter.next()), "Collection shouldn't contain removed element");
}
}
@@ -998,59 +970,51 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
List elements = Arrays.asList(getFullElements());
List other = Arrays.asList(getOtherElements());
assertTrue("Empty retainAll() should return false",
!collection.retainAll(Collections.EMPTY_SET));
assertTrue(!collection.retainAll(Collections.EMPTY_SET), "Empty retainAll() should return false");
verifyAll();
assertTrue("Empty retainAll() should return false",
!collection.retainAll(elements));
assertTrue(!collection.retainAll(elements), "Empty retainAll() should return false");
verifyAll();
resetFull();
assertTrue("Collection should change from retainAll empty",
collection.retainAll(Collections.EMPTY_SET));
assertTrue(collection.retainAll(Collections.EMPTY_SET), "Collection should change from retainAll empty");
confirmed.retainAll(Collections.EMPTY_SET);
verifyAll();
resetFull();
assertTrue("Collection changed from retainAll other",
collection.retainAll(other));
assertTrue(collection.retainAll(other), "Collection changed from retainAll other");
confirmed.retainAll(other);
verifyAll();
resetFull();
int size = collection.size();
assertTrue("Collection shouldn't change from retainAll elements",
!collection.retainAll(elements));
assertTrue(!collection.retainAll(elements), "Collection shouldn't change from retainAll elements");
verifyAll();
assertEquals("Collection size shouldn't change", size,
collection.size());
assertEquals(size, collection.size(), "Collection size shouldn't change");
if (getFullElements().length > 1) {
resetFull();
size = collection.size();
int min = (getFullElements().length < 2 ? 0 : 2);
int max = (getFullElements().length <= 5 ? getFullElements().length - 1 : 5);
assertTrue("Collection should changed by partial retainAll",
collection.retainAll(elements.subList(min, max)));
assertTrue(collection.retainAll(elements.subList(min, max)), "Collection should changed by partial retainAll");
confirmed.retainAll(elements.subList(min, max));
verifyAll();
Iterator iter = collection.iterator();
while (iter.hasNext()) {
assertTrue("Collection only contains retained element",
elements.subList(min, max).contains(iter.next()));
assertTrue(elements.subList(min, max).contains(iter.next()), "Collection only contains retained element");
}
}
resetFull();
HashSet set = new HashSet(elements);
size = collection.size();
assertTrue("Collection shouldn't change from retainAll without " +
"duplicate elements", !collection.retainAll(set));
assertTrue(!collection.retainAll(set),
"Collection shouldn't change from retainAll without duplicate elements");
verifyAll();
assertEquals("Collection size didn't change from nonduplicate " +
"retainAll", size, collection.size());
assertEquals( size, collection.size(),
"Collection size didn't change from nonduplicate retainAll");
}
@@ -1060,11 +1024,10 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
@Test
public void testCollectionSize() {
resetEmpty();
assertEquals("Size of new Collection is 0.", 0, collection.size());
assertEquals(0, collection.size(), "Size of new Collection is 0.");
resetFull();
assertTrue("Size of full collection should be greater than zero",
collection.size() > 0);
assertTrue(collection.size() > 0, "Size of full collection should be greater than zero");
}
@@ -1073,22 +1036,18 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
*/
public void testCollectionToArray() {
resetEmpty();
assertEquals("Empty Collection should return empty array for toArray",
0, collection.toArray().length);
assertEquals(0, collection.toArray().length, "Empty Collection should return empty array for toArray");
resetFull();
Object[] array = collection.toArray();
assertEquals("Full collection toArray should be same size as " +
"collection", array.length, collection.size());
assertEquals(array.length, collection.size(), "Full collection toArray should be same size as collection");
Object[] confirmedArray = confirmed.toArray();
assertEquals("length of array from confirmed collection should " +
"match the length of the collection's array",
confirmedArray.length, array.length);
assertEquals(confirmedArray.length, array.length,
"length of array from confirmed collection should match the length of the collection's array");
boolean[] matched = new boolean[array.length];
for (int i = 0; i < array.length; i++) {
assertTrue("Collection should contain element in toArray",
collection.contains(array[i]));
assertTrue(collection.contains(array[i]), "Collection should contain element in toArray");
boolean match = false;
// find a match in the confirmed array
@@ -1108,8 +1067,7 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
}
}
for(int i = 0; i < matched.length; i++) {
assertEquals("Collection should return all its elements in " +
"toArray", true, matched[i]);
assertEquals(true, matched[i], "Collection should return all its elements in toArray");
}
}
@@ -1123,8 +1081,8 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
resetEmpty();
Object[] a = new Object[] { new Object(), null, null };
Object[] array = collection.toArray(a);
assertArrayEquals("Given array shouldn't shrink", array, a);
assertNull("Last element should be set to null", a[0]);
assertArrayEquals(array, a, "Given array shouldn't shrink");
assertNull(a[0], "Last element should be set to null");
verifyAll();
resetFull();
@@ -1146,8 +1104,7 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
array = collection.toArray(new Object[0]);
a = collection.toArray();
assertEquals("toArrays should be equal",
Arrays.asList(array), Arrays.asList(a));
assertEquals(Arrays.asList(array), Arrays.asList(a), "toArrays should be equal");
// Figure out if they're all the same class
// TODO: It'd be nicer to detect a common superclass
@@ -1163,11 +1120,10 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
}
a = (Object[])Array.newInstance(cl, 0);
array = collection.toArray(a);
assertEquals("toArray(Object[]) should return correct array type",
a.getClass(), array.getClass());
assertEquals("type-specific toArrays should be equal",
Arrays.asList(array),
Arrays.asList(collection.toArray()));
assertEquals(a.getClass(), array.getClass(), "toArray(Object[]) should return correct array type");
assertEquals(Arrays.asList(array),
Arrays.asList(collection.toArray()),
"type-specific toArrays should be equal");
verifyAll();
}
@@ -1178,12 +1134,10 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
@Test
public void testCollectionToString() {
resetEmpty();
assertTrue("toString shouldn't return null",
collection.toString() != null);
assertTrue(collection.toString() != null, "toString shouldn't return null");
resetFull();
assertTrue("toString shouldn't return null",
collection.toString() != null);
assertTrue(collection.toString() != null, "toString shouldn't return null");
}

110
common/common-lang/src/test/java/com/twelvemonkeys/util/CollectionUtilTest.java
View File

@@ -30,13 +30,11 @@
package com.twelvemonkeys.util;
import org.junit.Ignore;
import org.junit.Test;
import java.util.*;
import static org.junit.Assert.*;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;
/**
* CollectionUtilTest
*
@@ -61,44 +59,60 @@ public class CollectionUtilTest {
assertArrayEquals(new Object[] {"bar", "baz", 3}, merged);
}
@Test(expected = IndexOutOfBoundsException.class)
@Test
public void testMergeArraysObjectBadOffset() {
CollectionUtil.mergeArrays(stringObjects, 4, 2, integerObjects, 2, 1);
assertThrows(IndexOutOfBoundsException.class, () -> {
CollectionUtil.mergeArrays(stringObjects, 4, 2, integerObjects, 2, 1);
});
}
@Test(expected = IndexOutOfBoundsException.class)
@Test
public void testMergeArraysObjectBadSecondOffset() {
CollectionUtil.mergeArrays(stringObjects, 1, 2, integerObjects, 4, 1);
assertThrows(IndexOutOfBoundsException.class, () -> {
CollectionUtil.mergeArrays(stringObjects, 1, 2, integerObjects, 4, 1);
});
}
@Test(expected = IndexOutOfBoundsException.class)
@Test
public void testMergeArraysObjectBadLength() {
CollectionUtil.mergeArrays(stringObjects, 1, 4, integerObjects, 2, 1);
assertThrows(IndexOutOfBoundsException.class, () -> {
CollectionUtil.mergeArrays(stringObjects, 1, 4, integerObjects, 2, 1);
});
}
@Test(expected = IndexOutOfBoundsException.class)
@Test
public void testMergeArraysObjectBadSecondLength() {
CollectionUtil.mergeArrays(stringObjects, 1, 2, integerObjects, 2, 2);
assertThrows(IndexOutOfBoundsException.class, () -> {
CollectionUtil.mergeArrays(stringObjects, 1, 2, integerObjects, 2, 2);
});
}
@Test(expected = IndexOutOfBoundsException.class)
@Test
public void testMergeArraysObjectNegativeOffset() {
CollectionUtil.mergeArrays(stringObjects, -1, 2, integerObjects, 2, 1);
assertThrows(IndexOutOfBoundsException.class, () -> {
CollectionUtil.mergeArrays(stringObjects, -1, 2, integerObjects, 2, 1);
});
}
@Test(expected = IndexOutOfBoundsException.class)
@Test
public void testMergeArraysObjectNegativeSecondOffset() {
CollectionUtil.mergeArrays(stringObjects, 1, 2, integerObjects, -1, 1);
assertThrows(IndexOutOfBoundsException.class, () -> {
CollectionUtil.mergeArrays(stringObjects, 1, 2, integerObjects, -1, 1);
});
}
@Test(expected = IndexOutOfBoundsException.class)
@Test
public void testMergeArraysObjectNegativeLength() {
CollectionUtil.mergeArrays(stringObjects, 1, -1, integerObjects, 2, 1);
assertThrows(IndexOutOfBoundsException.class, () -> {
CollectionUtil.mergeArrays(stringObjects, 1, -1, integerObjects, 2, 1);
});
}
@Test(expected = IndexOutOfBoundsException.class)
@Test
public void testMergeArraysObjectNegativeSecondLength() {
CollectionUtil.mergeArrays(stringObjects, 1, 2, integerObjects, 2, -1);
assertThrows(IndexOutOfBoundsException.class, () -> {
CollectionUtil.mergeArrays(stringObjects, 1, 2, integerObjects, 2, -1);
});
}
@Test
@@ -109,20 +123,24 @@ public class CollectionUtilTest {
assertArrayEquals(new Object[] {"foo", "bar", "baz", 1, 2, 3}, merged);
}
@Test(expected = ArrayStoreException.class)
@Test
public void testMergeArraysObjectIllegalType() {
String[] strings = {"foo", "bar", "baz"};
Integer[] integers = {1, 2, 3}; // Integer not assignable to String
CollectionUtil.mergeArrays(strings, integers);
assertThrows(ArrayStoreException.class, () -> {
CollectionUtil.mergeArrays(strings, integers);
});
}
@Test(expected = ArrayStoreException.class)
@Test
public void testMergeArraysNativeIllegalType() {
char[] chars = {'a', 'b', 'c'};
int[] integers = {1, 2, 3}; // Integer not assignable to String
CollectionUtil.mergeArrays(chars, integers);
assertThrows(ArrayStoreException.class, () -> {
CollectionUtil.mergeArrays(chars, integers);
});
}
@@ -147,9 +165,11 @@ public class CollectionUtilTest {
assertArrayEquals(new int[] {2, 3, 4}, numbers);
}
@Test(expected = IllegalArgumentException.class)
@Test
public void testEnumIteratorNull() {
CollectionUtil.iterator((Enumeration<Object>) null);
assertThrows(IllegalArgumentException.class, () -> {
CollectionUtil.iterator((Enumeration<Object>) null);
});
}
@Test
@@ -183,9 +203,11 @@ public class CollectionUtilTest {
}
}
@Test(expected = IllegalArgumentException.class)
@Test
public void testArrayIteratorNull() {
CollectionUtil.iterator((Object[]) null);
assertThrows(IllegalArgumentException.class, () -> {
CollectionUtil.iterator((Object[]) null);
});
}
@Test
@@ -262,7 +284,7 @@ public class CollectionUtilTest {
int count = 0;
for (Object element : elements) {
assertTrue("No next element for element '" + element + "' at index: " + count, iterator.hasNext());
assertTrue(iterator.hasNext(), "No next element for element '" + element + "' at index: " + count);
assertEquals(count > 0, iterator.hasPrevious());
assertEquals(count, iterator.nextIndex());
assertEquals(count - 1, iterator.previousIndex());
@@ -318,7 +340,7 @@ public class CollectionUtilTest {
assertEquals(elements.length, iterator.nextIndex());
for (int i = count; i > 0; i--) {
assertTrue("No previous element for element '" + elements[i - 1] + "' at index: " + (i - 1), iterator.hasPrevious());
assertTrue(iterator.hasPrevious(), "No previous element for element '" + elements[i - 1] + "' at index: " + (i - 1));
assertEquals(i < elements.length, iterator.hasNext());
assertEquals(i - 1, iterator.previousIndex());
assertEquals(i, iterator.nextIndex());
@@ -339,18 +361,24 @@ public class CollectionUtilTest {
}
}
@Test(expected = IllegalArgumentException.class)
@Test
public void testArrayIteratorRangeNull() {
CollectionUtil.iterator(null, 0, 0);
assertThrows(IllegalArgumentException.class, () -> {
CollectionUtil.iterator(null, 0, 0);
});
}
@Test(expected = IllegalArgumentException.class)
@Test
public void testArrayIteratorRangeBadStart() {
CollectionUtil.iterator(stringObjects, stringObjects.length + 1, 2);
assertThrows(IllegalArgumentException.class, () -> {
CollectionUtil.iterator(stringObjects, stringObjects.length + 1, 2);
});
}
@Test(expected = IllegalArgumentException.class)
@Test
public void testArrayIteratorRangeBadLength() {
CollectionUtil.iterator(stringObjects, 1, stringObjects.length);
assertThrows(IllegalArgumentException.class, () -> {
CollectionUtil.iterator(stringObjects, 1, stringObjects.length);
});
}
@Test
@@ -379,9 +407,11 @@ public class CollectionUtilTest {
}
}
@Test(expected = IllegalArgumentException.class)
@Test
public void testReverseOrderNull() {
CollectionUtil.reverseOrder(null);
assertThrows(IllegalArgumentException.class, () -> {
CollectionUtil.reverseOrder(null);
});
}
@Test
@@ -431,7 +461,7 @@ public class CollectionUtilTest {
}
}
@Ignore("For development only")
@Disabled("For development only")
@Test
@SuppressWarnings({"UnusedDeclaration"})
public void testGenerify() {

39
common/common-lang/src/test/java/com/twelvemonkeys/util/LRUMapTest.java
View File

@@ -45,11 +45,10 @@
package com.twelvemonkeys.util;
import org.junit.Test;
import java.util.*;
import static org.junit.Assert.assertTrue;
import org.junit.jupiter.api.*;
import static org.junit.jupiter.api.Assertions.*;
/**
* Tests LRUMap.
@@ -81,8 +80,8 @@ public class LRUMapTest extends LinkedMapTest {
map2.put(4,"foo"); // removes 1 since max size exceeded
map2.removeLRU(); // should be Integer(2)
assertTrue("Second to last value should exist",map2.get(new Integer(3)).equals("foo"));
assertTrue("First value inserted should not exist", map2.get(new Integer(1)) == null);
assertTrue(map2.get(new Integer(3)).equals("foo"), "Second to last value should exist");
assertTrue(map2.get(new Integer(1)) == null, "First value inserted should not exist");
}
@Test
@@ -93,8 +92,8 @@ public class LRUMapTest extends LinkedMapTest {
map2.put(3,"foo");
map2.put(4,"bar");
assertTrue("last value should exist",map2.get(new Integer(4)).equals("bar"));
assertTrue("LRU should not exist", map2.get(new Integer(1)) == null);
assertTrue(map2.get(new Integer(4)).equals("bar"), "last value should exist");
assertTrue(map2.get(new Integer(1)) == null, "LRU should not exist");
}
/**
@@ -113,10 +112,8 @@ public class LRUMapTest extends LinkedMapTest {
map2.putAll(hashMap);
assertTrue("max size is 3, but actual size is " + map2.size(),
map2.size() == 3);
assertTrue("map should contain the Integer(4) object",
map2.containsKey(new Integer(4)));
assertTrue(map2.size() == 3, "max size is 3, but actual size is " + map2.size());
assertTrue(map2.containsKey(new Integer(4)), "map should contain the Integer(4) object");
}
/**
@@ -134,8 +131,7 @@ public class LRUMapTest extends LinkedMapTest {
map.put("6","6");
map.setMaxSize(3);
assertTrue("map should have size = 3, but actually = " + map.size(),
map.size() == 3);
assertTrue(map.size() == 3, "map should have size = 3, but actually = " + map.size());
}
@Test
@@ -160,9 +156,9 @@ public class LRUMapTest extends LinkedMapTest {
keys[i] = keyIterator.next();
}
assertTrue("first evicted should be 3, was " + keys[0], keys[0].equals("3"));
assertTrue("second evicted should be 1, was " + keys[1], keys[1].equals("1"));
assertTrue("third evicted should be 4, was " + keys[2], keys[2].equals("4"));
assertTrue(keys[0].equals("3"), "first evicted should be 3, was " + keys[0]);
assertTrue(keys[1].equals("1"), "second evicted should be 1, was " + keys[1]);
assertTrue(keys[2].equals("4"), "third evicted should be 4, was " + keys[2]);
}
@@ -192,13 +188,12 @@ public class LRUMapTest extends LinkedMapTest {
// 4 2
counter.remove("5");
assertTrue("size should be 2, but was " + counter.size(), counter.size() == 2);
assertTrue("removedCount should be 3 but was " + counter.removedCount,
counter.removedCount == 3);
assertTrue(counter.size() == 2, "size should be 2, but was " + counter.size());
assertTrue(counter.removedCount == 3, "removedCount should be 3 but was " + counter.removedCount);
assertTrue("first removed was '2'",counter.list.get(0).equals("2"));
assertTrue("second removed was '3'",counter.list.get(1).equals("3"));
assertTrue("third removed was '1'",counter.list.get(2).equals("1"));
assertTrue(counter.list.get(0).equals("2"), "first removed was '2'");
assertTrue(counter.list.get(1).equals("3"), "second removed was '3'");
assertTrue(counter.list.get(2).equals("1"), "third removed was '1'");
//assertTrue("oldest key is '4'",counter.get(0).equals("4"));
//assertTrue("newest key is '2'",counter.get(1).equals("2"));

30
common/common-lang/src/test/java/com/twelvemonkeys/util/LinkedMapTest.java
View File

@@ -45,15 +45,11 @@
package com.twelvemonkeys.util;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import java.util.Iterator;
import java.util.Map;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import org.junit.jupiter.api.*;
import static org.junit.jupiter.api.Assertions.*;
/**
* Unit tests
@@ -74,7 +70,7 @@ public class LinkedMapTest extends MapAbstractTest {
*/
protected LinkedMap labRat;
@Before
@BeforeEach
public void setUp() throws Exception {
// use makeMap and cast the result to a SeqHashMap
// so that subclasses of SeqHashMap can share these tests
@@ -103,27 +99,21 @@ public class LinkedMapTest extends MapAbstractTest {
}
// Test size().
assertEquals("size() does not match expected size",
expectedSize, labRat.size());
assertEquals(expectedSize, labRat.size(), "size() does not match expected size");
// Test clone(), iterator(), and get(Object).
LinkedMap clone = (LinkedMap) labRat.clone();
assertEquals("Size of clone does not match original",
labRat.size(), clone.size());
assertEquals(labRat.size(), clone.size(), "Size of clone does not match original");
Iterator origEntries = labRat.entrySet().iterator();
Iterator copiedEntries = clone.entrySet().iterator();
while (origEntries.hasNext()) {
Map.Entry origEntry = (Map.Entry)origEntries.next();
Map.Entry copiedEntry = (Map.Entry)copiedEntries.next();
assertEquals("Cloned key does not match original",
origEntry.getKey(), copiedEntry.getKey());
assertEquals("Cloned value does not match original",
origEntry.getValue(), copiedEntry.getValue());
assertEquals("Cloned entry does not match original",
origEntry, copiedEntry);
assertEquals(origEntry.getKey(), copiedEntry.getKey(), "Cloned key does not match original");
assertEquals(origEntry.getValue(), copiedEntry.getValue(), "Cloned value does not match original");
assertEquals(origEntry, copiedEntry, "Cloned entry does not match original");
}
assertTrue("iterator() returned different number of elements than keys()",
!copiedEntries.hasNext());
assertTrue(!copiedEntries.hasNext(), "iterator() returned different number of elements than keys()");
// Test sequence()
/*
@@ -207,7 +197,7 @@ public class LinkedMapTest extends MapAbstractTest {
}
*/
@After
@AfterEach
public void tearDown() throws Exception {
labRat = null;
}

210
common/common-lang/src/test/java/com/twelvemonkeys/util/MapAbstractTest.java
View File

@@ -45,12 +45,10 @@
package com.twelvemonkeys.util;
import org.junit.After;
import org.junit.Test;
import java.util.*;
import static org.junit.Assert.*;
import org.junit.jupiter.api.*;
import static org.junit.jupiter.api.Assertions.*;
/**
* Abstract test class for {@link java.util.Map} methods and contracts.
@@ -390,19 +388,19 @@ public abstract class MapAbstractTest extends ObjectAbstractTest {
m.put(keys[i], values[i]);
}
catch (NullPointerException exception) {
assertTrue("NullPointerException only allowed to be thrown if either the key or value is null.",
keys[i] == null || values[i] == null);
assertTrue(keys[i] == null || values[i] == null,
"NullPointerException only allowed to be thrown if either the key or value is null.");
assertTrue("NullPointerException on null key, but isAllowNullKey is not overridden to return false.",
keys[i] == null || !isAllowNullKey());
assertTrue(keys[i] == null || !isAllowNullKey(),
"NullPointerException on null key, but isAllowNullKey is not overridden to return false.");
assertTrue("NullPointerException on null value, but isAllowNullValue is not overridden to return false.",
values[i] == null || !isAllowNullValue());
assertTrue(values[i] == null || !isAllowNullValue(),
"NullPointerException on null value, but isAllowNullValue is not overridden to return false.");
assertTrue("Unknown reason for NullPointer.", false);
fail("Unknown reason for NullPointer.");
}
}
assertEquals("size must reflect number of mappings added.", keys.length, m.size());
assertEquals(keys.length, m.size(), "size must reflect number of mappings added.");
}
//-----------------------------------------------------------------------
@@ -481,27 +479,26 @@ public abstract class MapAbstractTest extends ObjectAbstractTest {
Object[] values = getSampleValues();
Object[] newValues = getNewSampleValues();
assertTrue("failure in test: Must have keys returned from getSampleKeys.", keys != null);
assertTrue("failure in test: Must have values returned from getSampleValues.", values != null);
assertTrue(keys != null, "failure in test: Must have keys returned from getSampleKeys.");
assertTrue(values != null, "failure in test: Must have values returned from getSampleValues.");
// verify keys and values have equivalent lengths (in case getSampleX are
// overridden)
assertEquals("failure in test: not the same number of sample keys and values.", keys.length, values.length);
assertEquals("failure in test: not the same number of values and new values.", values.length, newValues.length);
assertEquals(keys.length, values.length, "failure in test: not the same number of sample keys and values.");
assertEquals(values.length, newValues.length, "failure in test: not the same number of values and new values.");
// verify there aren't duplicate keys, and check values
for (int i = 0; i < keys.length - 1; i++) {
for (int j = i + 1; j < keys.length; j++) {
assertTrue("failure in test: duplicate null keys.", (keys[i] != null || keys[j] != null));
assertTrue("failure in test: duplicate non-null key.",
(keys[i] == null || keys[j] == null || (!keys[i].equals(keys[j]) && !keys[j].equals(keys[i]))));
assertTrue((keys[i] != null || keys[j] != null), "failure in test: duplicate null keys.");
assertTrue((keys[i] == null || keys[j] == null || (!keys[i].equals(keys[j]) && !keys[j].equals(keys[i]))),
"failure in test: duplicate non-null key.");
}
assertTrue("failure in test: found null key, but isNullKeySupported is false.", keys[i] != null || isAllowNullKey());
assertTrue("failure in test: found null value, but isNullValueSupported is false.", values[i] != null || isAllowNullValue());
assertTrue("failure in test: found null new value, but isNullValueSupported is false.", newValues[i] != null || isAllowNullValue());
assertTrue("failure in test: values should not be the same as new value",
values[i] != newValues[i] && (values[i] == null || !values[i].equals(newValues[i])));
assertTrue(keys[i] != null || isAllowNullKey(),"failure in test: found null key, but isNullKeySupported is false.");
assertTrue(values[i] != null || isAllowNullValue(),"failure in test: found null value, but isNullValueSupported is false.");
assertTrue(newValues[i] != null || isAllowNullValue(), "failure in test: found null new value, but isNullValueSupported is false.");
assertTrue(values[i] != newValues[i] && (values[i] == null || !values[i].equals(newValues[i])), "failure in test: values should not be the same as new value");
}
}
@@ -517,18 +514,18 @@ public abstract class MapAbstractTest extends ObjectAbstractTest {
@Test
public void testMakeMap() {
Map em = makeEmptyMap();
assertTrue("failure in test: makeEmptyMap must return a non-null map.", em != null);
assertTrue(em != null, "failure in test: makeEmptyMap must return a non-null map.");
Map em2 = makeEmptyMap();
assertTrue("failure in test: makeEmptyMap must return a non-null map.", em2 != null);
assertTrue("failure in test: makeEmptyMap must return a new map with each invocation.", em != em2);
assertTrue(em2 != null, "failure in test: makeEmptyMap must return a non-null map.");
assertTrue(em != em2, "failure in test: makeEmptyMap must return a new map with each invocation.");
Map fm = makeFullMap();
assertTrue("failure in test: makeFullMap must return a non-null map.", fm != null);
assertTrue(fm != null, "failure in test: makeFullMap must return a non-null map.");
Map fm2 = makeFullMap();
assertTrue("failure in test: makeFullMap must return a non-null map.", fm2 != null);
assertTrue("failure in test: makeFullMap must return a new map with each invocation.", fm != fm2);
assertTrue(fm2 != null, "failure in test: makeFullMap must return a non-null map.");
assertTrue(fm != fm2, "failure in test: makeFullMap must return a new map with each invocation.");
}
/**
@@ -537,11 +534,11 @@ public abstract class MapAbstractTest extends ObjectAbstractTest {
@Test
public void testMapIsEmpty() {
resetEmpty();
assertEquals("Map.isEmpty() should return true with an empty map", true, map.isEmpty());
assertEquals(true, map.isEmpty(), "Map.isEmpty() should return true with an empty map");
verifyAll();
resetFull();
assertEquals("Map.isEmpty() should return false with a non-empty map", false, map.isEmpty());
assertEquals(false, map.isEmpty(), "Map.isEmpty() should return false with a non-empty map");
verifyAll();
}
@@ -551,11 +548,11 @@ public abstract class MapAbstractTest extends ObjectAbstractTest {
@Test
public void testMapSize() {
resetEmpty();
assertEquals("Map.size() should be 0 with an empty map", 0, map.size());
assertEquals(0, map.size(), "Map.size() should be 0 with an empty map");
verifyAll();
resetFull();
assertEquals("Map.size() should equal the number of entries in the map", getSampleKeys().length, map.size());
assertEquals(getSampleKeys().length, map.size(), "Map.size() should equal the number of entries in the map");
verifyAll();
}
@@ -602,13 +599,13 @@ public abstract class MapAbstractTest extends ObjectAbstractTest {
resetEmpty();
for (Object key : keys) {
assertTrue("Map must not contain key when map is empty", !map.containsKey(key));
assertTrue(!map.containsKey(key), "Map must not contain key when map is empty");
}
verifyAll();
resetFull();
for (Object key : keys) {
assertTrue("Map must contain key for a mapping in the map. Missing: " + key, map.containsKey(key));
assertTrue(map.containsKey(key), "Map must contain key for a mapping in the map. Missing: " + key);
}
verifyAll();
}
@@ -624,13 +621,13 @@ public abstract class MapAbstractTest extends ObjectAbstractTest {
resetEmpty();
for (Object value : values) {
assertTrue("Empty map must not contain value", !map.containsValue(value));
assertTrue(!map.containsValue(value), "Empty map must not contain value");
}
verifyAll();
resetFull();
for (Object value : values) {
assertTrue("Map must contain value for a mapping in the map.", map.containsValue(value));
assertTrue(map.containsValue(value), "Map must contain value for a mapping in the map.");
}
verifyAll();
}
@@ -641,11 +638,11 @@ public abstract class MapAbstractTest extends ObjectAbstractTest {
@Test
public void testMapEquals() {
resetEmpty();
assertTrue("Empty maps unequal.", map.equals(confirmed));
assertTrue(map.equals(confirmed), "Empty maps unequal.");
verifyAll();
resetFull();
assertTrue("Full maps unequal.", map.equals(confirmed));
assertTrue(map.equals(confirmed), "Full maps unequal.");
verifyAll();
resetFull();
@@ -654,11 +651,11 @@ public abstract class MapAbstractTest extends ObjectAbstractTest {
Iterator iter = confirmed.keySet().iterator();
iter.next();
iter.remove();
assertTrue("Different maps equal.", !map.equals(confirmed));
assertTrue(!map.equals(confirmed), "Different maps equal.");
resetFull();
assertTrue("equals(null) returned true.", !map.equals(null));
assertTrue("equals(new Object()) returned true.", !map.equals(new Object()));
assertTrue(!map.equals(null), "equals(null) returned true.");
assertTrue(!map.equals(new Object()), "equals(new Object()) returned true.");
verifyAll();
}
@@ -673,14 +670,14 @@ public abstract class MapAbstractTest extends ObjectAbstractTest {
Object[] values = getSampleValues();
for (Object key : keys) {
assertTrue("Empty map.get() should return null.", map.get(key) == null);
assertTrue(map.get(key) == null, "Empty map.get() should return null.");
}
verifyAll();
resetFull();
for (int i = 0; i < keys.length; i++) {
assertEquals("Full map.get() should return value from mapping.", values[i], map.get(keys[i]));
assertEquals(values[i], map.get(keys[i]), "Full map.get() should return value from mapping.");
}
}
@@ -690,10 +687,10 @@ public abstract class MapAbstractTest extends ObjectAbstractTest {
@Test
public void testMapHashCode() {
resetEmpty();
assertTrue("Empty maps have different hashCodes.", map.hashCode() == confirmed.hashCode());
assertTrue(map.hashCode() == confirmed.hashCode(), "Empty maps have different hashCodes.");
resetFull();
assertTrue("Equal maps have different hashCodes.", map.hashCode() == confirmed.hashCode());
assertTrue(map.hashCode() == confirmed.hashCode(), "Equal maps have different hashCodes.");
}
/**
@@ -708,11 +705,11 @@ public abstract class MapAbstractTest extends ObjectAbstractTest {
@Test
public void testMapToString() {
resetEmpty();
assertTrue("Empty map toString() should not return null", map.toString() != null);
assertTrue(map.toString() != null, "Empty map toString() should not return null");
verifyAll();
resetFull();
assertTrue("Empty map toString() should not return null", map.toString() != null);
assertTrue(map.toString() != null, "Empty map toString() should not return null");
verifyAll();
}
@@ -776,29 +773,23 @@ public abstract class MapAbstractTest extends ObjectAbstractTest {
Object o = map.put(keys[i], values[i]);
confirmed.put(keys[i], values[i]);
verifyAll();
assertTrue("First map.put should return null", o == null);
assertTrue("Map should contain key after put",
map.containsKey(keys[i]));
assertTrue("Map should contain value after put",
map.containsValue(values[i]));
assertTrue(o == null, "First map.put should return null");
assertTrue(map.containsKey(keys[i]), "Map should contain key after put");
assertTrue(map.containsValue(values[i]), "Map should contain value after put");
}
if (isPutChangeSupported()) {
for (int i = 0; i < keys.length; i++) {
Object o = map.put(keys[i], newValues[i]);
confirmed.put(keys[i], newValues[i]);
verifyAll();
assertEquals("Map.put should return previous value when changed",
values[i], o);
assertTrue("Map should still contain key after put when changed",
map.containsKey(keys[i]));
assertTrue("Map should contain new value after put when changed",
map.containsValue(newValues[i]));
assertEquals(values[i], o, "Map.put should return previous value when changed");
assertTrue(map.containsKey(keys[i]), "Map should still contain key after put when changed");
assertTrue(map.containsValue(newValues[i]), "Map should contain new value after put when changed");
// if duplicates are allowed, we're not guaranteed that the value
// no longer exists, so don't try checking that.
if (!isAllowDuplicateValues()) {
assertTrue("Map should not contain old value after put when changed",
!map.containsValue(values[i]));
assertTrue(!map.containsValue(values[i]), "Map should not contain old value after put when changed");
}
}
}
@@ -832,18 +823,14 @@ public abstract class MapAbstractTest extends ObjectAbstractTest {
Object o = map.put(key, newValues[i]);
Object value = confirmed.put(key, newValues[i]);
verifyAll();
assertEquals("Map.put should return previous value when changed",
value, o);
assertTrue("Map should still contain key after put when changed",
map.containsKey(key));
assertTrue("Map should contain new value after put when changed",
map.containsValue(newValues[i]));
assertEquals(value, o, "Map.put should return previous value when changed");
assertTrue(map.containsKey(key), "Map should still contain key after put when changed");
assertTrue(map.containsValue(newValues[i]), "Map should contain new value after put when changed");
// if duplicates are allowed, we're not guaranteed that the value
// no longer exists, so don't try checking that.
if (!isAllowDuplicateValues()) {
assertTrue("Map should not contain old value after put when changed",
!map.containsValue(values[i]));
assertTrue(!map.containsValue(values[i]), "Map should not contain old value after put when changed");
}
}
}
@@ -970,7 +957,7 @@ public abstract class MapAbstractTest extends ObjectAbstractTest {
Object[] values = getSampleValues();
for (int i = 0; i < keys.length; i++) {
Object o = map.remove(keys[i]);
assertTrue("First map.remove should return null", o == null);
assertTrue(o == null, "First map.remove should return null");
}
verifyAll();
@@ -981,8 +968,7 @@ public abstract class MapAbstractTest extends ObjectAbstractTest {
confirmed.remove(keys[i]);
verifyAll();
assertEquals("map.remove with valid key should return value",
values[i], o);
assertEquals(values[i], o, "map.remove with valid key should return value");
}
Object[] other = getOtherKeys();
@@ -991,10 +977,8 @@ public abstract class MapAbstractTest extends ObjectAbstractTest {
int size = map.size();
for (int i = 0; i < other.length; i++) {
Object o = map.remove(other[i]);
assertEquals("map.remove for nonexistent key should return null",
o, null);
assertEquals("map.remove for nonexistent key should not " +
"shrink map", size, map.size());
assertEquals(o, null, "map.remove for nonexistent key should return null");
assertEquals(size, map.size(), "map.remove for nonexistent key should not shrink map");
}
verifyAll();
}
@@ -1204,10 +1188,9 @@ public abstract class MapAbstractTest extends ObjectAbstractTest {
}
j++;
}
assertTrue("values().remove(obj) is broken", j < 10000);
assertTrue(
"Value should have been removed from the underlying map.",
!map.containsValue(sampleValues[i]));
assertTrue(j < 10000, "values().remove(obj) is broken");
assertTrue(!map.containsValue(sampleValues[i]),
"Value should have been removed from the underlying map.");
}
}
}
@@ -1230,9 +1213,8 @@ public abstract class MapAbstractTest extends ObjectAbstractTest {
// if key.remove is unsupported, just skip this test
return;
}
assertTrue(
"Key should have been removed from the underlying map.",
!map.containsKey(sampleKeys[i]));
assertTrue(!map.containsKey(sampleKeys[i]),
"Key should have been removed from the underlying map.");
}
}
@@ -1413,7 +1395,7 @@ public abstract class MapAbstractTest extends ObjectAbstractTest {
break;
}
}
assertNotNull("No matching entry in map for key '" + key + "'", entry);
assertNotNull(entry, "No matching entry in map for key '" + key + "'");
return entry;
}
@@ -1638,14 +1620,14 @@ public abstract class MapAbstractTest extends ObjectAbstractTest {
public void verifyMap() {
int size = confirmed.size();
boolean empty = confirmed.isEmpty();
assertEquals("Map should be same size as HashMap", size, map.size());
assertEquals("Map should be empty if HashMap is", empty, map.isEmpty());
assertEquals("hashCodes should be the same", confirmed.hashCode(), map.hashCode());
assertEquals(size, map.size(), "Map should be same size as HashMap");
assertEquals(empty, map.isEmpty(), "Map should be empty if HashMap is");
assertEquals(confirmed.hashCode(), map.hashCode(), "hashCodes should be the same");
// this fails for LRUMap because confirmed.equals() somehow modifies
// map, causing concurrent modification exceptions.
//assertEquals("Map should still equal HashMap", confirmed, map);
// this works though and performs the same verification:
assertTrue("Map should still equal HashMap", map.equals(confirmed));
assertTrue(map.equals(confirmed), "Map should still equal HashMap");
// TODO: this should really be reexamined to figure out why LRU map
// behaves like it does (the equals shouldn't modify since all accesses
// by the confirmed collection should be through an iterator, thus not
@@ -1655,29 +1637,29 @@ public abstract class MapAbstractTest extends ObjectAbstractTest {
public void verifyEntrySet() {
int size = confirmed.size();
boolean empty = confirmed.isEmpty();
assertEquals("entrySet should be same size as HashMap's\nTest: " + entrySet + "\nReal: " + confirmed.entrySet(),
size, entrySet.size());
assertEquals("entrySet should be empty if HashMap is\nTest: " + entrySet + "\nReal: " + confirmed.entrySet(),
empty, entrySet.isEmpty());
assertTrue("entrySet should contain all HashMap's elements\nTest: " + entrySet + "\nReal: " + confirmed.entrySet(),
entrySet.containsAll(confirmed.entrySet()));
assertEquals("entrySet hashCodes should be the same\nTest: " + entrySet + "\nReal: " + confirmed.entrySet(),
confirmed.entrySet().hashCode(), entrySet.hashCode());
assertEquals("Map's entry set should still equal HashMap's", confirmed.entrySet(), entrySet);
assertEquals(size, entrySet.size(),
"entrySet should be same size as HashMap's\nTest: " + entrySet + "\nReal: " + confirmed.entrySet());
assertEquals(empty, entrySet.isEmpty(),
"entrySet should be empty if HashMap is\nTest: " + entrySet + "\nReal: " + confirmed.entrySet());
assertTrue(entrySet.containsAll(confirmed.entrySet()),
"entrySet should contain all HashMap's elements\nTest: " + entrySet + "\nReal: " + confirmed.entrySet());
assertEquals(confirmed.entrySet().hashCode(), entrySet.hashCode(),
"entrySet hashCodes should be the same\nTest: " + entrySet + "\nReal: " + confirmed.entrySet());
assertEquals(confirmed.entrySet(), entrySet,"Map's entry set should still equal HashMap's");
}
public void verifyKeySet() {
int size = confirmed.size();
boolean empty = confirmed.isEmpty();
assertEquals("keySet should be same size as HashMap's\nTest: " + keySet + "\nReal: " + confirmed.keySet(),
size, keySet.size());
assertEquals("keySet should be empty if HashMap is\nTest: " + keySet + "\nReal: " + confirmed.keySet(),
empty, keySet.isEmpty());
assertTrue("keySet should contain all HashMap's elements\nTest: " + keySet + "\nReal: " + confirmed.keySet(),
keySet.containsAll(confirmed.keySet()));
assertEquals("keySet hashCodes should be the same\nTest: " + keySet + "\nReal: " + confirmed.keySet(),
confirmed.keySet().hashCode(), keySet.hashCode());
assertEquals("Map's key set should still equal HashMap's", confirmed.keySet(), keySet);
assertEquals(size, keySet.size(),
"keySet should be same size as HashMap's\nTest: " + keySet + "\nReal: " + confirmed.keySet());
assertEquals(empty, keySet.isEmpty(),
"keySet should be empty if HashMap is\nTest: " + keySet + "\nReal: " + confirmed.keySet());
assertTrue(keySet.containsAll(confirmed.keySet()),
"keySet should contain all HashMap's elements\nTest: " + keySet + "\nReal: " + confirmed.keySet());
assertEquals(confirmed.keySet().hashCode(), keySet.hashCode(),
"keySet hashCodes should be the same\nTest: " + keySet + "\nReal: " + confirmed.keySet());
assertEquals(confirmed.keySet(), keySet, "Map's key set should still equal HashMap's");
}
public void verifyValues() {
@@ -1687,23 +1669,23 @@ public abstract class MapAbstractTest extends ObjectAbstractTest {
int size = confirmed.size();
boolean empty = confirmed.isEmpty();
assertEquals("values should be same size as HashMap's\nTest: " + test + "\nReal: " + known, size, values.size());
assertEquals("values should be empty if HashMap is\nTest: " + test + "\nReal: " + known, empty, values.isEmpty());
assertTrue("values should contain all HashMap's elements\nTest: " + test + "\nReal: " + known, test.containsAll(known));
assertTrue("values should contain all HashMap's elements\nTest: " + test + "\nReal: " + known, known.containsAll(test));
assertEquals(size, values.size(), "values should be same size as HashMap's\nTest: " + test + "\nReal: " + known);
assertEquals(empty, values.isEmpty(), "values should be empty if HashMap is\nTest: " + test + "\nReal: " + known);
assertTrue(test.containsAll(known), "values should contain all HashMap's elements\nTest: " + test + "\nReal: " + known);
assertTrue(known.containsAll(test), "values should contain all HashMap's elements\nTest: " + test + "\nReal: " + known);
for (Object aKnown : known) {
boolean removed = test.remove(aKnown);
assertTrue("Map's values should still equal HashMap's", removed);
assertTrue(removed, "Map's values should still equal HashMap's");
}
assertTrue("Map's values should still equal HashMap's", test.isEmpty());
assertTrue(test.isEmpty(), "Map's values should still equal HashMap's");
}
/**
* Erases any leftover instance variables by setting them to null.
*/
@After
@AfterEach
public void tearDown() throws Exception {
map = null;
keySet = null;

41
common/common-lang/src/test/java/com/twelvemonkeys/util/NullMapTest.java
View File

@@ -30,13 +30,11 @@
package com.twelvemonkeys.util;
import org.junit.Test;
import java.util.HashMap;
import java.util.Map;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import org.junit.jupiter.api.*;
import static org.junit.jupiter.api.Assertions.*;
/**
* NOTE: This TestCase is written especially for NullMap, and is full of dirty
@@ -83,12 +81,12 @@ public class NullMapTest extends MapAbstractTest {
@Override
public void testMapIsEmpty() {
resetEmpty();
assertEquals("Map.isEmpty() should return true with an empty map",
true, map.isEmpty());
assertEquals(true, map.isEmpty(),
"Map.isEmpty() should return true with an empty map");
verifyAll();
resetFull();
assertEquals("Map.isEmpty() should return true with a full map",
true, map.isEmpty());
assertEquals(true, map.isEmpty(),
"Map.isEmpty() should return true with a full map");
}
// Overriden, as this map is always empty
@@ -96,13 +94,13 @@ public class NullMapTest extends MapAbstractTest {
@Override
public void testMapSize() {
resetEmpty();
assertEquals("Map.size() should be 0 with an empty map",
0, map.size());
assertEquals(0, map.size(),
"Map.size() should be 0 with an empty map");
verifyAll();
resetFull();
assertEquals("Map.size() should equal the number of entries " +
"in the map", 0, map.size());
assertEquals(0, map.size(),
"Map.size() should equal the number of entries in the map");
}
@Test
@@ -112,7 +110,7 @@ public class NullMapTest extends MapAbstractTest {
resetEmpty();
for (Object key : keys) {
assertTrue("Map must not contain key when map is empty", !map.containsKey(key));
assertTrue(!map.containsKey(key),"Map must not contain key when map is empty");
}
verifyAll();
}
@@ -124,7 +122,7 @@ public class NullMapTest extends MapAbstractTest {
resetEmpty();
for (Object value : values) {
assertTrue("Empty map must not contain value", !map.containsValue(value));
assertTrue(!map.containsValue(value), "Empty map must not contain value");
}
verifyAll();
}
@@ -133,7 +131,7 @@ public class NullMapTest extends MapAbstractTest {
@Override
public void testMapEquals() {
resetEmpty();
assertTrue("Empty maps unequal.", map.equals(confirmed));
assertTrue(map.equals(confirmed), "Empty maps unequal.");
verifyAll();
}
@@ -141,8 +139,7 @@ public class NullMapTest extends MapAbstractTest {
@Override
public void testMapHashCode() {
resetEmpty();
assertTrue("Empty maps have different hashCodes.",
map.hashCode() == confirmed.hashCode());
assertTrue(map.hashCode() == confirmed.hashCode(), "Empty maps have different hashCodes.");
}
@Test
@@ -153,7 +150,7 @@ public class NullMapTest extends MapAbstractTest {
Object[] keys = getSampleKeys();
for (Object key : keys) {
assertTrue("Empty map.get() should return null.", map.get(key) == null);
assertTrue(map.get(key) == null, "Empty map.get() should return null.");
}
verifyAll();
}
@@ -170,7 +167,7 @@ public class NullMapTest extends MapAbstractTest {
Object o = map.put(keys[i], values[i]);
//confirmed.put(keys[i], values[i]);
verifyAll();
assertTrue("First map.put should return null", o == null);
assertTrue(o == null, "First map.put should return null");
}
for (int i = 0; i < keys.length; i++) {
map.put(keys[i], newValues[i]);
@@ -183,8 +180,8 @@ public class NullMapTest extends MapAbstractTest {
@Override
public void testMapToString() {
resetEmpty();
assertTrue("Empty map toString() should not return null",
map.toString() != null);
assertTrue(map.toString() != null,
"Empty map toString() should not return null");
verifyAll();
}
@@ -202,7 +199,7 @@ public class NullMapTest extends MapAbstractTest {
Object[] keys = getSampleKeys();
for(int i = 0; i < keys.length; i++) {
Object o = map.remove(keys[i]);
assertTrue("First map.remove should return null", o == null);
assertTrue(o == null, "First map.remove should return null");
}
verifyAll();
}

33
common/common-lang/src/test/java/com/twelvemonkeys/util/ObjectAbstractTest.java
View File

@@ -44,12 +44,10 @@
*/
package com.twelvemonkeys.util;
import org.junit.Test;
import java.io.*;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import org.junit.jupiter.api.*;
import static org.junit.jupiter.api.Assertions.*;
/**
* Abstract test class for {@link Object} methods and contracts.
@@ -119,7 +117,7 @@ public abstract class ObjectAbstractTest {
@Test
public void testObjectEqualsSelf() {
Object obj = makeObject();
assertEquals("A Object should equal itself", obj, obj);
assertEquals(obj, obj, "A Object should equal itself");
}
@Test
@@ -131,25 +129,24 @@ public abstract class ObjectAbstractTest {
@Test
public void testObjectHashCodeEqualsSelfHashCode() {
Object obj = makeObject();
assertEquals("hashCode should be repeatable", obj.hashCode(), obj.hashCode());
assertEquals(obj.hashCode(), obj.hashCode(), "hashCode should be repeatable");
}
@Test
public void testObjectHashCodeEqualsContract() {
Object obj1 = makeObject();
if (obj1.equals(obj1)) {
assertEquals(
"[1] When two objects are equal, their hashCodes should be also.",
obj1.hashCode(), obj1.hashCode());
assertEquals(obj1.hashCode(), obj1.hashCode(),
"[1] When two objects are equal, their hashCodes should be also.");
}
Object obj2 = makeObject();
if (obj1.equals(obj2)) {
assertEquals(
"[2] When two objects are equal, their hashCodes should be also.",
obj1.hashCode(), obj2.hashCode());
obj1.hashCode(), obj2.hashCode(),
"[2] When two objects are equal, their hashCodes should be also.");
assertTrue(
"When obj1.equals(obj2) is true, then obj2.equals(obj1) should also be true",
obj2.equals(obj1));
obj2.equals(obj1),
"When obj1.equals(obj2) is true, then obj2.equals(obj1) should also be true");
}
}
@@ -166,7 +163,7 @@ public abstract class ObjectAbstractTest {
Object dest = in.readObject();
in.close();
if (isEqualsCheckable()) {
assertEquals("obj != deserialize(serialize(obj))", obj, dest);
assertEquals(obj, dest, "obj != deserialize(serialize(obj))");
}
}
}
@@ -199,8 +196,8 @@ public abstract class ObjectAbstractTest {
if (object instanceof Serializable) {
String name = getCanonicalEmptyCollectionName(object);
assertTrue(
"Canonical empty collection (" + name + ") is not in CVS",
new File(name).exists());
new File(name).exists(),
"Canonical empty collection (" + name + ") is not in CVS");
}
}
}
@@ -216,8 +213,8 @@ public abstract class ObjectAbstractTest {
if (object instanceof Serializable) {
String name = getCanonicalFullCollectionName(object);
assertTrue(
"Canonical full collection (" + name + ") is not in CVS",
new File(name).exists());
new File(name).exists(),
"Canonical full collection (" + name + ") is not in CVS");
}
}
}

31
common/common-lang/src/test/java/com/twelvemonkeys/util/SetAbstractTest.java
View File

@@ -44,12 +44,10 @@
*/
package com.twelvemonkeys.util;
import org.junit.Test;
import java.util.*;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import org.junit.jupiter.api.*;
import static org.junit.jupiter.api.Assertions.*;
/**
* Abstract test class for {@link Set} methods and contracts.
@@ -79,14 +77,12 @@ public abstract class SetAbstractTest extends CollectionAbstractTest {
public void verifyAll() {
super.verifyAll();
assertEquals("Sets should be equal", confirmed, collection);
assertEquals("Sets should have equal hashCodes",
confirmed.hashCode(), collection.hashCode());
assertEquals(confirmed, collection, "Sets should be equal");
assertEquals(confirmed.hashCode(), collection.hashCode(), "Sets should have equal hashCodes");
Collection set = makeConfirmedCollection();
Iterator iterator = collection.iterator();
while (iterator.hasNext()) {
assertTrue("Set.iterator should only return unique elements",
set.add(iterator.next()));
assertTrue(set.add(iterator.next()), "Set.iterator should only return unique elements");
}
}
@@ -180,23 +176,20 @@ public abstract class SetAbstractTest extends CollectionAbstractTest {
@Test
public void testSetEquals() {
resetEmpty();
assertEquals("Empty sets should be equal",
getSet(), getConfirmedSet());
assertEquals(getSet(), getConfirmedSet(), "Empty sets should be equal");
verifyAll();
Collection set2 = makeConfirmedCollection();
set2.add("foo");
assertTrue("Empty set shouldn't equal nonempty set",
!getSet().equals(set2));
assertTrue(!getSet().equals(set2), "Empty set shouldn't equal nonempty set");
resetFull();
assertEquals("Full sets should be equal", getSet(), getConfirmedSet());
assertEquals(getSet(), getConfirmedSet(), "Full sets should be equal");
verifyAll();
set2.clear();
set2.addAll(Arrays.asList(getOtherElements()));
assertTrue("Sets with different contents shouldn't be equal",
!getSet().equals(set2));
assertTrue(!getSet().equals(set2), "Sets with different contents shouldn't be equal");
}
/**
@@ -205,11 +198,9 @@ public abstract class SetAbstractTest extends CollectionAbstractTest {
@Test
public void testSetHashCode() {
resetEmpty();
assertEquals("Empty sets have equal hashCodes",
getSet().hashCode(), getConfirmedSet().hashCode());
assertEquals(getSet().hashCode(), getConfirmedSet().hashCode(), "Empty sets have equal hashCodes");
resetFull();
assertEquals("Equal sets have equal hashCodes",
getSet().hashCode(), getConfirmedSet().hashCode());
assertEquals(getSet().hashCode(), getConfirmedSet().hashCode(), "Equal sets have equal hashCodes");
}
}

62
common/common-lang/src/test/java/com/twelvemonkeys/util/StringTokenIteratorTest.java
View File

@@ -30,12 +30,10 @@
package com.twelvemonkeys.util;
import org.junit.Test;
import java.util.Iterator;
import static org.junit.Assert.*;
import org.junit.jupiter.api.*;
import static org.junit.jupiter.api.Assertions.*;
/**
* StringTokenIteratorTestCase
@@ -56,88 +54,88 @@ public class StringTokenIteratorTest extends TokenIteratorAbstractTest {
@Test
public void testEmptyDelimiter() {
Iterator iterator = createTokenIterator("", "");
assertFalse("Empty string has elements", iterator.hasNext());
assertFalse(iterator.hasNext(), "Empty string has elements");
}
@Test
public void testSingleToken() {
Iterator iterator = createTokenIterator("A");
assertTrue("String has no elements", iterator.hasNext());
assertTrue(iterator.hasNext(), "String has no elements");
assertEquals("A", iterator.next());
assertFalse("String has more than one element", iterator.hasNext());
assertFalse(iterator.hasNext(), "String has more than one element");
}
@Test
public void testSingleTokenEmptyDelimiter() {
Iterator iterator = createTokenIterator("A", "");
assertTrue("String has no elements", iterator.hasNext());
assertTrue(iterator.hasNext(), "String has no elements");
assertEquals("A", iterator.next());
assertFalse("String has more than one element", iterator.hasNext());
assertFalse(iterator.hasNext(), "String has more than one element");
}
@Test
public void testSingleTokenSingleDelimiter() {
Iterator iterator = createTokenIterator("A", ",");
assertTrue("String has no elements", iterator.hasNext());
assertTrue(iterator.hasNext(), "String has no elements");
assertEquals("A", iterator.next());
assertFalse("String has more than one element", iterator.hasNext());
assertFalse(iterator.hasNext(), "String has more than one element");
}
@Test
public void testSingleSeparatorDefaultDelimiter() {
Iterator iterator = createTokenIterator("A B C D");
assertTrue("String has no elements", iterator.hasNext());
assertTrue(iterator.hasNext(), "String has no elements");
assertEquals("A", iterator.next());
assertTrue("String has no elements", iterator.hasNext());
assertTrue(iterator.hasNext(), "String has no elements");
assertEquals("B", iterator.next());
assertTrue("String has no elements", iterator.hasNext());
assertTrue(iterator.hasNext(), "String has no elements");
assertEquals("C", iterator.next());
assertTrue("String has no elements", iterator.hasNext());
assertTrue(iterator.hasNext(), "String has no elements");
assertEquals("D", iterator.next());
assertFalse("String has more than one element", iterator.hasNext());
assertFalse(iterator.hasNext(), "String has more than one element");
}
@Test
public void testSingleSeparator() {
Iterator iterator = createTokenIterator("A,B,C", ",");
assertTrue("String has no elements", iterator.hasNext());
assertTrue(iterator.hasNext(), "String has no elements");
assertEquals("A", iterator.next());
assertTrue("String has no elements", iterator.hasNext());
assertTrue(iterator.hasNext(), "String has no elements");
assertEquals("B", iterator.next());
assertTrue("String has no elements", iterator.hasNext());
assertTrue(iterator.hasNext(), "String has no elements");
assertEquals("C", iterator.next());
assertFalse("String has more than one element", iterator.hasNext());
assertFalse(iterator.hasNext(), "String has more than one element");
}
@Test
public void testMultipleSeparatorDefaultDelimiter() {
Iterator iterator = createTokenIterator("A B C\nD\t\t \nE");
assertTrue("String has no elements", iterator.hasNext());
assertTrue(iterator.hasNext(), "String has no elements");
assertEquals("A", iterator.next());
assertTrue("String has no elements", iterator.hasNext());
assertTrue(iterator.hasNext(), "String has no elements");
assertEquals("B", iterator.next());
assertTrue("String has no elements", iterator.hasNext());
assertTrue(iterator.hasNext(), "String has no elements");
assertEquals("C", iterator.next());
assertTrue("String has no elements", iterator.hasNext());
assertTrue(iterator.hasNext(), "String has no elements");
assertEquals("D", iterator.next());
assertTrue("String has no elements", iterator.hasNext());
assertTrue(iterator.hasNext(), "String has no elements");
assertEquals("E", iterator.next());
assertFalse("String has more than one element", iterator.hasNext());
assertFalse(iterator.hasNext(), "String has more than one element");
}
@Test
public void testMultipleSeparator() {
Iterator iterator = createTokenIterator("A,B,;,C...D, ., ,E", " ,.;:");
assertTrue("String has no elements", iterator.hasNext());
assertTrue(iterator.hasNext(), "String has no elements");
assertEquals("A", iterator.next());
assertTrue("String has no elements", iterator.hasNext());
assertTrue(iterator.hasNext(), "String has no elements");
assertEquals("B", iterator.next());
assertTrue("String has no elements", iterator.hasNext());
assertTrue(iterator.hasNext(), "String has no elements");
assertEquals("C", iterator.next());
assertTrue("String has no elements", iterator.hasNext());
assertTrue(iterator.hasNext(), "String has no elements");
assertEquals("D", iterator.next());
assertTrue("String has no elements", iterator.hasNext());
assertTrue(iterator.hasNext(), "String has no elements");
assertEquals("E", iterator.next());
assertFalse("String has more than one element", iterator.hasNext());
assertFalse(iterator.hasNext(), "String has more than one element");
}
}

18
common/common-lang/src/test/java/com/twelvemonkeys/util/TimeoutMapTest.java
View File

@@ -30,12 +30,10 @@
package com.twelvemonkeys.util;
import org.junit.Test;
import java.util.*;
import static org.junit.Assert.*;
import org.junit.jupiter.api.*;
import static org.junit.jupiter.api.Assertions.*;
/**
* TimeoutMapTest
* <p/>
@@ -541,7 +539,7 @@ public class TimeoutMapTest extends MapAbstractTest {
}
}
assertTrue("Elements expired too early, test did not run as expected.", count > 0);
assertTrue(count > 0, "Elements expired too early, test did not run as expected.");
//assertEquals("Elements did not expire as expected.", 1, count);
}
@@ -573,7 +571,7 @@ public class TimeoutMapTest extends MapAbstractTest {
}
}
assertTrue("Elements expired too early, test did not run as expected.", count > 0);
assertTrue(count > 0, "Elements expired too early, test did not run as expected.");
//assertEquals("Elements did not expire as expected.", 1, count);
}
@@ -613,7 +611,7 @@ public class TimeoutMapTest extends MapAbstractTest {
}
}
assertTrue("Elements expired too early, test did not run as expected.", count > 0);
assertTrue(count > 0, "Elements expired too early, test did not run as expected.");
//assertEquals("Elements did not expire as expected.", 1, count);
}
@@ -630,7 +628,7 @@ public class TimeoutMapTest extends MapAbstractTest {
Object removedKey = null;
Object otherKey = null;
Iterator iterator = map.entrySet().iterator();
assertTrue("Iterator was empty", iterator.hasNext());
assertTrue(iterator.hasNext(), "Iterator was empty");
try {
Map.Entry entry = (Map.Entry) iterator.next();
assertNotNull(entry);
@@ -648,8 +646,8 @@ public class TimeoutMapTest extends MapAbstractTest {
fail("Elements expired between Interator.hasNext() and Iterator.remove()");
}
assertTrue("Wrong entry removed, keySet().iterator() is broken.", !map.containsKey(removedKey));
assertTrue("Wrong entry removed, keySet().iterator() is broken.", map.containsKey(otherKey));
assertTrue(!map.containsKey(removedKey), "Wrong entry removed, keySet().iterator() is broken.");
assertTrue(map.containsKey(otherKey), "Wrong entry removed, keySet().iterator() is broken.");
}

8
common/common-lang/src/test/java/com/twelvemonkeys/util/TokenIteratorAbstractTest.java
View File

@@ -30,12 +30,10 @@
package com.twelvemonkeys.util;
import org.junit.Test;
import java.util.Iterator;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.fail;
import org.junit.jupiter.api.*;
import static org.junit.jupiter.api.Assertions.*;
/**
* TokenIteratorAbstractTestCase
@@ -80,7 +78,7 @@ public abstract class TokenIteratorAbstractTest {
@Test
public void testEmptyString() {
Iterator iterator = createTokenIterator("");
assertFalse("Empty string has elements", iterator.hasNext());
assertFalse(iterator.hasNext(), "Empty string has elements");
}
}

6
common/common-lang/src/test/java/com/twelvemonkeys/util/convert/ConverterTest.java
View File

@@ -30,8 +30,8 @@
package com.twelvemonkeys.util.convert;
import org.junit.Ignore;
import org.junit.Test;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
/**
* ConverterTest
@@ -43,7 +43,7 @@ import org.junit.Test;
*/
public class ConverterTest {
@Ignore("Not implemented")
@Disabled("Not implemented")
@Test
public void testMe() {
// TODO: Implement tests

2
common/common-lang/src/test/java/com/twelvemonkeys/util/convert/DateConverterTest.java
View File

@@ -31,7 +31,7 @@
package com.twelvemonkeys.util.convert;
import com.twelvemonkeys.lang.DateUtil;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import java.text.DateFormat;
import java.util.Date;

8
common/common-lang/src/test/java/com/twelvemonkeys/util/convert/DefaultConverterTest.java
View File

@@ -31,13 +31,13 @@
package com.twelvemonkeys.util.convert;
import com.twelvemonkeys.lang.Validate;
import org.junit.Ignore;
import org.junit.Test;
import java.io.File;
import java.net.URI;
import static org.junit.Assert.*;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;
/**
* DefaultConverterTest
@@ -138,7 +138,7 @@ public class DefaultConverterTest extends PropertyConverterAbstractTest {
assertEquals(-2.3456, (Double) converter.toObject("-2.3456", Double.TYPE, null), 0);
}
@Ignore("Known issue. Why would anyone do something like this?")
@Disabled("Known issue. Why would anyone do something like this?")
@Test
public void testConvertCharPrimitive() {
PropertyConverter converter = makePropertyConverter();

32
common/common-lang/src/test/java/com/twelvemonkeys/util/convert/PropertyConverterAbstractTest.java
View File

@@ -32,11 +32,11 @@ package com.twelvemonkeys.util.convert;
import com.twelvemonkeys.lang.ObjectAbstractTest;
import com.twelvemonkeys.lang.Validate;
import org.junit.Test;
import java.util.Arrays;
import static org.junit.Assert.*;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;
/**
* PropertyConverterAbstractTest
@@ -66,26 +66,26 @@ public abstract class PropertyConverterAbstractTest extends ObjectAbstractTest {
try {
obj = converter.toObject(test.original(), test.type(), test.format());
assertEquals(String.format("'%s' converted to incorrect type", test.original()), test.type(), obj.getClass());
assertEquals(test.type(), obj.getClass(), String.format("'%s' converted to incorrect type", test.original()));
if (test.type().isArray()) {
assertArrayEquals0(String.format("'%s' not converted", test.original()), test.value(), obj);
}
else {
assertEquals(String.format("'%s' not converted", test.original()), test.value(), obj);
assertEquals(test.value(), obj, String.format("'%s' not converted", test.original()));
}
String result = converter.toString(test.value(), test.format());
assertEquals(String.format("'%s' does not match", test.converted()), test.converted(), result);
assertEquals(test.converted(), result, String.format("'%s' does not match", test.converted()));
obj = converter.toObject(result, test.type(), test.format());
assertEquals(String.format("'%s' converted to incorrect type", test.original()), test.type(), obj.getClass());
assertEquals(test.type(), obj.getClass(), String.format("'%s' converted to incorrect type", test.original()));
if (test.type().isArray()) {
assertArrayEquals0(String.format("'%s' did not survive round trip conversion", test.original()), test.value(), obj);
}
else {
assertEquals(String.format("'%s' did not survive round trip conversion", test.original()), test.value(), obj);
assertEquals(test.value(), obj, String.format("'%s' did not survive round trip conversion", test.original()));
}
}
catch (ConversionException e) {
@@ -98,35 +98,35 @@ public abstract class PropertyConverterAbstractTest extends ObjectAbstractTest {
Class<?> componentType = left.getClass().getComponentType();
if (componentType.isPrimitive()) {
if (int.class == componentType) {
assertArrayEquals(message, (int[]) left, (int[]) right);
assertArrayEquals((int[]) left, (int[]) right, message);
}
else if (short.class == componentType) {
assertArrayEquals(message, (short[]) left, (short[]) right);
assertArrayEquals((short[]) left, (short[]) right, message);
}
else if (long.class == componentType) {
assertArrayEquals(message, (long[]) left, (long[]) right);
assertArrayEquals((long[]) left, (long[]) right, message);
}
else if (float.class == componentType) {
assertArrayEquals(message, (float[]) left, (float[]) right, 0f);
assertArrayEquals((float[]) left, (float[]) right, 0f, message);
}
else if (double.class == componentType) {
assertArrayEquals(message, (double[]) left, (double[]) right, 0d);
assertArrayEquals((double[]) left, (double[]) right, 0d, message);
}
else if (boolean.class == componentType) {
assertTrue(message, Arrays.equals((boolean[]) left, (boolean[]) right));
assertTrue(Arrays.equals((boolean[]) left, (boolean[]) right), message);
}
else if (byte.class == componentType) {
assertArrayEquals(message, (byte[]) left, (byte[]) right);
assertArrayEquals((byte[]) left, (byte[]) right, message);
}
else if (char.class == componentType) {
assertArrayEquals(message, (char[]) left, (char[]) right);
assertArrayEquals((char[]) left, (char[]) right, message);
}
else {
fail(String.format("Unknown primitive type: %s", componentType));
}
}
else {
assertArrayEquals(message, (Object[]) left, (Object[]) right);
assertArrayEquals((Object[]) left, (Object[]) right, message);
}
}

55
common/common-lang/src/test/java/com/twelvemonkeys/util/regex/RegExTokenIteratorTest.java
View File

@@ -32,12 +32,11 @@ package com.twelvemonkeys.util.regex;
import com.twelvemonkeys.util.TokenIterator;
import com.twelvemonkeys.util.TokenIteratorAbstractTest;
import org.junit.Test;
import java.util.Iterator;
import static org.junit.Assert.*;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;
/**
* StringTokenIteratorTestCase
* <p/>
@@ -68,9 +67,9 @@ public class RegExTokenIteratorTest extends TokenIteratorAbstractTest {
@Test
public void testSingleToken() {
Iterator iterator = createTokenIterator("A");
assertTrue("String has no elements", iterator.hasNext());
assertTrue(iterator.hasNext(), "String has no elements");
assertEquals("A", iterator.next());
assertFalse("String has more than one element", iterator.hasNext());
assertFalse(iterator.hasNext(), "String has more than one element");
}
@Test
@@ -87,67 +86,67 @@ public class RegExTokenIteratorTest extends TokenIteratorAbstractTest {
@Test
public void testSingleTokenSingleDelimiter() {
Iterator iterator = createTokenIterator("A", "[^,]+");
assertTrue("String has no elements", iterator.hasNext());
assertTrue(iterator.hasNext(), "String has no elements");
assertEquals("A", iterator.next());
assertFalse("String has more than one element", iterator.hasNext());
assertFalse(iterator.hasNext(), "String has more than one element");
}
@Test
public void testSingleSeparatorDefaultDelimiter() {
Iterator iterator = createTokenIterator("A B C D");
assertTrue("String has no elements", iterator.hasNext());
assertTrue(iterator.hasNext(), "String has no elements");
assertEquals("A", iterator.next());
assertTrue("String has no elements", iterator.hasNext());
assertTrue(iterator.hasNext(), "String has no elements");
assertEquals("B", iterator.next());
assertTrue("String has no elements", iterator.hasNext());
assertTrue(iterator.hasNext(), "String has no elements");
assertEquals("C", iterator.next());
assertTrue("String has no elements", iterator.hasNext());
assertTrue(iterator.hasNext(), "String has no elements");
assertEquals("D", iterator.next());
assertFalse("String has more than one element", iterator.hasNext());
assertFalse(iterator.hasNext(), "String has more than one element");
}
@Test
public void testSingleSeparator() {
Iterator iterator = createTokenIterator("A,B,C", "[^,]+");
assertTrue("String has no elements", iterator.hasNext());
assertTrue(iterator.hasNext(), "String has no elements");
assertEquals("A", iterator.next());
assertTrue("String has no elements", iterator.hasNext());
assertTrue(iterator.hasNext(), "String has no elements");
assertEquals("B", iterator.next());
assertTrue("String has no elements", iterator.hasNext());
assertTrue(iterator.hasNext(), "String has no elements");
assertEquals("C", iterator.next());
assertFalse("String has more than one element", iterator.hasNext());
assertFalse(iterator.hasNext(), "String has more than one element");
}
@Test
public void testMultipleSeparatorDefaultDelimiter() {
Iterator iterator = createTokenIterator("A B C\nD\t\t \nE");
assertTrue("String has no elements", iterator.hasNext());
assertTrue(iterator.hasNext(), "String has no elements");
assertEquals("A", iterator.next());
assertTrue("String has no elements", iterator.hasNext());
assertTrue(iterator.hasNext(), "String has no elements");
assertEquals("B", iterator.next());
assertTrue("String has no elements", iterator.hasNext());
assertTrue(iterator.hasNext(), "String has no elements");
assertEquals("C", iterator.next());
assertTrue("String has no elements", iterator.hasNext());
assertTrue(iterator.hasNext(), "String has no elements");
assertEquals("D", iterator.next());
assertTrue("String has no elements", iterator.hasNext());
assertTrue(iterator.hasNext(), "String has no elements");
assertEquals("E", iterator.next());
assertFalse("String has more than one element", iterator.hasNext());
assertFalse(iterator.hasNext(), "String has more than one element");
}
@Test
public void testMultipleSeparator() {
Iterator iterator = createTokenIterator("A,B,;,C...D, ., ,E", "[^ ,.;:]+");
assertTrue("String has no elements", iterator.hasNext());
assertTrue(iterator.hasNext(), "String has no elements");
Object o = iterator.next();
assertEquals("A", o);
assertTrue("String has no elements", iterator.hasNext());
assertTrue(iterator.hasNext(), "String has no elements");
assertEquals("B", iterator.next());
assertTrue("String has no elements", iterator.hasNext());
assertTrue(iterator.hasNext(), "String has no elements");
assertEquals("C", iterator.next());
assertTrue("String has no elements", iterator.hasNext());
assertTrue(iterator.hasNext(), "String has no elements");
assertEquals("D", iterator.next());
assertTrue("String has no elements", iterator.hasNext());
assertTrue(iterator.hasNext(), "String has no elements");
assertEquals("E", iterator.next());
assertFalse("String has more than one element", iterator.hasNext());
assertFalse(iterator.hasNext(), "String has more than one element");
}
}

20
common/common-lang/src/test/java/com/twelvemonkeys/util/service/ServiceRegistryTest.java
View File

@@ -30,12 +30,13 @@
package com.twelvemonkeys.util.service;
import com.twelvemonkeys.lang.Validate;
import com.twelvemonkeys.util.CollectionUtil;
import org.junit.Test;
import java.util.*;
import static org.junit.Assert.*;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;
/**
* ServiceRegistryTest
@@ -48,9 +49,11 @@ public class ServiceRegistryTest {
private final TestRegistry registry = new TestRegistry();
@Test(expected = IllegalArgumentException.class)
@Test
public void testCreateNull() {
new ServiceRegistry(null);
assertThrows(IllegalArgumentException.class, () -> {
new ServiceRegistry(null);
});
}
@Test
@@ -64,11 +67,12 @@ public class ServiceRegistryTest {
}
}
@Test(expected = ServiceConfigurationError.class)
@Test
public void testCreateBadConfig() {
@SuppressWarnings("unchecked")
ServiceRegistry registry = new ServiceRegistry(Arrays.asList(BadSPI.class).iterator());
registry.registerApplicationClasspathSPIs();
assertThrows(ServiceConfigurationError.class, () -> {
ServiceRegistry registry = new ServiceRegistry(Arrays.asList(BadSPI.class).iterator());
registry.registerApplicationClasspathSPIs();
});
// DONE: Test non-class