http://git-wip-us.apache.org/repos/asf/commons-lang/blob/3609993f/src/test/java/org/apache/commons/lang3/exception/ContextedRuntimeExceptionTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/lang3/exception/ContextedRuntimeExceptionTest.java b/src/test/java/org/apache/commons/lang3/exception/ContextedRuntimeExceptionTest.java index 2794b76..16d36bf 100644 --- a/src/test/java/org/apache/commons/lang3/exception/ContextedRuntimeExceptionTest.java +++ b/src/test/java/org/apache/commons/lang3/exception/ContextedRuntimeExceptionTest.java @@ -17,6 +17,7 @@ package org.apache.commons.lang3.exception; import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertNull; import static org.junit.jupiter.api.Assertions.assertTrue; @@ -100,7 +101,7 @@ public class ContextedRuntimeExceptionTest extends AbstractExceptionContextTest< .addContextValue("test Poorly written obj", new ObjectWithFaultyToString()); final String message = exceptionContext.getMessage(); - assertTrue(message != null); + assertNotNull(message); } @Test
http://git-wip-us.apache.org/repos/asf/commons-lang/blob/3609993f/src/test/java/org/apache/commons/lang3/math/FractionTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/lang3/math/FractionTest.java b/src/test/java/org/apache/commons/lang3/math/FractionTest.java index 416c16b..59a17b9 100644 --- a/src/test/java/org/apache/commons/lang3/math/FractionTest.java +++ b/src/test/java/org/apache/commons/lang3/math/FractionTest.java @@ -19,7 +19,7 @@ package org.apache.commons.lang3.math; import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotEquals; import static org.junit.jupiter.api.Assertions.assertSame; import static org.junit.jupiter.api.Assertions.assertThrows; import static org.junit.jupiter.api.Assertions.assertTrue; @@ -621,7 +621,7 @@ public class FractionTest { f = Fraction.getFraction(6, 10); assertEquals(f, f.pow(1)); - assertFalse(f.pow(1).equals(Fraction.getFraction(3,5))); + assertNotEquals(f.pow(1), Fraction.getFraction(3, 5)); f = Fraction.getFraction(6, 10); f = f.pow(2); @@ -646,11 +646,11 @@ public class FractionTest { // zero to any positive power is still zero. f = Fraction.getFraction(0, 1231); f = f.pow(1); - assertTrue(0==f.compareTo(Fraction.ZERO)); + assertEquals(0, f.compareTo(Fraction.ZERO)); assertEquals(0, f.getNumerator()); assertEquals(1231, f.getDenominator()); f = f.pow(2); - assertTrue(0==f.compareTo(Fraction.ZERO)); + assertEquals(0, f.compareTo(Fraction.ZERO)); assertEquals(0, f.getNumerator()); assertEquals(1, f.getDenominator()); @@ -994,21 +994,21 @@ public class FractionTest { Fraction f2 = null; f1 = Fraction.getFraction(3, 5); - assertFalse(f1.equals(null)); - assertFalse(f1.equals(new Object())); - assertFalse(f1.equals(Integer.valueOf(6))); + assertNotEquals(null, f1); + assertNotEquals(f1, new Object()); + assertNotEquals(f1, Integer.valueOf(6)); f1 = Fraction.getFraction(3, 5); f2 = Fraction.getFraction(2, 5); - assertFalse(f1.equals(f2)); - assertTrue(f1.equals(f1)); - assertTrue(f2.equals(f2)); + assertNotEquals(f1, f2); + assertEquals(f1, f1); + assertEquals(f2, f2); f2 = Fraction.getFraction(3, 5); - assertTrue(f1.equals(f2)); + assertEquals(f1, f2); f2 = Fraction.getFraction(6, 10); - assertFalse(f1.equals(f2)); + assertNotEquals(f1, f2); } @Test @@ -1016,7 +1016,7 @@ public class FractionTest { final Fraction f1 = Fraction.getFraction(3, 5); Fraction f2 = Fraction.getFraction(3, 5); - assertTrue(f1.hashCode() == f2.hashCode()); + assertEquals(f1.hashCode(), f2.hashCode()); f2 = Fraction.getFraction(2, 5); assertTrue(f1.hashCode() != f2.hashCode()); @@ -1031,30 +1031,30 @@ public class FractionTest { Fraction f2 = null; f1 = Fraction.getFraction(3, 5); - assertTrue(f1.compareTo(f1) == 0); + assertEquals(0, f1.compareTo(f1)); final Fraction fr = f1; assertThrows(NullPointerException.class, () -> fr.compareTo(null)); f2 = Fraction.getFraction(2, 5); assertTrue(f1.compareTo(f2) > 0); - assertTrue(f2.compareTo(f2) == 0); + assertEquals(0, f2.compareTo(f2)); f2 = Fraction.getFraction(4, 5); assertTrue(f1.compareTo(f2) < 0); - assertTrue(f2.compareTo(f2) == 0); + assertEquals(0, f2.compareTo(f2)); f2 = Fraction.getFraction(3, 5); - assertTrue(f1.compareTo(f2) == 0); - assertTrue(f2.compareTo(f2) == 0); + assertEquals(0, f1.compareTo(f2)); + assertEquals(0, f2.compareTo(f2)); f2 = Fraction.getFraction(6, 10); - assertTrue(f1.compareTo(f2) == 0); - assertTrue(f2.compareTo(f2) == 0); + assertEquals(0, f1.compareTo(f2)); + assertEquals(0, f2.compareTo(f2)); f2 = Fraction.getFraction(-1, 1, Integer.MAX_VALUE); assertTrue(f1.compareTo(f2) > 0); - assertTrue(f2.compareTo(f2) == 0); + assertEquals(0, f2.compareTo(f2)); } http://git-wip-us.apache.org/repos/asf/commons-lang/blob/3609993f/src/test/java/org/apache/commons/lang3/math/NumberUtilsTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/lang3/math/NumberUtilsTest.java b/src/test/java/org/apache/commons/lang3/math/NumberUtilsTest.java index a819c3d..58569d0 100644 --- a/src/test/java/org/apache/commons/lang3/math/NumberUtilsTest.java +++ b/src/test/java/org/apache/commons/lang3/math/NumberUtilsTest.java @@ -19,6 +19,7 @@ package org.apache.commons.lang3.math; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; import static org.junit.jupiter.api.Assertions.assertThrows; import static org.junit.jupiter.api.Assertions.assertTrue; @@ -53,10 +54,10 @@ public class NumberUtilsTest { */ @Test public void testToIntString() { - assertTrue(NumberUtils.toInt("12345") == 12345, "toInt(String) 1 failed"); - assertTrue(NumberUtils.toInt("abc") == 0, "toInt(String) 2 failed"); - assertTrue(NumberUtils.toInt("") == 0, "toInt(empty) failed"); - assertTrue(NumberUtils.toInt(null) == 0, "toInt(null) failed"); + assertEquals(12345, NumberUtils.toInt("12345"), "toInt(String) 1 failed"); + assertEquals(0, NumberUtils.toInt("abc"), "toInt(String) 2 failed"); + assertEquals(0, NumberUtils.toInt(""), "toInt(empty) failed"); + assertEquals(0, NumberUtils.toInt(null), "toInt(null) failed"); } /** @@ -64,8 +65,8 @@ public class NumberUtilsTest { */ @Test public void testToIntStringI() { - assertTrue(NumberUtils.toInt("12345", 5) == 12345, "toInt(String,int) 1 failed"); - assertTrue(NumberUtils.toInt("1234.5", 5) == 5, "toInt(String,int) 2 failed"); + assertEquals(12345, NumberUtils.toInt("12345", 5), "toInt(String,int) 1 failed"); + assertEquals(5, NumberUtils.toInt("1234.5", 5), "toInt(String,int) 2 failed"); } /** @@ -73,14 +74,14 @@ public class NumberUtilsTest { */ @Test public void testToLongString() { - assertTrue(NumberUtils.toLong("12345") == 12345L, "toLong(String) 1 failed"); - assertTrue(NumberUtils.toLong("abc") == 0L, "toLong(String) 2 failed"); - assertTrue(NumberUtils.toLong("1L") == 0L, "toLong(String) 3 failed"); - assertTrue(NumberUtils.toLong("1l") == 0L, "toLong(String) 4 failed"); - assertTrue(NumberUtils.toLong(Long.MAX_VALUE+"") == Long.MAX_VALUE, "toLong(Long.MAX_VALUE) failed"); - assertTrue(NumberUtils.toLong(Long.MIN_VALUE+"") == Long.MIN_VALUE, "toLong(Long.MIN_VALUE) failed"); - assertTrue(NumberUtils.toLong("") == 0L, "toLong(empty) failed"); - assertTrue(NumberUtils.toLong(null) == 0L, "toLong(null) failed"); + assertEquals(12345L, NumberUtils.toLong("12345"), "toLong(String) 1 failed"); + assertEquals(0L, NumberUtils.toLong("abc"), "toLong(String) 2 failed"); + assertEquals(0L, NumberUtils.toLong("1L"), "toLong(String) 3 failed"); + assertEquals(0L, NumberUtils.toLong("1l"), "toLong(String) 4 failed"); + assertEquals(NumberUtils.toLong(Long.MAX_VALUE + ""), Long.MAX_VALUE, "toLong(Long.MAX_VALUE) failed"); + assertEquals(NumberUtils.toLong(Long.MIN_VALUE + ""), Long.MIN_VALUE, "toLong(Long.MIN_VALUE) failed"); + assertEquals(0L, NumberUtils.toLong(""), "toLong(empty) failed"); + assertEquals(0L, NumberUtils.toLong(null), "toLong(null) failed"); } /** @@ -88,8 +89,8 @@ public class NumberUtilsTest { */ @Test public void testToLongStringL() { - assertTrue(NumberUtils.toLong("12345", 5L) == 12345L, "toLong(String,long) 1 failed"); - assertTrue(NumberUtils.toLong("1234.5", 5L) == 5L, "toLong(String,long) 2 failed"); + assertEquals(12345L, NumberUtils.toLong("12345", 5L), "toLong(String,long) 1 failed"); + assertEquals(5L, NumberUtils.toLong("1234.5", 5L), "toLong(String,long) 2 failed"); } /** @@ -204,10 +205,10 @@ public class NumberUtilsTest { */ @Test public void testToByteString() { - assertTrue(NumberUtils.toByte("123") == 123, "toByte(String) 1 failed"); - assertTrue(NumberUtils.toByte("abc") == 0, "toByte(String) 2 failed"); - assertTrue(NumberUtils.toByte("") == 0, "toByte(empty) failed"); - assertTrue(NumberUtils.toByte(null) == 0, "toByte(null) failed"); + assertEquals(123, NumberUtils.toByte("123"), "toByte(String) 1 failed"); + assertEquals(0, NumberUtils.toByte("abc"), "toByte(String) 2 failed"); + assertEquals(0, NumberUtils.toByte(""), "toByte(empty) failed"); + assertEquals(0, NumberUtils.toByte(null), "toByte(null) failed"); } /** @@ -215,8 +216,8 @@ public class NumberUtilsTest { */ @Test public void testToByteStringI() { - assertTrue(NumberUtils.toByte("123", (byte) 5) == 123, "toByte(String,byte) 1 failed"); - assertTrue(NumberUtils.toByte("12.3", (byte) 5) == 5, "toByte(String,byte) 2 failed"); + assertEquals(123, NumberUtils.toByte("123", (byte) 5), "toByte(String,byte) 1 failed"); + assertEquals(5, NumberUtils.toByte("12.3", (byte) 5), "toByte(String,byte) 2 failed"); } /** @@ -224,10 +225,10 @@ public class NumberUtilsTest { */ @Test public void testToShortString() { - assertTrue(NumberUtils.toShort("12345") == 12345, "toShort(String) 1 failed"); - assertTrue(NumberUtils.toShort("abc") == 0, "toShort(String) 2 failed"); - assertTrue(NumberUtils.toShort("") == 0, "toShort(empty) failed"); - assertTrue(NumberUtils.toShort(null) == 0, "toShort(null) failed"); + assertEquals(12345, NumberUtils.toShort("12345"), "toShort(String) 1 failed"); + assertEquals(0, NumberUtils.toShort("abc"), "toShort(String) 2 failed"); + assertEquals(0, NumberUtils.toShort(""), "toShort(empty) failed"); + assertEquals(0, NumberUtils.toShort(null), "toShort(null) failed"); } /** @@ -235,8 +236,8 @@ public class NumberUtilsTest { */ @Test public void testToShortStringI() { - assertTrue(NumberUtils.toShort("12345", (short) 5) == 12345, "toShort(String,short) 1 failed"); - assertTrue(NumberUtils.toShort("1234.5", (short) 5) == 5, "toShort(String,short) 2 failed"); + assertEquals(12345, NumberUtils.toShort("12345", (short) 5), "toShort(String,short) 1 failed"); + assertEquals(5, NumberUtils.toShort("1234.5", (short) 5), "toShort(String,short) 2 failed"); } /** @@ -244,19 +245,13 @@ public class NumberUtilsTest { */ @Test public void testToScaledBigDecimalBigDecimal() { - assertTrue(NumberUtils.toScaledBigDecimal(BigDecimal.valueOf(123.456)).equals(BigDecimal.valueOf(123.46)), - "toScaledBigDecimal(BigDecimal) 1 failed"); + assertEquals(NumberUtils.toScaledBigDecimal(BigDecimal.valueOf(123.456)), BigDecimal.valueOf(123.46), "toScaledBigDecimal(BigDecimal) 1 failed"); // Test RoudingMode.HALF_EVEN default rounding. - assertTrue(NumberUtils.toScaledBigDecimal(BigDecimal.valueOf(23.515)).equals(BigDecimal.valueOf(23.52)), - "toScaledBigDecimal(BigDecimal) 2 failed"); - assertTrue(NumberUtils.toScaledBigDecimal(BigDecimal.valueOf(23.525)).equals(BigDecimal.valueOf(23.52)), - "toScaledBigDecimal(BigDecimal) 3 failed"); - assertTrue(NumberUtils.toScaledBigDecimal(BigDecimal.valueOf(23.525)) - .multiply(BigDecimal.valueOf(100)).toString() - .equals("2352.00"), - "toScaledBigDecimal(BigDecimal) 4 failed"); - assertTrue(NumberUtils.toScaledBigDecimal((BigDecimal) null).equals(BigDecimal.ZERO), - "toScaledBigDecimal(BigDecimal) 5 failed"); + assertEquals(NumberUtils.toScaledBigDecimal(BigDecimal.valueOf(23.515)), BigDecimal.valueOf(23.52), "toScaledBigDecimal(BigDecimal) 2 failed"); + assertEquals(NumberUtils.toScaledBigDecimal(BigDecimal.valueOf(23.525)), BigDecimal.valueOf(23.52), "toScaledBigDecimal(BigDecimal) 3 failed"); + assertEquals("2352.00", NumberUtils.toScaledBigDecimal(BigDecimal.valueOf(23.525)) + .multiply(BigDecimal.valueOf(100)).toString(), "toScaledBigDecimal(BigDecimal) 4 failed"); + assertEquals(NumberUtils.toScaledBigDecimal((BigDecimal) null), BigDecimal.ZERO, "toScaledBigDecimal(BigDecimal) 5 failed"); } /** @@ -264,19 +259,13 @@ public class NumberUtilsTest { */ @Test public void testToScaledBigDecimalBigDecimalIRM() { - assertTrue(NumberUtils.toScaledBigDecimal(BigDecimal.valueOf(123.456), 1, RoundingMode.CEILING).equals(BigDecimal.valueOf(123.5)), - "toScaledBigDecimal(BigDecimal, int, RoudingMode) 1 failed"); - assertTrue(NumberUtils.toScaledBigDecimal(BigDecimal.valueOf(23.5159), 3, RoundingMode.FLOOR).equals(BigDecimal.valueOf(23.515)), - "toScaledBigDecimal(BigDecimal, int, RoudingMode) 2 failed"); - assertTrue(NumberUtils.toScaledBigDecimal(BigDecimal.valueOf(23.525), 2, RoundingMode.HALF_UP).equals(BigDecimal.valueOf(23.53)), - "toScaledBigDecimal(BigDecimal, int, RoudingMode) 3 failed"); - assertTrue(NumberUtils.toScaledBigDecimal(BigDecimal.valueOf(23.521), 4, RoundingMode.HALF_EVEN) - .multiply(BigDecimal.valueOf(1000)) - .toString() - .equals("23521.0000"), - "toScaledBigDecimal(BigDecimal, int, RoudingMode) 4 failed"); - assertTrue(NumberUtils.toScaledBigDecimal((BigDecimal) null, 2, RoundingMode.HALF_UP).equals(BigDecimal.ZERO), - "toScaledBigDecimal(BigDecimal, int, RoudingMode) 5 failed"); + assertEquals(NumberUtils.toScaledBigDecimal(BigDecimal.valueOf(123.456), 1, RoundingMode.CEILING), BigDecimal.valueOf(123.5), "toScaledBigDecimal(BigDecimal, int, RoudingMode) 1 failed"); + assertEquals(NumberUtils.toScaledBigDecimal(BigDecimal.valueOf(23.5159), 3, RoundingMode.FLOOR), BigDecimal.valueOf(23.515), "toScaledBigDecimal(BigDecimal, int, RoudingMode) 2 failed"); + assertEquals(NumberUtils.toScaledBigDecimal(BigDecimal.valueOf(23.525), 2, RoundingMode.HALF_UP), BigDecimal.valueOf(23.53), "toScaledBigDecimal(BigDecimal, int, RoudingMode) 3 failed"); + assertEquals("23521.0000", NumberUtils.toScaledBigDecimal(BigDecimal.valueOf(23.521), 4, RoundingMode.HALF_EVEN) + .multiply(BigDecimal.valueOf(1000)) + .toString(), "toScaledBigDecimal(BigDecimal, int, RoudingMode) 4 failed"); + assertEquals(NumberUtils.toScaledBigDecimal((BigDecimal) null, 2, RoundingMode.HALF_UP), BigDecimal.ZERO, "toScaledBigDecimal(BigDecimal, int, RoudingMode) 5 failed"); } /** @@ -284,21 +273,15 @@ public class NumberUtilsTest { */ @Test public void testToScaledBigDecimalFloat() { - assertTrue(NumberUtils.toScaledBigDecimal(Float.valueOf(123.456f)).equals(BigDecimal.valueOf(123.46)), - "toScaledBigDecimal(Float) 1 failed"); + assertEquals(NumberUtils.toScaledBigDecimal(Float.valueOf(123.456f)), BigDecimal.valueOf(123.46), "toScaledBigDecimal(Float) 1 failed"); // Test RoudingMode.HALF_EVEN default rounding. - assertTrue(NumberUtils.toScaledBigDecimal(Float.valueOf(23.515f)).equals(BigDecimal.valueOf(23.51)), - "toScaledBigDecimal(Float) 2 failed"); + assertEquals(NumberUtils.toScaledBigDecimal(Float.valueOf(23.515f)), BigDecimal.valueOf(23.51), "toScaledBigDecimal(Float) 2 failed"); // Note. NumberUtils.toScaledBigDecimal(Float.valueOf(23.515f)).equals(BigDecimal.valueOf(23.51)) // because of roundoff error. It is ok. - assertTrue(NumberUtils.toScaledBigDecimal(Float.valueOf(23.525f)).equals(BigDecimal.valueOf(23.52)), - "toScaledBigDecimal(Float) 3 failed"); - assertTrue(NumberUtils.toScaledBigDecimal(Float.valueOf(23.525f)) - .multiply(BigDecimal.valueOf(100)).toString() - .equals("2352.00"), - "toScaledBigDecimal(Float) 4 failed"); - assertTrue(NumberUtils.toScaledBigDecimal((Float) null).equals(BigDecimal.ZERO), - "toScaledBigDecimal(Float) 5 failed"); + assertEquals(NumberUtils.toScaledBigDecimal(Float.valueOf(23.525f)), BigDecimal.valueOf(23.52), "toScaledBigDecimal(Float) 3 failed"); + assertEquals("2352.00", NumberUtils.toScaledBigDecimal(Float.valueOf(23.525f)) + .multiply(BigDecimal.valueOf(100)).toString(), "toScaledBigDecimal(Float) 4 failed"); + assertEquals(NumberUtils.toScaledBigDecimal((Float) null), BigDecimal.ZERO, "toScaledBigDecimal(Float) 5 failed"); } /** @@ -306,20 +289,14 @@ public class NumberUtilsTest { */ @Test public void testToScaledBigDecimalFloatIRM() { - assertTrue(NumberUtils.toScaledBigDecimal(Float.valueOf(123.456f), 1, RoundingMode.CEILING).equals(BigDecimal.valueOf(123.5)), - "toScaledBigDecimal(Float, int, RoudingMode) 1 failed"); - assertTrue(NumberUtils.toScaledBigDecimal(Float.valueOf(23.5159f), 3, RoundingMode.FLOOR).equals(BigDecimal.valueOf(23.515)), - "toScaledBigDecimal(Float, int, RoudingMode) 2 failed"); + assertEquals(NumberUtils.toScaledBigDecimal(Float.valueOf(123.456f), 1, RoundingMode.CEILING), BigDecimal.valueOf(123.5), "toScaledBigDecimal(Float, int, RoudingMode) 1 failed"); + assertEquals(NumberUtils.toScaledBigDecimal(Float.valueOf(23.5159f), 3, RoundingMode.FLOOR), BigDecimal.valueOf(23.515), "toScaledBigDecimal(Float, int, RoudingMode) 2 failed"); // The following happens due to roundoff error. We're ok with this. - assertTrue(NumberUtils.toScaledBigDecimal(Float.valueOf(23.525f), 2, RoundingMode.HALF_UP).equals(BigDecimal.valueOf(23.52)), - "toScaledBigDecimal(Float, int, RoudingMode) 3 failed"); - assertTrue(NumberUtils.toScaledBigDecimal(Float.valueOf(23.521f), 4, RoundingMode.HALF_EVEN) - .multiply(BigDecimal.valueOf(1000)) - .toString() - .equals("23521.0000"), - "toScaledBigDecimal(Float, int, RoudingMode) 4 failed"); - assertTrue(NumberUtils.toScaledBigDecimal((Float) null, 2, RoundingMode.HALF_UP).equals(BigDecimal.ZERO), - "toScaledBigDecimal(Float, int, RoudingMode) 5 failed"); + assertEquals(NumberUtils.toScaledBigDecimal(Float.valueOf(23.525f), 2, RoundingMode.HALF_UP), BigDecimal.valueOf(23.52), "toScaledBigDecimal(Float, int, RoudingMode) 3 failed"); + assertEquals("23521.0000", NumberUtils.toScaledBigDecimal(Float.valueOf(23.521f), 4, RoundingMode.HALF_EVEN) + .multiply(BigDecimal.valueOf(1000)) + .toString(), "toScaledBigDecimal(Float, int, RoudingMode) 4 failed"); + assertEquals(NumberUtils.toScaledBigDecimal((Float) null, 2, RoundingMode.HALF_UP), BigDecimal.ZERO, "toScaledBigDecimal(Float, int, RoudingMode) 5 failed"); } /** @@ -327,19 +304,13 @@ public class NumberUtilsTest { */ @Test public void testToScaledBigDecimalDouble() { - assertTrue(NumberUtils.toScaledBigDecimal(Double.valueOf(123.456d)).equals(BigDecimal.valueOf(123.46)), - "toScaledBigDecimal(Double) 1 failed"); + assertEquals(NumberUtils.toScaledBigDecimal(Double.valueOf(123.456d)), BigDecimal.valueOf(123.46), "toScaledBigDecimal(Double) 1 failed"); // Test RoudingMode.HALF_EVEN default rounding. - assertTrue(NumberUtils.toScaledBigDecimal(Double.valueOf(23.515d)).equals(BigDecimal.valueOf(23.52)), - "toScaledBigDecimal(Double) 2 failed"); - assertTrue(NumberUtils.toScaledBigDecimal(Double.valueOf(23.525d)).equals(BigDecimal.valueOf(23.52)), - "toScaledBigDecimal(Double) 3 failed"); - assertTrue(NumberUtils.toScaledBigDecimal(Double.valueOf(23.525d)) - .multiply(BigDecimal.valueOf(100)).toString() - .equals("2352.00"), - "toScaledBigDecimal(Double) 4 failed"); - assertTrue(NumberUtils.toScaledBigDecimal((Double) null).equals(BigDecimal.ZERO), - "toScaledBigDecimal(Double) 5 failed"); + assertEquals(NumberUtils.toScaledBigDecimal(Double.valueOf(23.515d)), BigDecimal.valueOf(23.52), "toScaledBigDecimal(Double) 2 failed"); + assertEquals(NumberUtils.toScaledBigDecimal(Double.valueOf(23.525d)), BigDecimal.valueOf(23.52), "toScaledBigDecimal(Double) 3 failed"); + assertEquals("2352.00", NumberUtils.toScaledBigDecimal(Double.valueOf(23.525d)) + .multiply(BigDecimal.valueOf(100)).toString(), "toScaledBigDecimal(Double) 4 failed"); + assertEquals(NumberUtils.toScaledBigDecimal((Double) null), BigDecimal.ZERO, "toScaledBigDecimal(Double) 5 failed"); } /** @@ -347,19 +318,13 @@ public class NumberUtilsTest { */ @Test public void testToScaledBigDecimalDoubleIRM() { - assertTrue(NumberUtils.toScaledBigDecimal(Double.valueOf(123.456d), 1, RoundingMode.CEILING).equals(BigDecimal.valueOf(123.5)), - "toScaledBigDecimal(Double, int, RoudingMode) 1 failed"); - assertTrue(NumberUtils.toScaledBigDecimal(Double.valueOf(23.5159d), 3, RoundingMode.FLOOR).equals(BigDecimal.valueOf(23.515)), - "toScaledBigDecimal(Double, int, RoudingMode) 2 failed"); - assertTrue(NumberUtils.toScaledBigDecimal(Double.valueOf(23.525d), 2, RoundingMode.HALF_UP).equals(BigDecimal.valueOf(23.53)), - "toScaledBigDecimal(Double, int, RoudingMode) 3 failed"); - assertTrue(NumberUtils.toScaledBigDecimal(Double.valueOf(23.521d), 4, RoundingMode.HALF_EVEN) - .multiply(BigDecimal.valueOf(1000)) - .toString() - .equals("23521.0000"), - "toScaledBigDecimal(Double, int, RoudingMode) 4 failed"); - assertTrue(NumberUtils.toScaledBigDecimal((Double) null, 2, RoundingMode.HALF_UP).equals(BigDecimal.ZERO), - "toScaledBigDecimal(Double, int, RoudingMode) 5 failed"); + assertEquals(NumberUtils.toScaledBigDecimal(Double.valueOf(123.456d), 1, RoundingMode.CEILING), BigDecimal.valueOf(123.5), "toScaledBigDecimal(Double, int, RoudingMode) 1 failed"); + assertEquals(NumberUtils.toScaledBigDecimal(Double.valueOf(23.5159d), 3, RoundingMode.FLOOR), BigDecimal.valueOf(23.515), "toScaledBigDecimal(Double, int, RoudingMode) 2 failed"); + assertEquals(NumberUtils.toScaledBigDecimal(Double.valueOf(23.525d), 2, RoundingMode.HALF_UP), BigDecimal.valueOf(23.53), "toScaledBigDecimal(Double, int, RoudingMode) 3 failed"); + assertEquals("23521.0000", NumberUtils.toScaledBigDecimal(Double.valueOf(23.521d), 4, RoundingMode.HALF_EVEN) + .multiply(BigDecimal.valueOf(1000)) + .toString(), "toScaledBigDecimal(Double, int, RoudingMode) 4 failed"); + assertEquals(NumberUtils.toScaledBigDecimal((Double) null, 2, RoundingMode.HALF_UP), BigDecimal.ZERO, "toScaledBigDecimal(Double, int, RoudingMode) 5 failed"); } /** @@ -367,19 +332,13 @@ public class NumberUtilsTest { */ @Test public void testToScaledBigDecimalString() { - assertTrue(NumberUtils.toScaledBigDecimal("123.456").equals(BigDecimal.valueOf(123.46)), - "toScaledBigDecimal(String) 1 failed"); + assertEquals(NumberUtils.toScaledBigDecimal("123.456"), BigDecimal.valueOf(123.46), "toScaledBigDecimal(String) 1 failed"); // Test RoudingMode.HALF_EVEN default rounding. - assertTrue(NumberUtils.toScaledBigDecimal("23.515").equals(BigDecimal.valueOf(23.52)), - "toScaledBigDecimal(String) 2 failed"); - assertTrue(NumberUtils.toScaledBigDecimal("23.525").equals(BigDecimal.valueOf(23.52)), - "toScaledBigDecimal(String) 3 failed"); - assertTrue(NumberUtils.toScaledBigDecimal("23.525") - .multiply(BigDecimal.valueOf(100)).toString() - .equals("2352.00"), - "toScaledBigDecimal(String) 4 failed"); - assertTrue(NumberUtils.toScaledBigDecimal((String) null).equals(BigDecimal.ZERO), - "toScaledBigDecimal(String) 5 failed"); + assertEquals(NumberUtils.toScaledBigDecimal("23.515"), BigDecimal.valueOf(23.52), "toScaledBigDecimal(String) 2 failed"); + assertEquals(NumberUtils.toScaledBigDecimal("23.525"), BigDecimal.valueOf(23.52), "toScaledBigDecimal(String) 3 failed"); + assertEquals("2352.00", NumberUtils.toScaledBigDecimal("23.525") + .multiply(BigDecimal.valueOf(100)).toString(), "toScaledBigDecimal(String) 4 failed"); + assertEquals(NumberUtils.toScaledBigDecimal((String) null), BigDecimal.ZERO, "toScaledBigDecimal(String) 5 failed"); } /** @@ -387,19 +346,13 @@ public class NumberUtilsTest { */ @Test public void testToScaledBigDecimalStringIRM() { - assertTrue(NumberUtils.toScaledBigDecimal("123.456", 1, RoundingMode.CEILING).equals(BigDecimal.valueOf(123.5)), - "toScaledBigDecimal(String, int, RoudingMode) 1 failed"); - assertTrue(NumberUtils.toScaledBigDecimal("23.5159", 3, RoundingMode.FLOOR).equals(BigDecimal.valueOf(23.515)), - "toScaledBigDecimal(String, int, RoudingMode) 2 failed"); - assertTrue(NumberUtils.toScaledBigDecimal("23.525", 2, RoundingMode.HALF_UP).equals(BigDecimal.valueOf(23.53)), - "toScaledBigDecimal(String, int, RoudingMode) 3 failed"); - assertTrue(NumberUtils.toScaledBigDecimal("23.521", 4, RoundingMode.HALF_EVEN) - .multiply(BigDecimal.valueOf(1000)) - .toString() - .equals("23521.0000"), - "toScaledBigDecimal(String, int, RoudingMode) 4 failed"); - assertTrue(NumberUtils.toScaledBigDecimal((String) null, 2, RoundingMode.HALF_UP).equals(BigDecimal.ZERO), - "toScaledBigDecimal(String, int, RoudingMode) 5 failed"); + assertEquals(NumberUtils.toScaledBigDecimal("123.456", 1, RoundingMode.CEILING), BigDecimal.valueOf(123.5), "toScaledBigDecimal(String, int, RoudingMode) 1 failed"); + assertEquals(NumberUtils.toScaledBigDecimal("23.5159", 3, RoundingMode.FLOOR), BigDecimal.valueOf(23.515), "toScaledBigDecimal(String, int, RoudingMode) 2 failed"); + assertEquals(NumberUtils.toScaledBigDecimal("23.525", 2, RoundingMode.HALF_UP), BigDecimal.valueOf(23.53), "toScaledBigDecimal(String, int, RoudingMode) 3 failed"); + assertEquals("23521.0000", NumberUtils.toScaledBigDecimal("23.521", 4, RoundingMode.HALF_EVEN) + .multiply(BigDecimal.valueOf(1000)) + .toString(), "toScaledBigDecimal(String, int, RoudingMode) 4 failed"); + assertEquals(NumberUtils.toScaledBigDecimal((String) null, 2, RoundingMode.HALF_UP), BigDecimal.ZERO, "toScaledBigDecimal(String, int, RoudingMode) 5 failed"); } @Test @@ -417,15 +370,15 @@ public class NumberUtilsTest { assertEquals(Long.valueOf(12345), NumberUtils.createNumber("12345l"), "createNumber(String) 6 failed"); assertEquals(Float.valueOf("-1234.5"), NumberUtils.createNumber("-1234.5"), "createNumber(String) 7 failed"); assertEquals(Integer.valueOf("-12345"), NumberUtils.createNumber("-12345"), "createNumber(String) 8 failed"); - assertTrue(0xFADE == NumberUtils.createNumber("0xFADE").intValue(), "createNumber(String) 9a failed"); - assertTrue(0xFADE == NumberUtils.createNumber("0Xfade").intValue(), "createNumber(String) 9b failed"); - assertTrue(-0xFADE == NumberUtils.createNumber("-0xFADE").intValue(), "createNumber(String) 10a failed"); - assertTrue(-0xFADE == NumberUtils.createNumber("-0Xfade").intValue(), "createNumber(String) 10b failed"); + assertEquals(0xFADE, NumberUtils.createNumber("0xFADE").intValue(), "createNumber(String) 9a failed"); + assertEquals(0xFADE, NumberUtils.createNumber("0Xfade").intValue(), "createNumber(String) 9b failed"); + assertEquals(-0xFADE, NumberUtils.createNumber("-0xFADE").intValue(), "createNumber(String) 10a failed"); + assertEquals(-0xFADE, NumberUtils.createNumber("-0Xfade").intValue(), "createNumber(String) 10b failed"); assertEquals(Double.valueOf("1.1E200"), NumberUtils.createNumber("1.1E200"), "createNumber(String) 11 failed"); assertEquals(Float.valueOf("1.1E20"), NumberUtils.createNumber("1.1E20"), "createNumber(String) 12 failed"); assertEquals(Double.valueOf("-1.1E200"), NumberUtils.createNumber("-1.1E200"), "createNumber(String) 13 failed"); assertEquals(Double.valueOf("1.1E-200"), NumberUtils.createNumber("1.1E-200"), "createNumber(String) 14 failed"); - assertEquals(null, NumberUtils.createNumber(null), "createNumber(null) failed"); + assertNull(NumberUtils.createNumber(null), "createNumber(null) failed"); assertEquals(new BigInteger("12345678901234567890"), NumberUtils.createNumber("12345678901234567890L"), "createNumber(String) failed"); assertEquals(new BigDecimal("1.1E-700"), NumberUtils.createNumber("1.1E-700F"), "createNumber(String) 15 failed"); @@ -606,7 +559,7 @@ public class NumberUtilsTest { @Test public void testCreateFloat() { assertEquals(Float.valueOf("1234.5"), NumberUtils.createFloat("1234.5"), "createFloat(String) failed"); - assertEquals(null, NumberUtils.createFloat(null), "createFloat(null) failed"); + assertNull(NumberUtils.createFloat(null), "createFloat(null) failed"); this.testCreateFloatFailure(""); this.testCreateFloatFailure(" "); this.testCreateFloatFailure("\b\t\n\f\r"); @@ -623,7 +576,7 @@ public class NumberUtilsTest { @Test public void testCreateDouble() { assertEquals(Double.valueOf("1234.5"), NumberUtils.createDouble("1234.5"), "createDouble(String) failed"); - assertEquals(null, NumberUtils.createDouble(null), "createDouble(null) failed"); + assertNull(NumberUtils.createDouble(null), "createDouble(null) failed"); this.testCreateDoubleFailure(""); this.testCreateDoubleFailure(" "); this.testCreateDoubleFailure("\b\t\n\f\r"); @@ -641,7 +594,7 @@ public class NumberUtilsTest { @Test public void testCreateInteger() { assertEquals(Integer.valueOf("12345"), NumberUtils.createInteger("12345"), "createInteger(String) failed"); - assertEquals(null, NumberUtils.createInteger(null), "createInteger(null) failed"); + assertNull(NumberUtils.createInteger(null), "createInteger(null) failed"); this.testCreateIntegerFailure(""); this.testCreateIntegerFailure(" "); this.testCreateIntegerFailure("\b\t\n\f\r"); @@ -659,7 +612,7 @@ public class NumberUtilsTest { @Test public void testCreateLong() { assertEquals(Long.valueOf("12345"), NumberUtils.createLong("12345"), "createLong(String) failed"); - assertEquals(null, NumberUtils.createLong(null), "createLong(null) failed"); + assertNull(NumberUtils.createLong(null), "createLong(null) failed"); this.testCreateLongFailure(""); this.testCreateLongFailure(" "); this.testCreateLongFailure("\b\t\n\f\r"); @@ -677,7 +630,7 @@ public class NumberUtilsTest { @Test public void testCreateBigInteger() { assertEquals(new BigInteger("12345"), NumberUtils.createBigInteger("12345"), "createBigInteger(String) failed"); - assertEquals(null, NumberUtils.createBigInteger(null), "createBigInteger(null) failed"); + assertNull(NumberUtils.createBigInteger(null), "createBigInteger(null) failed"); this.testCreateBigIntegerFailure(""); this.testCreateBigIntegerFailure(" "); this.testCreateBigIntegerFailure("\b\t\n\f\r"); @@ -708,7 +661,7 @@ public class NumberUtilsTest { @Test public void testCreateBigDecimal() { assertEquals(new BigDecimal("1234.5"), NumberUtils.createBigDecimal("1234.5"), "createBigDecimal(String) failed"); - assertEquals(null, NumberUtils.createBigDecimal(null), "createBigDecimal(null) failed"); + assertNull(NumberUtils.createBigDecimal(null), "createBigDecimal(null) failed"); this.testCreateBigDecimalFailure(""); this.testCreateBigDecimalFailure(" "); this.testCreateBigDecimalFailure("\b\t\n\f\r"); @@ -1111,188 +1064,188 @@ public class NumberUtilsTest { // Testing JDK against old Lang functionality @Test public void testCompareDouble() { - assertTrue(Double.compare(Double.NaN, Double.NaN) == 0); - assertTrue(Double.compare(Double.NaN, Double.POSITIVE_INFINITY) == +1); - assertTrue(Double.compare(Double.NaN, Double.MAX_VALUE) == +1); - assertTrue(Double.compare(Double.NaN, 1.2d) == +1); - assertTrue(Double.compare(Double.NaN, 0.0d) == +1); - assertTrue(Double.compare(Double.NaN, -0.0d) == +1); - assertTrue(Double.compare(Double.NaN, -1.2d) == +1); - assertTrue(Double.compare(Double.NaN, -Double.MAX_VALUE) == +1); - assertTrue(Double.compare(Double.NaN, Double.NEGATIVE_INFINITY) == +1); - - assertTrue(Double.compare(Double.POSITIVE_INFINITY, Double.NaN) == -1); - assertTrue(Double.compare(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY) == 0); - assertTrue(Double.compare(Double.POSITIVE_INFINITY, Double.MAX_VALUE) == +1); - assertTrue(Double.compare(Double.POSITIVE_INFINITY, 1.2d) == +1); - assertTrue(Double.compare(Double.POSITIVE_INFINITY, 0.0d) == +1); - assertTrue(Double.compare(Double.POSITIVE_INFINITY, -0.0d) == +1); - assertTrue(Double.compare(Double.POSITIVE_INFINITY, -1.2d) == +1); - assertTrue(Double.compare(Double.POSITIVE_INFINITY, -Double.MAX_VALUE) == +1); - assertTrue(Double.compare(Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY) == +1); - - assertTrue(Double.compare(Double.MAX_VALUE, Double.NaN) == -1); - assertTrue(Double.compare(Double.MAX_VALUE, Double.POSITIVE_INFINITY) == -1); - assertTrue(Double.compare(Double.MAX_VALUE, Double.MAX_VALUE) == 0); - assertTrue(Double.compare(Double.MAX_VALUE, 1.2d) == +1); - assertTrue(Double.compare(Double.MAX_VALUE, 0.0d) == +1); - assertTrue(Double.compare(Double.MAX_VALUE, -0.0d) == +1); - assertTrue(Double.compare(Double.MAX_VALUE, -1.2d) == +1); - assertTrue(Double.compare(Double.MAX_VALUE, -Double.MAX_VALUE) == +1); - assertTrue(Double.compare(Double.MAX_VALUE, Double.NEGATIVE_INFINITY) == +1); - - assertTrue(Double.compare(1.2d, Double.NaN) == -1); - assertTrue(Double.compare(1.2d, Double.POSITIVE_INFINITY) == -1); - assertTrue(Double.compare(1.2d, Double.MAX_VALUE) == -1); - assertTrue(Double.compare(1.2d, 1.2d) == 0); - assertTrue(Double.compare(1.2d, 0.0d) == +1); - assertTrue(Double.compare(1.2d, -0.0d) == +1); - assertTrue(Double.compare(1.2d, -1.2d) == +1); - assertTrue(Double.compare(1.2d, -Double.MAX_VALUE) == +1); - assertTrue(Double.compare(1.2d, Double.NEGATIVE_INFINITY) == +1); - - assertTrue(Double.compare(0.0d, Double.NaN) == -1); - assertTrue(Double.compare(0.0d, Double.POSITIVE_INFINITY) == -1); - assertTrue(Double.compare(0.0d, Double.MAX_VALUE) == -1); - assertTrue(Double.compare(0.0d, 1.2d) == -1); - assertTrue(Double.compare(0.0d, 0.0d) == 0); - assertTrue(Double.compare(0.0d, -0.0d) == +1); - assertTrue(Double.compare(0.0d, -1.2d) == +1); - assertTrue(Double.compare(0.0d, -Double.MAX_VALUE) == +1); - assertTrue(Double.compare(0.0d, Double.NEGATIVE_INFINITY) == +1); - - assertTrue(Double.compare(-0.0d, Double.NaN) == -1); - assertTrue(Double.compare(-0.0d, Double.POSITIVE_INFINITY) == -1); - assertTrue(Double.compare(-0.0d, Double.MAX_VALUE) == -1); - assertTrue(Double.compare(-0.0d, 1.2d) == -1); - assertTrue(Double.compare(-0.0d, 0.0d) == -1); - assertTrue(Double.compare(-0.0d, -0.0d) == 0); - assertTrue(Double.compare(-0.0d, -1.2d) == +1); - assertTrue(Double.compare(-0.0d, -Double.MAX_VALUE) == +1); - assertTrue(Double.compare(-0.0d, Double.NEGATIVE_INFINITY) == +1); - - assertTrue(Double.compare(-1.2d, Double.NaN) == -1); - assertTrue(Double.compare(-1.2d, Double.POSITIVE_INFINITY) == -1); - assertTrue(Double.compare(-1.2d, Double.MAX_VALUE) == -1); - assertTrue(Double.compare(-1.2d, 1.2d) == -1); - assertTrue(Double.compare(-1.2d, 0.0d) == -1); - assertTrue(Double.compare(-1.2d, -0.0d) == -1); - assertTrue(Double.compare(-1.2d, -1.2d) == 0); - assertTrue(Double.compare(-1.2d, -Double.MAX_VALUE) == +1); - assertTrue(Double.compare(-1.2d, Double.NEGATIVE_INFINITY) == +1); - - assertTrue(Double.compare(-Double.MAX_VALUE, Double.NaN) == -1); - assertTrue(Double.compare(-Double.MAX_VALUE, Double.POSITIVE_INFINITY) == -1); - assertTrue(Double.compare(-Double.MAX_VALUE, Double.MAX_VALUE) == -1); - assertTrue(Double.compare(-Double.MAX_VALUE, 1.2d) == -1); - assertTrue(Double.compare(-Double.MAX_VALUE, 0.0d) == -1); - assertTrue(Double.compare(-Double.MAX_VALUE, -0.0d) == -1); - assertTrue(Double.compare(-Double.MAX_VALUE, -1.2d) == -1); - assertTrue(Double.compare(-Double.MAX_VALUE, -Double.MAX_VALUE) == 0); - assertTrue(Double.compare(-Double.MAX_VALUE, Double.NEGATIVE_INFINITY) == +1); - - assertTrue(Double.compare(Double.NEGATIVE_INFINITY, Double.NaN) == -1); - assertTrue(Double.compare(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY) == -1); - assertTrue(Double.compare(Double.NEGATIVE_INFINITY, Double.MAX_VALUE) == -1); - assertTrue(Double.compare(Double.NEGATIVE_INFINITY, 1.2d) == -1); - assertTrue(Double.compare(Double.NEGATIVE_INFINITY, 0.0d) == -1); - assertTrue(Double.compare(Double.NEGATIVE_INFINITY, -0.0d) == -1); - assertTrue(Double.compare(Double.NEGATIVE_INFINITY, -1.2d) == -1); - assertTrue(Double.compare(Double.NEGATIVE_INFINITY, -Double.MAX_VALUE) == -1); - assertTrue(Double.compare(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY) == 0); + assertEquals(0, Double.compare(Double.NaN, Double.NaN)); + assertEquals(Double.compare(Double.NaN, Double.POSITIVE_INFINITY), +1); + assertEquals(Double.compare(Double.NaN, Double.MAX_VALUE), +1); + assertEquals(Double.compare(Double.NaN, 1.2d), +1); + assertEquals(Double.compare(Double.NaN, 0.0d), +1); + assertEquals(Double.compare(Double.NaN, -0.0d), +1); + assertEquals(Double.compare(Double.NaN, -1.2d), +1); + assertEquals(Double.compare(Double.NaN, -Double.MAX_VALUE), +1); + assertEquals(Double.compare(Double.NaN, Double.NEGATIVE_INFINITY), +1); + + assertEquals(Double.compare(Double.POSITIVE_INFINITY, Double.NaN), -1); + assertEquals(0, Double.compare(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY)); + assertEquals(Double.compare(Double.POSITIVE_INFINITY, Double.MAX_VALUE), +1); + assertEquals(Double.compare(Double.POSITIVE_INFINITY, 1.2d), +1); + assertEquals(Double.compare(Double.POSITIVE_INFINITY, 0.0d), +1); + assertEquals(Double.compare(Double.POSITIVE_INFINITY, -0.0d), +1); + assertEquals(Double.compare(Double.POSITIVE_INFINITY, -1.2d), +1); + assertEquals(Double.compare(Double.POSITIVE_INFINITY, -Double.MAX_VALUE), +1); + assertEquals(Double.compare(Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY), +1); + + assertEquals(Double.compare(Double.MAX_VALUE, Double.NaN), -1); + assertEquals(Double.compare(Double.MAX_VALUE, Double.POSITIVE_INFINITY), -1); + assertEquals(0, Double.compare(Double.MAX_VALUE, Double.MAX_VALUE)); + assertEquals(Double.compare(Double.MAX_VALUE, 1.2d), +1); + assertEquals(Double.compare(Double.MAX_VALUE, 0.0d), +1); + assertEquals(Double.compare(Double.MAX_VALUE, -0.0d), +1); + assertEquals(Double.compare(Double.MAX_VALUE, -1.2d), +1); + assertEquals(Double.compare(Double.MAX_VALUE, -Double.MAX_VALUE), +1); + assertEquals(Double.compare(Double.MAX_VALUE, Double.NEGATIVE_INFINITY), +1); + + assertEquals(Double.compare(1.2d, Double.NaN), -1); + assertEquals(Double.compare(1.2d, Double.POSITIVE_INFINITY), -1); + assertEquals(Double.compare(1.2d, Double.MAX_VALUE), -1); + assertEquals(0, Double.compare(1.2d, 1.2d)); + assertEquals(Double.compare(1.2d, 0.0d), +1); + assertEquals(Double.compare(1.2d, -0.0d), +1); + assertEquals(Double.compare(1.2d, -1.2d), +1); + assertEquals(Double.compare(1.2d, -Double.MAX_VALUE), +1); + assertEquals(Double.compare(1.2d, Double.NEGATIVE_INFINITY), +1); + + assertEquals(Double.compare(0.0d, Double.NaN), -1); + assertEquals(Double.compare(0.0d, Double.POSITIVE_INFINITY), -1); + assertEquals(Double.compare(0.0d, Double.MAX_VALUE), -1); + assertEquals(Double.compare(0.0d, 1.2d), -1); + assertEquals(0, Double.compare(0.0d, 0.0d)); + assertEquals(Double.compare(0.0d, -0.0d), +1); + assertEquals(Double.compare(0.0d, -1.2d), +1); + assertEquals(Double.compare(0.0d, -Double.MAX_VALUE), +1); + assertEquals(Double.compare(0.0d, Double.NEGATIVE_INFINITY), +1); + + assertEquals(Double.compare(-0.0d, Double.NaN), -1); + assertEquals(Double.compare(-0.0d, Double.POSITIVE_INFINITY), -1); + assertEquals(Double.compare(-0.0d, Double.MAX_VALUE), -1); + assertEquals(Double.compare(-0.0d, 1.2d), -1); + assertEquals(Double.compare(-0.0d, 0.0d), -1); + assertEquals(0, Double.compare(-0.0d, -0.0d)); + assertEquals(Double.compare(-0.0d, -1.2d), +1); + assertEquals(Double.compare(-0.0d, -Double.MAX_VALUE), +1); + assertEquals(Double.compare(-0.0d, Double.NEGATIVE_INFINITY), +1); + + assertEquals(Double.compare(-1.2d, Double.NaN), -1); + assertEquals(Double.compare(-1.2d, Double.POSITIVE_INFINITY), -1); + assertEquals(Double.compare(-1.2d, Double.MAX_VALUE), -1); + assertEquals(Double.compare(-1.2d, 1.2d), -1); + assertEquals(Double.compare(-1.2d, 0.0d), -1); + assertEquals(Double.compare(-1.2d, -0.0d), -1); + assertEquals(0, Double.compare(-1.2d, -1.2d)); + assertEquals(Double.compare(-1.2d, -Double.MAX_VALUE), +1); + assertEquals(Double.compare(-1.2d, Double.NEGATIVE_INFINITY), +1); + + assertEquals(Double.compare(-Double.MAX_VALUE, Double.NaN), -1); + assertEquals(Double.compare(-Double.MAX_VALUE, Double.POSITIVE_INFINITY), -1); + assertEquals(Double.compare(-Double.MAX_VALUE, Double.MAX_VALUE), -1); + assertEquals(Double.compare(-Double.MAX_VALUE, 1.2d), -1); + assertEquals(Double.compare(-Double.MAX_VALUE, 0.0d), -1); + assertEquals(Double.compare(-Double.MAX_VALUE, -0.0d), -1); + assertEquals(Double.compare(-Double.MAX_VALUE, -1.2d), -1); + assertEquals(0, Double.compare(-Double.MAX_VALUE, -Double.MAX_VALUE)); + assertEquals(Double.compare(-Double.MAX_VALUE, Double.NEGATIVE_INFINITY), +1); + + assertEquals(Double.compare(Double.NEGATIVE_INFINITY, Double.NaN), -1); + assertEquals(Double.compare(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY), -1); + assertEquals(Double.compare(Double.NEGATIVE_INFINITY, Double.MAX_VALUE), -1); + assertEquals(Double.compare(Double.NEGATIVE_INFINITY, 1.2d), -1); + assertEquals(Double.compare(Double.NEGATIVE_INFINITY, 0.0d), -1); + assertEquals(Double.compare(Double.NEGATIVE_INFINITY, -0.0d), -1); + assertEquals(Double.compare(Double.NEGATIVE_INFINITY, -1.2d), -1); + assertEquals(Double.compare(Double.NEGATIVE_INFINITY, -Double.MAX_VALUE), -1); + assertEquals(0, Double.compare(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY)); } @Test public void testCompareFloat() { - assertTrue(Float.compare(Float.NaN, Float.NaN) == 0); - assertTrue(Float.compare(Float.NaN, Float.POSITIVE_INFINITY) == +1); - assertTrue(Float.compare(Float.NaN, Float.MAX_VALUE) == +1); - assertTrue(Float.compare(Float.NaN, 1.2f) == +1); - assertTrue(Float.compare(Float.NaN, 0.0f) == +1); - assertTrue(Float.compare(Float.NaN, -0.0f) == +1); - assertTrue(Float.compare(Float.NaN, -1.2f) == +1); - assertTrue(Float.compare(Float.NaN, -Float.MAX_VALUE) == +1); - assertTrue(Float.compare(Float.NaN, Float.NEGATIVE_INFINITY) == +1); - - assertTrue(Float.compare(Float.POSITIVE_INFINITY, Float.NaN) == -1); - assertTrue(Float.compare(Float.POSITIVE_INFINITY, Float.POSITIVE_INFINITY) == 0); - assertTrue(Float.compare(Float.POSITIVE_INFINITY, Float.MAX_VALUE) == +1); - assertTrue(Float.compare(Float.POSITIVE_INFINITY, 1.2f) == +1); - assertTrue(Float.compare(Float.POSITIVE_INFINITY, 0.0f) == +1); - assertTrue(Float.compare(Float.POSITIVE_INFINITY, -0.0f) == +1); - assertTrue(Float.compare(Float.POSITIVE_INFINITY, -1.2f) == +1); - assertTrue(Float.compare(Float.POSITIVE_INFINITY, -Float.MAX_VALUE) == +1); - assertTrue(Float.compare(Float.POSITIVE_INFINITY, Float.NEGATIVE_INFINITY) == +1); - - assertTrue(Float.compare(Float.MAX_VALUE, Float.NaN) == -1); - assertTrue(Float.compare(Float.MAX_VALUE, Float.POSITIVE_INFINITY) == -1); - assertTrue(Float.compare(Float.MAX_VALUE, Float.MAX_VALUE) == 0); - assertTrue(Float.compare(Float.MAX_VALUE, 1.2f) == +1); - assertTrue(Float.compare(Float.MAX_VALUE, 0.0f) == +1); - assertTrue(Float.compare(Float.MAX_VALUE, -0.0f) == +1); - assertTrue(Float.compare(Float.MAX_VALUE, -1.2f) == +1); - assertTrue(Float.compare(Float.MAX_VALUE, -Float.MAX_VALUE) == +1); - assertTrue(Float.compare(Float.MAX_VALUE, Float.NEGATIVE_INFINITY) == +1); - - assertTrue(Float.compare(1.2f, Float.NaN) == -1); - assertTrue(Float.compare(1.2f, Float.POSITIVE_INFINITY) == -1); - assertTrue(Float.compare(1.2f, Float.MAX_VALUE) == -1); - assertTrue(Float.compare(1.2f, 1.2f) == 0); - assertTrue(Float.compare(1.2f, 0.0f) == +1); - assertTrue(Float.compare(1.2f, -0.0f) == +1); - assertTrue(Float.compare(1.2f, -1.2f) == +1); - assertTrue(Float.compare(1.2f, -Float.MAX_VALUE) == +1); - assertTrue(Float.compare(1.2f, Float.NEGATIVE_INFINITY) == +1); - - assertTrue(Float.compare(0.0f, Float.NaN) == -1); - assertTrue(Float.compare(0.0f, Float.POSITIVE_INFINITY) == -1); - assertTrue(Float.compare(0.0f, Float.MAX_VALUE) == -1); - assertTrue(Float.compare(0.0f, 1.2f) == -1); - assertTrue(Float.compare(0.0f, 0.0f) == 0); - assertTrue(Float.compare(0.0f, -0.0f) == +1); - assertTrue(Float.compare(0.0f, -1.2f) == +1); - assertTrue(Float.compare(0.0f, -Float.MAX_VALUE) == +1); - assertTrue(Float.compare(0.0f, Float.NEGATIVE_INFINITY) == +1); - - assertTrue(Float.compare(-0.0f, Float.NaN) == -1); - assertTrue(Float.compare(-0.0f, Float.POSITIVE_INFINITY) == -1); - assertTrue(Float.compare(-0.0f, Float.MAX_VALUE) == -1); - assertTrue(Float.compare(-0.0f, 1.2f) == -1); - assertTrue(Float.compare(-0.0f, 0.0f) == -1); - assertTrue(Float.compare(-0.0f, -0.0f) == 0); - assertTrue(Float.compare(-0.0f, -1.2f) == +1); - assertTrue(Float.compare(-0.0f, -Float.MAX_VALUE) == +1); - assertTrue(Float.compare(-0.0f, Float.NEGATIVE_INFINITY) == +1); - - assertTrue(Float.compare(-1.2f, Float.NaN) == -1); - assertTrue(Float.compare(-1.2f, Float.POSITIVE_INFINITY) == -1); - assertTrue(Float.compare(-1.2f, Float.MAX_VALUE) == -1); - assertTrue(Float.compare(-1.2f, 1.2f) == -1); - assertTrue(Float.compare(-1.2f, 0.0f) == -1); - assertTrue(Float.compare(-1.2f, -0.0f) == -1); - assertTrue(Float.compare(-1.2f, -1.2f) == 0); - assertTrue(Float.compare(-1.2f, -Float.MAX_VALUE) == +1); - assertTrue(Float.compare(-1.2f, Float.NEGATIVE_INFINITY) == +1); - - assertTrue(Float.compare(-Float.MAX_VALUE, Float.NaN) == -1); - assertTrue(Float.compare(-Float.MAX_VALUE, Float.POSITIVE_INFINITY) == -1); - assertTrue(Float.compare(-Float.MAX_VALUE, Float.MAX_VALUE) == -1); - assertTrue(Float.compare(-Float.MAX_VALUE, 1.2f) == -1); - assertTrue(Float.compare(-Float.MAX_VALUE, 0.0f) == -1); - assertTrue(Float.compare(-Float.MAX_VALUE, -0.0f) == -1); - assertTrue(Float.compare(-Float.MAX_VALUE, -1.2f) == -1); - assertTrue(Float.compare(-Float.MAX_VALUE, -Float.MAX_VALUE) == 0); - assertTrue(Float.compare(-Float.MAX_VALUE, Float.NEGATIVE_INFINITY) == +1); - - assertTrue(Float.compare(Float.NEGATIVE_INFINITY, Float.NaN) == -1); - assertTrue(Float.compare(Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY) == -1); - assertTrue(Float.compare(Float.NEGATIVE_INFINITY, Float.MAX_VALUE) == -1); - assertTrue(Float.compare(Float.NEGATIVE_INFINITY, 1.2f) == -1); - assertTrue(Float.compare(Float.NEGATIVE_INFINITY, 0.0f) == -1); - assertTrue(Float.compare(Float.NEGATIVE_INFINITY, -0.0f) == -1); - assertTrue(Float.compare(Float.NEGATIVE_INFINITY, -1.2f) == -1); - assertTrue(Float.compare(Float.NEGATIVE_INFINITY, -Float.MAX_VALUE) == -1); - assertTrue(Float.compare(Float.NEGATIVE_INFINITY, Float.NEGATIVE_INFINITY) == 0); + assertEquals(0, Float.compare(Float.NaN, Float.NaN)); + assertEquals(Float.compare(Float.NaN, Float.POSITIVE_INFINITY), +1); + assertEquals(Float.compare(Float.NaN, Float.MAX_VALUE), +1); + assertEquals(Float.compare(Float.NaN, 1.2f), +1); + assertEquals(Float.compare(Float.NaN, 0.0f), +1); + assertEquals(Float.compare(Float.NaN, -0.0f), +1); + assertEquals(Float.compare(Float.NaN, -1.2f), +1); + assertEquals(Float.compare(Float.NaN, -Float.MAX_VALUE), +1); + assertEquals(Float.compare(Float.NaN, Float.NEGATIVE_INFINITY), +1); + + assertEquals(Float.compare(Float.POSITIVE_INFINITY, Float.NaN), -1); + assertEquals(0, Float.compare(Float.POSITIVE_INFINITY, Float.POSITIVE_INFINITY)); + assertEquals(Float.compare(Float.POSITIVE_INFINITY, Float.MAX_VALUE), +1); + assertEquals(Float.compare(Float.POSITIVE_INFINITY, 1.2f), +1); + assertEquals(Float.compare(Float.POSITIVE_INFINITY, 0.0f), +1); + assertEquals(Float.compare(Float.POSITIVE_INFINITY, -0.0f), +1); + assertEquals(Float.compare(Float.POSITIVE_INFINITY, -1.2f), +1); + assertEquals(Float.compare(Float.POSITIVE_INFINITY, -Float.MAX_VALUE), +1); + assertEquals(Float.compare(Float.POSITIVE_INFINITY, Float.NEGATIVE_INFINITY), +1); + + assertEquals(Float.compare(Float.MAX_VALUE, Float.NaN), -1); + assertEquals(Float.compare(Float.MAX_VALUE, Float.POSITIVE_INFINITY), -1); + assertEquals(0, Float.compare(Float.MAX_VALUE, Float.MAX_VALUE)); + assertEquals(Float.compare(Float.MAX_VALUE, 1.2f), +1); + assertEquals(Float.compare(Float.MAX_VALUE, 0.0f), +1); + assertEquals(Float.compare(Float.MAX_VALUE, -0.0f), +1); + assertEquals(Float.compare(Float.MAX_VALUE, -1.2f), +1); + assertEquals(Float.compare(Float.MAX_VALUE, -Float.MAX_VALUE), +1); + assertEquals(Float.compare(Float.MAX_VALUE, Float.NEGATIVE_INFINITY), +1); + + assertEquals(Float.compare(1.2f, Float.NaN), -1); + assertEquals(Float.compare(1.2f, Float.POSITIVE_INFINITY), -1); + assertEquals(Float.compare(1.2f, Float.MAX_VALUE), -1); + assertEquals(0, Float.compare(1.2f, 1.2f)); + assertEquals(Float.compare(1.2f, 0.0f), +1); + assertEquals(Float.compare(1.2f, -0.0f), +1); + assertEquals(Float.compare(1.2f, -1.2f), +1); + assertEquals(Float.compare(1.2f, -Float.MAX_VALUE), +1); + assertEquals(Float.compare(1.2f, Float.NEGATIVE_INFINITY), +1); + + assertEquals(Float.compare(0.0f, Float.NaN), -1); + assertEquals(Float.compare(0.0f, Float.POSITIVE_INFINITY), -1); + assertEquals(Float.compare(0.0f, Float.MAX_VALUE), -1); + assertEquals(Float.compare(0.0f, 1.2f), -1); + assertEquals(0, Float.compare(0.0f, 0.0f)); + assertEquals(Float.compare(0.0f, -0.0f), +1); + assertEquals(Float.compare(0.0f, -1.2f), +1); + assertEquals(Float.compare(0.0f, -Float.MAX_VALUE), +1); + assertEquals(Float.compare(0.0f, Float.NEGATIVE_INFINITY), +1); + + assertEquals(Float.compare(-0.0f, Float.NaN), -1); + assertEquals(Float.compare(-0.0f, Float.POSITIVE_INFINITY), -1); + assertEquals(Float.compare(-0.0f, Float.MAX_VALUE), -1); + assertEquals(Float.compare(-0.0f, 1.2f), -1); + assertEquals(Float.compare(-0.0f, 0.0f), -1); + assertEquals(0, Float.compare(-0.0f, -0.0f)); + assertEquals(Float.compare(-0.0f, -1.2f), +1); + assertEquals(Float.compare(-0.0f, -Float.MAX_VALUE), +1); + assertEquals(Float.compare(-0.0f, Float.NEGATIVE_INFINITY), +1); + + assertEquals(Float.compare(-1.2f, Float.NaN), -1); + assertEquals(Float.compare(-1.2f, Float.POSITIVE_INFINITY), -1); + assertEquals(Float.compare(-1.2f, Float.MAX_VALUE), -1); + assertEquals(Float.compare(-1.2f, 1.2f), -1); + assertEquals(Float.compare(-1.2f, 0.0f), -1); + assertEquals(Float.compare(-1.2f, -0.0f), -1); + assertEquals(0, Float.compare(-1.2f, -1.2f)); + assertEquals(Float.compare(-1.2f, -Float.MAX_VALUE), +1); + assertEquals(Float.compare(-1.2f, Float.NEGATIVE_INFINITY), +1); + + assertEquals(Float.compare(-Float.MAX_VALUE, Float.NaN), -1); + assertEquals(Float.compare(-Float.MAX_VALUE, Float.POSITIVE_INFINITY), -1); + assertEquals(Float.compare(-Float.MAX_VALUE, Float.MAX_VALUE), -1); + assertEquals(Float.compare(-Float.MAX_VALUE, 1.2f), -1); + assertEquals(Float.compare(-Float.MAX_VALUE, 0.0f), -1); + assertEquals(Float.compare(-Float.MAX_VALUE, -0.0f), -1); + assertEquals(Float.compare(-Float.MAX_VALUE, -1.2f), -1); + assertEquals(0, Float.compare(-Float.MAX_VALUE, -Float.MAX_VALUE)); + assertEquals(Float.compare(-Float.MAX_VALUE, Float.NEGATIVE_INFINITY), +1); + + assertEquals(Float.compare(Float.NEGATIVE_INFINITY, Float.NaN), -1); + assertEquals(Float.compare(Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY), -1); + assertEquals(Float.compare(Float.NEGATIVE_INFINITY, Float.MAX_VALUE), -1); + assertEquals(Float.compare(Float.NEGATIVE_INFINITY, 1.2f), -1); + assertEquals(Float.compare(Float.NEGATIVE_INFINITY, 0.0f), -1); + assertEquals(Float.compare(Float.NEGATIVE_INFINITY, -0.0f), -1); + assertEquals(Float.compare(Float.NEGATIVE_INFINITY, -1.2f), -1); + assertEquals(Float.compare(Float.NEGATIVE_INFINITY, -Float.MAX_VALUE), -1); + assertEquals(0, Float.compare(Float.NEGATIVE_INFINITY, Float.NEGATIVE_INFINITY)); } @Test @@ -1558,23 +1511,23 @@ public class NumberUtilsTest { assertTrue(NumberUtils.FLOAT_ONE instanceof Float); assertTrue(NumberUtils.FLOAT_MINUS_ONE instanceof Float); - assertTrue(NumberUtils.LONG_ZERO.longValue() == 0); - assertTrue(NumberUtils.LONG_ONE.longValue() == 1); - assertTrue(NumberUtils.LONG_MINUS_ONE.longValue() == -1); - assertTrue(NumberUtils.INTEGER_ZERO.intValue() == 0); - assertTrue(NumberUtils.INTEGER_ONE.intValue() == 1); - assertTrue(NumberUtils.INTEGER_MINUS_ONE.intValue() == -1); - assertTrue(NumberUtils.SHORT_ZERO.shortValue() == 0); - assertTrue(NumberUtils.SHORT_ONE.shortValue() == 1); - assertTrue(NumberUtils.SHORT_MINUS_ONE.shortValue() == -1); - assertTrue(NumberUtils.BYTE_ZERO.byteValue() == 0); - assertTrue(NumberUtils.BYTE_ONE.byteValue() == 1); - assertTrue(NumberUtils.BYTE_MINUS_ONE.byteValue() == -1); - assertTrue(NumberUtils.DOUBLE_ZERO.doubleValue() == 0.0d); - assertTrue(NumberUtils.DOUBLE_ONE.doubleValue() == 1.0d); + assertEquals(0, NumberUtils.LONG_ZERO.longValue()); + assertEquals(1, NumberUtils.LONG_ONE.longValue()); + assertEquals(NumberUtils.LONG_MINUS_ONE.longValue(), -1); + assertEquals(0, NumberUtils.INTEGER_ZERO.intValue()); + assertEquals(1, NumberUtils.INTEGER_ONE.intValue()); + assertEquals(NumberUtils.INTEGER_MINUS_ONE.intValue(), -1); + assertEquals(0, NumberUtils.SHORT_ZERO.shortValue()); + assertEquals(1, NumberUtils.SHORT_ONE.shortValue()); + assertEquals(NumberUtils.SHORT_MINUS_ONE.shortValue(), -1); + assertEquals(0, NumberUtils.BYTE_ZERO.byteValue()); + assertEquals(1, NumberUtils.BYTE_ONE.byteValue()); + assertEquals(NumberUtils.BYTE_MINUS_ONE.byteValue(), -1); + assertTrue(0.0d == NumberUtils.DOUBLE_ZERO.doubleValue()); + assertTrue(1.0d == NumberUtils.DOUBLE_ONE.doubleValue()); assertTrue(NumberUtils.DOUBLE_MINUS_ONE.doubleValue() == -1.0d); - assertTrue(NumberUtils.FLOAT_ZERO.floatValue() == 0.0f); - assertTrue(NumberUtils.FLOAT_ONE.floatValue() == 1.0f); + assertTrue(0.0f == NumberUtils.FLOAT_ZERO.floatValue()); + assertTrue(1.0f == NumberUtils.FLOAT_ONE.floatValue()); assertTrue(NumberUtils.FLOAT_MINUS_ONE.floatValue() == -1.0f); } @@ -1610,28 +1563,28 @@ public class NumberUtilsTest { @Test public void compareInt() { assertTrue(NumberUtils.compare(-3, 0) < 0); - assertTrue(NumberUtils.compare(113, 113)==0); + assertEquals(0, NumberUtils.compare(113, 113)); assertTrue(NumberUtils.compare(213, 32) > 0); } @Test public void compareLong() { assertTrue(NumberUtils.compare(-3L, 0L) < 0); - assertTrue(NumberUtils.compare(113L, 113L)==0); + assertEquals(0, NumberUtils.compare(113L, 113L)); assertTrue(NumberUtils.compare(213L, 32L) > 0); } @Test public void compareShort() { assertTrue(NumberUtils.compare((short)-3, (short)0) < 0); - assertTrue(NumberUtils.compare((short)113, (short)113)==0); + assertEquals(0, NumberUtils.compare((short) 113, (short) 113)); assertTrue(NumberUtils.compare((short)213, (short)32) > 0); } @Test public void compareByte() { assertTrue(NumberUtils.compare((byte)-3, (byte)0) < 0); - assertTrue(NumberUtils.compare((byte)113, (byte)113)==0); + assertEquals(0, NumberUtils.compare((byte) 113, (byte) 113)); assertTrue(NumberUtils.compare((byte)123, (byte)32) > 0); } } http://git-wip-us.apache.org/repos/asf/commons-lang/blob/3609993f/src/test/java/org/apache/commons/lang3/mutable/MutableBooleanTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/lang3/mutable/MutableBooleanTest.java b/src/test/java/org/apache/commons/lang3/mutable/MutableBooleanTest.java index c7634d8..7f345af 100644 --- a/src/test/java/org/apache/commons/lang3/mutable/MutableBooleanTest.java +++ b/src/test/java/org/apache/commons/lang3/mutable/MutableBooleanTest.java @@ -21,6 +21,7 @@ import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotEquals; import static org.junit.jupiter.api.Assertions.assertThrows; import static org.junit.jupiter.api.Assertions.assertTrue; @@ -73,16 +74,16 @@ public class MutableBooleanTest { final MutableBoolean mutBoolB = new MutableBoolean(false); final MutableBoolean mutBoolC = new MutableBoolean(true); - assertTrue(mutBoolA.equals(mutBoolA)); - assertTrue(mutBoolA.equals(mutBoolB)); - assertTrue(mutBoolB.equals(mutBoolA)); - assertTrue(mutBoolB.equals(mutBoolB)); - assertFalse(mutBoolA.equals(mutBoolC)); - assertFalse(mutBoolB.equals(mutBoolC)); - assertTrue(mutBoolC.equals(mutBoolC)); - assertFalse(mutBoolA.equals(null)); - assertFalse(mutBoolA.equals(Boolean.FALSE)); - assertFalse(mutBoolA.equals("false")); + assertEquals(mutBoolA, mutBoolA); + assertEquals(mutBoolA, mutBoolB); + assertEquals(mutBoolB, mutBoolA); + assertEquals(mutBoolB, mutBoolB); + assertNotEquals(mutBoolA, mutBoolC); + assertNotEquals(mutBoolB, mutBoolC); + assertEquals(mutBoolC, mutBoolC); + assertNotEquals(null, mutBoolA); + assertNotEquals(mutBoolA, Boolean.FALSE); + assertNotEquals("false", mutBoolA); } @Test http://git-wip-us.apache.org/repos/asf/commons-lang/blob/3609993f/src/test/java/org/apache/commons/lang3/mutable/MutableByteTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/lang3/mutable/MutableByteTest.java b/src/test/java/org/apache/commons/lang3/mutable/MutableByteTest.java index 91ad38c..7f5d412 100644 --- a/src/test/java/org/apache/commons/lang3/mutable/MutableByteTest.java +++ b/src/test/java/org/apache/commons/lang3/mutable/MutableByteTest.java @@ -20,6 +20,7 @@ import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotEquals; import static org.junit.jupiter.api.Assertions.assertThrows; import static org.junit.jupiter.api.Assertions.assertTrue; @@ -80,16 +81,16 @@ public class MutableByteTest { final MutableByte mutNumB = new MutableByte((byte) 0); final MutableByte mutNumC = new MutableByte((byte) 1); - assertTrue(mutNumA.equals(mutNumA)); - assertTrue(mutNumA.equals(mutNumB)); - assertTrue(mutNumB.equals(mutNumA)); - assertTrue(mutNumB.equals(mutNumB)); - assertFalse(mutNumA.equals(mutNumC)); - assertFalse(mutNumB.equals(mutNumC)); - assertTrue(mutNumC.equals(mutNumC)); - assertFalse(mutNumA.equals(null)); - assertFalse(mutNumA.equals(Byte.valueOf((byte) 0))); - assertFalse(mutNumA.equals("0")); + assertEquals(mutNumA, mutNumA); + assertEquals(mutNumA, mutNumB); + assertEquals(mutNumB, mutNumA); + assertEquals(mutNumB, mutNumB); + assertNotEquals(mutNumA, mutNumC); + assertNotEquals(mutNumB, mutNumC); + assertEquals(mutNumC, mutNumC); + assertNotEquals(null, mutNumA); + assertNotEquals(mutNumA, Byte.valueOf((byte) 0)); + assertNotEquals("0", mutNumA); } @Test @@ -98,10 +99,10 @@ public class MutableByteTest { final MutableByte mutNumB = new MutableByte((byte) 0); final MutableByte mutNumC = new MutableByte((byte) 1); - assertTrue(mutNumA.hashCode() == mutNumA.hashCode()); - assertTrue(mutNumA.hashCode() == mutNumB.hashCode()); + assertEquals(mutNumA.hashCode(), mutNumA.hashCode()); + assertEquals(mutNumA.hashCode(), mutNumB.hashCode()); assertFalse(mutNumA.hashCode() == mutNumC.hashCode()); - assertTrue(mutNumA.hashCode() == Byte.valueOf((byte) 0).hashCode()); + assertEquals(mutNumA.hashCode(), Byte.valueOf((byte) 0).hashCode()); } @Test http://git-wip-us.apache.org/repos/asf/commons-lang/blob/3609993f/src/test/java/org/apache/commons/lang3/mutable/MutableDoubleTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/lang3/mutable/MutableDoubleTest.java b/src/test/java/org/apache/commons/lang3/mutable/MutableDoubleTest.java index 378379a..5bb417d 100644 --- a/src/test/java/org/apache/commons/lang3/mutable/MutableDoubleTest.java +++ b/src/test/java/org/apache/commons/lang3/mutable/MutableDoubleTest.java @@ -20,6 +20,7 @@ import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotEquals; import static org.junit.jupiter.api.Assertions.assertThrows; import static org.junit.jupiter.api.Assertions.assertTrue; @@ -92,16 +93,16 @@ public class MutableDoubleTest { final MutableDouble mutNumB = new MutableDouble(0d); final MutableDouble mutNumC = new MutableDouble(1d); - assertTrue(mutNumA.equals(mutNumA)); - assertTrue(mutNumA.equals(mutNumB)); - assertTrue(mutNumB.equals(mutNumA)); - assertTrue(mutNumB.equals(mutNumB)); - assertFalse(mutNumA.equals(mutNumC)); - assertFalse(mutNumB.equals(mutNumC)); - assertTrue(mutNumC.equals(mutNumC)); - assertFalse(mutNumA.equals(null)); - assertFalse(mutNumA.equals(Double.valueOf(0d))); - assertFalse(mutNumA.equals("0")); + assertEquals(mutNumA, mutNumA); + assertEquals(mutNumA, mutNumB); + assertEquals(mutNumB, mutNumA); + assertEquals(mutNumB, mutNumB); + assertNotEquals(mutNumA, mutNumC); + assertNotEquals(mutNumB, mutNumC); + assertEquals(mutNumC, mutNumC); + assertNotEquals(null, mutNumA); + assertNotEquals(mutNumA, Double.valueOf(0d)); + assertNotEquals("0", mutNumA); } @Test @@ -110,10 +111,10 @@ public class MutableDoubleTest { final MutableDouble mutNumB = new MutableDouble(0d); final MutableDouble mutNumC = new MutableDouble(1d); - assertTrue(mutNumA.hashCode() == mutNumA.hashCode()); - assertTrue(mutNumA.hashCode() == mutNumB.hashCode()); + assertEquals(mutNumA.hashCode(), mutNumA.hashCode()); + assertEquals(mutNumA.hashCode(), mutNumB.hashCode()); assertFalse(mutNumA.hashCode() == mutNumC.hashCode()); - assertTrue(mutNumA.hashCode() == Double.valueOf(0d).hashCode()); + assertEquals(mutNumA.hashCode(), Double.valueOf(0d).hashCode()); } @Test http://git-wip-us.apache.org/repos/asf/commons-lang/blob/3609993f/src/test/java/org/apache/commons/lang3/mutable/MutableFloatTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/lang3/mutable/MutableFloatTest.java b/src/test/java/org/apache/commons/lang3/mutable/MutableFloatTest.java index 96fbcdd..4b479ec 100644 --- a/src/test/java/org/apache/commons/lang3/mutable/MutableFloatTest.java +++ b/src/test/java/org/apache/commons/lang3/mutable/MutableFloatTest.java @@ -20,6 +20,7 @@ import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotEquals; import static org.junit.jupiter.api.Assertions.assertThrows; import static org.junit.jupiter.api.Assertions.assertTrue; @@ -92,16 +93,16 @@ public class MutableFloatTest { final MutableFloat mutNumB = new MutableFloat(0f); final MutableFloat mutNumC = new MutableFloat(1f); - assertTrue(mutNumA.equals(mutNumA)); - assertTrue(mutNumA.equals(mutNumB)); - assertTrue(mutNumB.equals(mutNumA)); - assertTrue(mutNumB.equals(mutNumB)); - assertFalse(mutNumA.equals(mutNumC)); - assertFalse(mutNumB.equals(mutNumC)); - assertTrue(mutNumC.equals(mutNumC)); - assertFalse(mutNumA.equals(null)); - assertFalse(mutNumA.equals(Float.valueOf(0f))); - assertFalse(mutNumA.equals("0")); + assertEquals(mutNumA, mutNumA); + assertEquals(mutNumA, mutNumB); + assertEquals(mutNumB, mutNumA); + assertEquals(mutNumB, mutNumB); + assertNotEquals(mutNumA, mutNumC); + assertNotEquals(mutNumB, mutNumC); + assertEquals(mutNumC, mutNumC); + assertNotEquals(null, mutNumA); + assertNotEquals(mutNumA, Float.valueOf(0f)); + assertNotEquals("0", mutNumA); } @Test @@ -110,10 +111,10 @@ public class MutableFloatTest { final MutableFloat mutNumB = new MutableFloat(0f); final MutableFloat mutNumC = new MutableFloat(1f); - assertTrue(mutNumA.hashCode() == mutNumA.hashCode()); - assertTrue(mutNumA.hashCode() == mutNumB.hashCode()); + assertEquals(mutNumA.hashCode(), mutNumA.hashCode()); + assertEquals(mutNumA.hashCode(), mutNumB.hashCode()); assertFalse(mutNumA.hashCode() == mutNumC.hashCode()); - assertTrue(mutNumA.hashCode() == Float.valueOf(0f).hashCode()); + assertEquals(mutNumA.hashCode(), Float.valueOf(0f).hashCode()); } @Test http://git-wip-us.apache.org/repos/asf/commons-lang/blob/3609993f/src/test/java/org/apache/commons/lang3/mutable/MutableIntTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/lang3/mutable/MutableIntTest.java b/src/test/java/org/apache/commons/lang3/mutable/MutableIntTest.java index f3100d3..27eb976 100644 --- a/src/test/java/org/apache/commons/lang3/mutable/MutableIntTest.java +++ b/src/test/java/org/apache/commons/lang3/mutable/MutableIntTest.java @@ -20,6 +20,7 @@ import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotEquals; import static org.junit.jupiter.api.Assertions.assertThrows; import static org.junit.jupiter.api.Assertions.assertTrue; @@ -87,16 +88,16 @@ public class MutableIntTest { * @param numC must not equal numA; must not equal numC. */ void testEquals(final Number numA, final Number numB, final Number numC) { - assertTrue(numA.equals(numA)); - assertTrue(numA.equals(numB)); - assertTrue(numB.equals(numA)); - assertTrue(numB.equals(numB)); - assertFalse(numA.equals(numC)); - assertFalse(numB.equals(numC)); - assertTrue(numC.equals(numC)); - assertFalse(numA.equals(null)); - assertFalse(numA.equals(Integer.valueOf(0))); - assertFalse(numA.equals("0")); + assertEquals(numA, numA); + assertEquals(numA, numB); + assertEquals(numB, numA); + assertEquals(numB, numB); + assertNotEquals(numA, numC); + assertNotEquals(numB, numC); + assertEquals(numC, numC); + assertNotEquals(null, numA); + assertNotEquals(numA, Integer.valueOf(0)); + assertNotEquals("0", numA); } @Test @@ -105,10 +106,10 @@ public class MutableIntTest { final MutableInt mutNumB = new MutableInt(0); final MutableInt mutNumC = new MutableInt(1); - assertTrue(mutNumA.hashCode() == mutNumA.hashCode()); - assertTrue(mutNumA.hashCode() == mutNumB.hashCode()); + assertEquals(mutNumA.hashCode(), mutNumA.hashCode()); + assertEquals(mutNumA.hashCode(), mutNumB.hashCode()); assertFalse(mutNumA.hashCode() == mutNumC.hashCode()); - assertTrue(mutNumA.hashCode() == Integer.valueOf(0).hashCode()); + assertEquals(mutNumA.hashCode(), Integer.valueOf(0).hashCode()); } @Test http://git-wip-us.apache.org/repos/asf/commons-lang/blob/3609993f/src/test/java/org/apache/commons/lang3/mutable/MutableLongTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/lang3/mutable/MutableLongTest.java b/src/test/java/org/apache/commons/lang3/mutable/MutableLongTest.java index 2ad7ea9..15ed28e 100644 --- a/src/test/java/org/apache/commons/lang3/mutable/MutableLongTest.java +++ b/src/test/java/org/apache/commons/lang3/mutable/MutableLongTest.java @@ -20,6 +20,7 @@ import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotEquals; import static org.junit.jupiter.api.Assertions.assertThrows; import static org.junit.jupiter.api.Assertions.assertTrue; @@ -80,16 +81,16 @@ public class MutableLongTest { final MutableLong mutNumB = new MutableLong(0); final MutableLong mutNumC = new MutableLong(1); - assertTrue(mutNumA.equals(mutNumA)); - assertTrue(mutNumA.equals(mutNumB)); - assertTrue(mutNumB.equals(mutNumA)); - assertTrue(mutNumB.equals(mutNumB)); - assertFalse(mutNumA.equals(mutNumC)); - assertFalse(mutNumB.equals(mutNumC)); - assertTrue(mutNumC.equals(mutNumC)); - assertFalse(mutNumA.equals(null)); - assertFalse(mutNumA.equals(Long.valueOf(0))); - assertFalse(mutNumA.equals("0")); + assertEquals(mutNumA, mutNumA); + assertEquals(mutNumA, mutNumB); + assertEquals(mutNumB, mutNumA); + assertEquals(mutNumB, mutNumB); + assertNotEquals(mutNumA, mutNumC); + assertNotEquals(mutNumB, mutNumC); + assertEquals(mutNumC, mutNumC); + assertNotEquals(null, mutNumA); + assertNotEquals(mutNumA, Long.valueOf(0)); + assertNotEquals("0", mutNumA); } @Test @@ -98,10 +99,10 @@ public class MutableLongTest { final MutableLong mutNumB = new MutableLong(0); final MutableLong mutNumC = new MutableLong(1); - assertTrue(mutNumA.hashCode() == mutNumA.hashCode()); - assertTrue(mutNumA.hashCode() == mutNumB.hashCode()); + assertEquals(mutNumA.hashCode(), mutNumA.hashCode()); + assertEquals(mutNumA.hashCode(), mutNumB.hashCode()); assertFalse(mutNumA.hashCode() == mutNumC.hashCode()); - assertTrue(mutNumA.hashCode() == Long.valueOf(0).hashCode()); + assertEquals(mutNumA.hashCode(), Long.valueOf(0).hashCode()); } @Test http://git-wip-us.apache.org/repos/asf/commons-lang/blob/3609993f/src/test/java/org/apache/commons/lang3/mutable/MutableShortTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/lang3/mutable/MutableShortTest.java b/src/test/java/org/apache/commons/lang3/mutable/MutableShortTest.java index 78ffe63..08df298 100644 --- a/src/test/java/org/apache/commons/lang3/mutable/MutableShortTest.java +++ b/src/test/java/org/apache/commons/lang3/mutable/MutableShortTest.java @@ -20,6 +20,7 @@ import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotEquals; import static org.junit.jupiter.api.Assertions.assertThrows; import static org.junit.jupiter.api.Assertions.assertTrue; @@ -71,16 +72,16 @@ public class MutableShortTest { final MutableShort mutNumB = new MutableShort((short) 0); final MutableShort mutNumC = new MutableShort((short) 1); - assertTrue(mutNumA.equals(mutNumA)); - assertTrue(mutNumA.equals(mutNumB)); - assertTrue(mutNumB.equals(mutNumA)); - assertTrue(mutNumB.equals(mutNumB)); - assertFalse(mutNumA.equals(mutNumC)); - assertFalse(mutNumB.equals(mutNumC)); - assertTrue(mutNumC.equals(mutNumC)); - assertFalse(mutNumA.equals(null)); - assertFalse(mutNumA.equals(Short.valueOf((short) 0))); - assertFalse(mutNumA.equals("0")); + assertEquals(mutNumA, mutNumA); + assertEquals(mutNumA, mutNumB); + assertEquals(mutNumB, mutNumA); + assertEquals(mutNumB, mutNumB); + assertNotEquals(mutNumA, mutNumC); + assertNotEquals(mutNumB, mutNumC); + assertEquals(mutNumC, mutNumC); + assertNotEquals(null, mutNumA); + assertNotEquals(mutNumA, Short.valueOf((short) 0)); + assertNotEquals("0", mutNumA); } @Test @@ -89,10 +90,10 @@ public class MutableShortTest { final MutableShort mutNumB = new MutableShort((short) 0); final MutableShort mutNumC = new MutableShort((short) 1); - assertTrue(mutNumA.hashCode() == mutNumA.hashCode()); - assertTrue(mutNumA.hashCode() == mutNumB.hashCode()); + assertEquals(mutNumA.hashCode(), mutNumA.hashCode()); + assertEquals(mutNumA.hashCode(), mutNumB.hashCode()); assertFalse(mutNumA.hashCode() == mutNumC.hashCode()); - assertTrue(mutNumA.hashCode() == Short.valueOf((short) 0).hashCode()); + assertEquals(mutNumA.hashCode(), Short.valueOf((short) 0).hashCode()); } @Test http://git-wip-us.apache.org/repos/asf/commons-lang/blob/3609993f/src/test/java/org/apache/commons/lang3/text/ExtendedMessageFormatTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/lang3/text/ExtendedMessageFormatTest.java b/src/test/java/org/apache/commons/lang3/text/ExtendedMessageFormatTest.java index efa5970..6249765 100644 --- a/src/test/java/org/apache/commons/lang3/text/ExtendedMessageFormatTest.java +++ b/src/test/java/org/apache/commons/lang3/text/ExtendedMessageFormatTest.java @@ -21,7 +21,7 @@ import org.junit.jupiter.api.BeforeEach; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.assertNotEquals; import java.text.DateFormat; import java.text.FieldPosition; @@ -301,33 +301,33 @@ public class ExtendedMessageFormatTest { ExtendedMessageFormat other = null; // Same object - assertTrue(emf.equals(emf), "same, equals()"); - assertTrue(emf.hashCode() == emf.hashCode(), "same, hashcode()"); + assertEquals(emf, emf, "same, equals()"); + assertEquals(emf.hashCode(), emf.hashCode(), "same, hashcode()"); // Equal Object other = new ExtendedMessageFormat(pattern, Locale.US, fmtRegistry); - assertTrue(emf.equals(other), "equal, equals()"); - assertTrue(emf.hashCode() == other.hashCode(), "equal, hashcode()"); + assertEquals(emf, other, "equal, equals()"); + assertEquals(emf.hashCode(), other.hashCode(), "equal, hashcode()"); // Different Class other = new OtherExtendedMessageFormat(pattern, Locale.US, fmtRegistry); - assertFalse(emf.equals(other), "class, equals()"); - assertTrue(emf.hashCode() == other.hashCode(), "class, hashcode()"); // same hashcode + assertNotEquals(emf, other, "class, equals()"); + assertEquals(emf.hashCode(), other.hashCode(), "class, hashcode()"); // same hashcode // Different pattern other = new ExtendedMessageFormat("X" + pattern, Locale.US, fmtRegistry); - assertFalse(emf.equals(other), "pattern, equals()"); + assertNotEquals(emf, other, "pattern, equals()"); assertFalse(emf.hashCode() == other.hashCode(), "pattern, hashcode()"); // Different registry other = new ExtendedMessageFormat(pattern, Locale.US, otherRegitry); - assertFalse(emf.equals(other), "registry, equals()"); + assertNotEquals(emf, other, "registry, equals()"); assertFalse(emf.hashCode() == other.hashCode(), "registry, hashcode()"); // Different Locale other = new ExtendedMessageFormat(pattern, Locale.FRANCE, fmtRegistry); - assertFalse(emf.equals(other), "locale, equals()"); - assertTrue(emf.hashCode() == other.hashCode(), "locale, hashcode()"); // same hashcode + assertNotEquals(emf, other, "locale, equals()"); + assertEquals(emf.hashCode(), other.hashCode(), "locale, hashcode()"); // same hashcode } /** http://git-wip-us.apache.org/repos/asf/commons-lang/blob/3609993f/src/test/java/org/apache/commons/lang3/text/StrBuilderTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/lang3/text/StrBuilderTest.java b/src/test/java/org/apache/commons/lang3/text/StrBuilderTest.java index b09065f..025456d 100644 --- a/src/test/java/org/apache/commons/lang3/text/StrBuilderTest.java +++ b/src/test/java/org/apache/commons/lang3/text/StrBuilderTest.java @@ -21,6 +21,7 @@ import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotEquals; import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertNotSame; import static org.junit.jupiter.api.Assertions.assertNull; @@ -241,7 +242,7 @@ public class StrBuilderTest { assertTrue(sb.capacity() >= 32); assertEquals(3, sb.length()); assertEquals(3, sb.size()); - assertTrue(sb.isEmpty() == false); + assertFalse(sb.isEmpty()); sb.clear(); assertTrue(sb.capacity() >= 32); @@ -253,19 +254,19 @@ public class StrBuilderTest { assertTrue(sb.capacity() > 32); assertEquals(33, sb.length()); assertEquals(33, sb.size()); - assertTrue(sb.isEmpty() == false); + assertFalse(sb.isEmpty()); sb.ensureCapacity(16); assertTrue(sb.capacity() > 16); assertEquals(33, sb.length()); assertEquals(33, sb.size()); - assertTrue(sb.isEmpty() == false); + assertFalse(sb.isEmpty()); sb.minimizeCapacity(); assertEquals(33, sb.capacity()); assertEquals(33, sb.length()); assertEquals(33, sb.size()); - assertTrue(sb.isEmpty() == false); + assertFalse(sb.isEmpty()); assertThrows( IndexOutOfBoundsException.class, @@ -276,21 +277,21 @@ public class StrBuilderTest { assertEquals(33, sb.capacity()); assertEquals(33, sb.length()); assertEquals(33, sb.size()); - assertTrue(sb.isEmpty() == false); + assertFalse(sb.isEmpty()); sb.setLength(16); assertTrue(sb.capacity() >= 16); assertEquals(16, sb.length()); assertEquals(16, sb.size()); assertEquals("1234567890123456", sb.toString()); - assertTrue(sb.isEmpty() == false); + assertFalse(sb.isEmpty()); sb.setLength(32); assertTrue(sb.capacity() >= 32); assertEquals(32, sb.length()); assertEquals(32, sb.size()); assertEquals("1234567890123456\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", sb.toString()); - assertTrue(sb.isEmpty() == false); + assertFalse(sb.isEmpty()); sb.setLength(0); assertTrue(sb.capacity() >= 32); @@ -1721,22 +1722,22 @@ public class StrBuilderTest { assertTrue(sb1.equals(sb2)); assertTrue(sb1.equals(sb1)); assertTrue(sb2.equals(sb2)); - assertTrue(sb1.equals((Object) sb2)); + assertEquals(sb1, (Object) sb2); sb1.append("abc"); assertFalse(sb1.equals(sb2)); - assertFalse(sb1.equals((Object) sb2)); + assertNotEquals(sb1, (Object) sb2); sb2.append("ABC"); assertFalse(sb1.equals(sb2)); - assertFalse(sb1.equals((Object) sb2)); + assertNotEquals(sb1, (Object) sb2); sb2.clear().append("abc"); assertTrue(sb1.equals(sb2)); - assertTrue(sb1.equals((Object) sb2)); + assertEquals(sb1, (Object) sb2); - assertFalse(sb1.equals(Integer.valueOf(1))); - assertFalse(sb1.equals("abc")); + assertNotEquals(sb1, Integer.valueOf(1)); + assertNotEquals("abc", sb1); } @Test http://git-wip-us.apache.org/repos/asf/commons-lang/blob/3609993f/src/test/java/org/apache/commons/lang3/text/StrTokenizerTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/lang3/text/StrTokenizerTest.java b/src/test/java/org/apache/commons/lang3/text/StrTokenizerTest.java index c43df01..4065550 100644 --- a/src/test/java/org/apache/commons/lang3/text/StrTokenizerTest.java +++ b/src/test/java/org/apache/commons/lang3/text/StrTokenizerTest.java @@ -21,6 +21,7 @@ import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotSame; import static org.junit.jupiter.api.Assertions.assertNull; import static org.junit.jupiter.api.Assertions.assertThrows; import static org.junit.jupiter.api.Assertions.assertTrue; @@ -43,8 +44,8 @@ public class StrTokenizerTest { private static final String TSV_SIMPLE_FIXTURE = "A\tb\tc"; private void checkClone(final StrTokenizer tokenizer) { - assertFalse(StrTokenizer.getCSVInstance() == tokenizer); - assertFalse(StrTokenizer.getTSVInstance() == tokenizer); + assertNotSame(StrTokenizer.getCSVInstance(), tokenizer); + assertNotSame(StrTokenizer.getTSVInstance(), tokenizer); } // ----------------------------------------------------------------------- @@ -182,11 +183,9 @@ public class StrTokenizerTest { assertEquals(expected.length, tokens.length, ArrayUtils.toString(tokens)); - assertTrue(nextCount == expected.length, - "could not cycle through entire token list" + " using the 'hasNext' and 'next' methods"); + assertEquals(nextCount, expected.length, "could not cycle through entire token list" + " using the 'hasNext' and 'next' methods"); - assertTrue(prevCount == expected.length, - "could not cycle through entire token list" + " using the 'hasPrevious' and 'previous' methods"); + assertEquals(prevCount, expected.length, "could not cycle through entire token list" + " using the 'hasPrevious' and 'previous' methods"); }
