This is an automated email from the ASF dual-hosted git repository.
ggregory pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-lang.git
The following commit(s) were added to refs/heads/master by this push:
new e18ace7 Sort members.
e18ace7 is described below
commit e18ace73ef1bfb79d026c2d8d19cd26590e8a169
Author: Gary Gregory <[email protected]>
AuthorDate: Sun Feb 21 14:09:57 2021 -0500
Sort members.
---
.../apache/commons/lang3/math/FractionTest.java | 1060 ++++++++++----------
.../commons/lang3/math/IEEE754rUtilsTest.java | 50 +-
.../commons/lang3/mutable/MutableBooleanTest.java | 22 +-
.../commons/lang3/mutable/MutableByteTest.java | 248 ++---
.../commons/lang3/mutable/MutableDoubleTest.java | 266 ++---
.../commons/lang3/mutable/MutableFloatTest.java | 266 ++---
.../commons/lang3/mutable/MutableIntTest.java | 252 ++---
.../commons/lang3/mutable/MutableLongTest.java | 252 ++---
.../commons/lang3/mutable/MutableObjectTest.java | 24 +-
.../commons/lang3/mutable/MutableShortTest.java | 236 ++---
.../commons/lang3/tuple/ImmutablePairTest.java | 98 +-
.../commons/lang3/tuple/ImmutableTripleTest.java | 26 +-
.../commons/lang3/tuple/MutablePairTest.java | 26 +-
.../commons/lang3/tuple/MutableTripleTest.java | 26 +-
.../org/apache/commons/lang3/tuple/PairTest.java | 26 +-
.../org/apache/commons/lang3/tuple/TripleTest.java | 26 +-
16 files changed, 1452 insertions(+), 1452 deletions(-)
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 28d94b2..7ede98c 100644
--- a/src/test/java/org/apache/commons/lang3/math/FractionTest.java
+++ b/src/test/java/org/apache/commons/lang3/math/FractionTest.java
@@ -33,6 +33,168 @@ public class FractionTest {
private static final int SKIP = 500; //53
+ @Test
+ public void testAbs() {
+ Fraction f;
+
+ f = Fraction.getFraction(50, 75);
+ f = f.abs();
+ assertEquals(50, f.getNumerator());
+ assertEquals(75, f.getDenominator());
+
+ f = Fraction.getFraction(-50, 75);
+ f = f.abs();
+ assertEquals(50, f.getNumerator());
+ assertEquals(75, f.getDenominator());
+
+ f = Fraction.getFraction(Integer.MAX_VALUE, 1);
+ f = f.abs();
+ assertEquals(Integer.MAX_VALUE, f.getNumerator());
+ assertEquals(1, f.getDenominator());
+
+ f = Fraction.getFraction(Integer.MAX_VALUE, -1);
+ f = f.abs();
+ assertEquals(Integer.MAX_VALUE, f.getNumerator());
+ assertEquals(1, f.getDenominator());
+
+ assertThrows(ArithmeticException.class, () ->
Fraction.getFraction(Integer.MIN_VALUE, 1).abs());
+ }
+
+ @Test
+ public void testAdd() {
+ Fraction f;
+ Fraction f1;
+ Fraction f2;
+
+ f1 = Fraction.getFraction(3, 5);
+ f2 = Fraction.getFraction(1, 5);
+ f = f1.add(f2);
+ assertEquals(4, f.getNumerator());
+ assertEquals(5, f.getDenominator());
+
+ f1 = Fraction.getFraction(3, 5);
+ f2 = Fraction.getFraction(2, 5);
+ f = f1.add(f2);
+ assertEquals(1, f.getNumerator());
+ assertEquals(1, f.getDenominator());
+
+ f1 = Fraction.getFraction(3, 5);
+ f2 = Fraction.getFraction(3, 5);
+ f = f1.add(f2);
+ assertEquals(6, f.getNumerator());
+ assertEquals(5, f.getDenominator());
+
+ f1 = Fraction.getFraction(3, 5);
+ f2 = Fraction.getFraction(-4, 5);
+ f = f1.add(f2);
+ assertEquals(-1, f.getNumerator());
+ assertEquals(5, f.getDenominator());
+
+ f1 = Fraction.getFraction(Integer.MAX_VALUE - 1, 1);
+ f2 = Fraction.ONE;
+ f = f1.add(f2);
+ assertEquals(Integer.MAX_VALUE, f.getNumerator());
+ assertEquals(1, f.getDenominator());
+
+ f1 = Fraction.getFraction(3, 5);
+ f2 = Fraction.getFraction(1, 2);
+ f = f1.add(f2);
+ assertEquals(11, f.getNumerator());
+ assertEquals(10, f.getDenominator());
+
+ f1 = Fraction.getFraction(3, 8);
+ f2 = Fraction.getFraction(1, 6);
+ f = f1.add(f2);
+ assertEquals(13, f.getNumerator());
+ assertEquals(24, f.getDenominator());
+
+ f1 = Fraction.getFraction(0, 5);
+ f2 = Fraction.getFraction(1, 5);
+ f = f1.add(f2);
+ assertSame(f2, f);
+ f = f2.add(f1);
+ assertSame(f2, f);
+
+ f1 = Fraction.getFraction(-1, 13*13*2*2);
+ f2 = Fraction.getFraction(-2, 13*17*2);
+ final Fraction fr = f1.add(f2);
+ assertEquals(13*13*17*2*2, fr.getDenominator());
+ assertEquals(-17 - 2*13*2, fr.getNumerator());
+
+ assertThrows(NullPointerException.class, () -> fr.add(null));
+
+ // if this fraction is added naively, it will overflow.
+ // check that it doesn't.
+ f1 = Fraction.getFraction(1, 32768*3);
+ f2 = Fraction.getFraction(1, 59049);
+ f = f1.add(f2);
+ assertEquals(52451, f.getNumerator());
+ assertEquals(1934917632, f.getDenominator());
+
+ f1 = Fraction.getFraction(Integer.MIN_VALUE, 3);
+ f2 = Fraction.ONE_THIRD;
+ f = f1.add(f2);
+ assertEquals(Integer.MIN_VALUE+1, f.getNumerator());
+ assertEquals(3, f.getDenominator());
+
+ f1 = Fraction.getFraction(Integer.MAX_VALUE - 1, 1);
+ f2 = Fraction.ONE;
+ f = f1.add(f2);
+ assertEquals(Integer.MAX_VALUE, f.getNumerator());
+ assertEquals(1, f.getDenominator());
+
+ final Fraction overflower = f;
+ assertThrows(ArithmeticException.class, () ->
overflower.add(Fraction.ONE)); // should overflow
+
+ // denominator should not be a multiple of 2 or 3 to trigger overflow
+ assertThrows(
+ ArithmeticException.class,
+ () -> Fraction.getFraction(Integer.MIN_VALUE,
5).add(Fraction.getFraction(-1, 5)));
+
+ final Fraction maxValue = Fraction.getFraction(-Integer.MAX_VALUE, 1);
+ assertThrows(ArithmeticException.class, () -> maxValue.add(maxValue));
+
+ final Fraction negativeMaxValue =
Fraction.getFraction(-Integer.MAX_VALUE, 1);
+ assertThrows(ArithmeticException.class, () ->
negativeMaxValue.add(negativeMaxValue));
+
+ final Fraction f3 = Fraction.getFraction(3, 327680);
+ final Fraction f4 = Fraction.getFraction(2, 59049);
+ assertThrows(ArithmeticException.class, () -> f3.add(f4)); // should
overflow
+ }
+
+ @Test
+ public void testCompareTo() {
+ Fraction f1;
+ Fraction f2;
+
+ f1 = Fraction.getFraction(3, 5);
+ 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);
+ assertEquals(0, f2.compareTo(f2));
+
+ f2 = Fraction.getFraction(4, 5);
+ assertTrue(f1.compareTo(f2) < 0);
+ assertEquals(0, f2.compareTo(f2));
+
+ f2 = Fraction.getFraction(3, 5);
+ assertEquals(0, f1.compareTo(f2));
+ assertEquals(0, f2.compareTo(f2));
+
+ f2 = Fraction.getFraction(6, 10);
+ assertEquals(0, f1.compareTo(f2));
+ assertEquals(0, f2.compareTo(f2));
+
+ f2 = Fraction.getFraction(-1, 1, Integer.MAX_VALUE);
+ assertTrue(f1.compareTo(f2) > 0);
+ assertEquals(0, f2.compareTo(f2));
+
+ }
+
//--------------------------------------------------------------------------
@Test
public void testConstants() {
@@ -74,6 +236,150 @@ public class FractionTest {
}
@Test
+ public void testConversions() {
+ Fraction f;
+
+ f = Fraction.getFraction(3, 7, 8);
+ assertEquals(3, f.intValue());
+ assertEquals(3L, f.longValue());
+ assertEquals(3.875f, f.floatValue(), 0.00001f);
+ assertEquals(3.875d, f.doubleValue(), 0.00001d);
+ }
+
+ @Test
+ public void testDivide() {
+ Fraction f;
+ Fraction f1;
+ Fraction f2;
+
+ f1 = Fraction.getFraction(3, 5);
+ f2 = Fraction.getFraction(2, 5);
+ f = f1.divideBy(f2);
+ assertEquals(3, f.getNumerator());
+ assertEquals(2, f.getDenominator());
+
+ assertThrows(ArithmeticException.class, () -> Fraction.getFraction(3,
5).divideBy(Fraction.ZERO));
+
+ f1 = Fraction.getFraction(0, 5);
+ f2 = Fraction.getFraction(2, 7);
+ f = f1.divideBy(f2);
+ assertSame(Fraction.ZERO, f);
+
+ f1 = Fraction.getFraction(2, 7);
+ f2 = Fraction.ONE;
+ f = f1.divideBy(f2);
+ assertEquals(2, f.getNumerator());
+ assertEquals(7, f.getDenominator());
+
+ f1 = Fraction.getFraction(1, Integer.MAX_VALUE);
+ f = f1.divideBy(f1);
+ assertEquals(1, f.getNumerator());
+ assertEquals(1, f.getDenominator());
+
+ f1 = Fraction.getFraction(Integer.MIN_VALUE, Integer.MAX_VALUE);
+ f2 = Fraction.getFraction(1, Integer.MAX_VALUE);
+ final Fraction fr = f1.divideBy(f2);
+ assertEquals(Integer.MIN_VALUE, fr.getNumerator());
+ assertEquals(1, fr.getDenominator());
+
+ assertThrows(NullPointerException.class, () -> fr.divideBy(null));
+
+ final Fraction smallest = Fraction.getFraction(1, Integer.MAX_VALUE);
+ assertThrows(ArithmeticException.class, () ->
smallest.divideBy(smallest.invert())); // Should overflow
+
+ final Fraction negative = Fraction.getFraction(1, -Integer.MAX_VALUE);
+ assertThrows(ArithmeticException.class, () ->
negative.divideBy(negative.invert())); // Should overflow
+ }
+
+
+ @Test
+ public void testEquals() {
+ Fraction f1;
+ Fraction f2;
+
+ f1 = Fraction.getFraction(3, 5);
+ assertNotEquals(null, f1);
+ assertNotEquals(f1, new Object());
+ assertNotEquals(f1, Integer.valueOf(6));
+
+ f1 = Fraction.getFraction(3, 5);
+ f2 = Fraction.getFraction(2, 5);
+ assertNotEquals(f1, f2);
+ assertEquals(f1, f1);
+ assertEquals(f2, f2);
+
+ f2 = Fraction.getFraction(3, 5);
+ assertEquals(f1, f2);
+
+ f2 = Fraction.getFraction(6, 10);
+ assertNotEquals(f1, f2);
+ }
+
+ @Test
+ public void testFactory_double() {
+ assertThrows(ArithmeticException.class, () ->
Fraction.getFraction(Double.NaN));
+ assertThrows(ArithmeticException.class, () ->
Fraction.getFraction(Double.POSITIVE_INFINITY));
+ assertThrows(ArithmeticException.class, () ->
Fraction.getFraction(Double.NEGATIVE_INFINITY));
+ assertThrows(ArithmeticException.class, () ->
Fraction.getFraction((double) Integer.MAX_VALUE + 1));
+
+ // zero
+ Fraction f = Fraction.getFraction(0.0d);
+ assertEquals(0, f.getNumerator());
+ assertEquals(1, f.getDenominator());
+
+ // one
+ f = Fraction.getFraction(1.0d);
+ assertEquals(1, f.getNumerator());
+ assertEquals(1, f.getDenominator());
+
+ // one half
+ f = Fraction.getFraction(0.5d);
+ assertEquals(1, f.getNumerator());
+ assertEquals(2, f.getDenominator());
+
+ // negative
+ f = Fraction.getFraction(-0.875d);
+ assertEquals(-7, f.getNumerator());
+ assertEquals(8, f.getDenominator());
+
+ // over 1
+ f = Fraction.getFraction(1.25d);
+ assertEquals(5, f.getNumerator());
+ assertEquals(4, f.getDenominator());
+
+ // two thirds
+ f = Fraction.getFraction(0.66666d);
+ assertEquals(2, f.getNumerator());
+ assertEquals(3, f.getDenominator());
+
+ // small
+ f = Fraction.getFraction(1.0d/10001d);
+ assertEquals(0, f.getNumerator());
+ assertEquals(1, f.getDenominator());
+
+ // normal
+ Fraction f2 = null;
+ for (int i = 1; i <= 100; i++) { // denominator
+ for (int j = 1; j <= i; j++) { // numerator
+ f = Fraction.getFraction((double) j / (double) i);
+
+ f2 = Fraction.getReducedFraction(j, i);
+ assertEquals(f2.getNumerator(), f.getNumerator());
+ assertEquals(f2.getDenominator(), f.getDenominator());
+ }
+ }
+ // save time by skipping some tests! (
+ for (int i = 1001; i <= 10000; i+=SKIP) { // denominator
+ for (int j = 1; j <= i; j++) { // numerator
+ f = Fraction.getFraction((double) j / (double) i);
+ f2 = Fraction.getReducedFraction(j, i);
+ assertEquals(f2.getNumerator(), f.getNumerator());
+ assertEquals(f2.getDenominator(), f.getDenominator());
+ }
+ }
+ }
+
+ @Test
public void testFactory_int_int() {
Fraction f;
@@ -182,175 +488,67 @@ public class FractionTest {
}
@Test
- public void testReducedFactory_int_int() {
- Fraction f;
-
- // zero
- f = Fraction.getReducedFraction(0, 1);
- assertEquals(0, f.getNumerator());
- assertEquals(1, f.getDenominator());
-
- // normal
- f = Fraction.getReducedFraction(1, 1);
- assertEquals(1, f.getNumerator());
- assertEquals(1, f.getDenominator());
-
- f = Fraction.getReducedFraction(2, 1);
- assertEquals(2, f.getNumerator());
- assertEquals(1, f.getDenominator());
-
- // improper
- f = Fraction.getReducedFraction(22, 7);
- assertEquals(22, f.getNumerator());
- assertEquals(7, f.getDenominator());
-
- // negatives
- f = Fraction.getReducedFraction(-6, 10);
- assertEquals(-3, f.getNumerator());
- assertEquals(5, f.getDenominator());
-
- f = Fraction.getReducedFraction(6, -10);
- assertEquals(-3, f.getNumerator());
- assertEquals(5, f.getDenominator());
-
- f = Fraction.getReducedFraction(-6, -10);
- assertEquals(3, f.getNumerator());
- assertEquals(5, f.getDenominator());
-
- // zero denominator
- assertThrows(ArithmeticException.class, () ->
Fraction.getReducedFraction(1, 0));
- assertThrows(ArithmeticException.class, () ->
Fraction.getReducedFraction(2, 0));
- assertThrows(ArithmeticException.class, () ->
Fraction.getReducedFraction(-3, 0));
-
- // reduced
- f = Fraction.getReducedFraction(0, 2);
- assertEquals(0, f.getNumerator());
- assertEquals(1, f.getDenominator());
-
- f = Fraction.getReducedFraction(2, 2);
- assertEquals(1, f.getNumerator());
- assertEquals(1, f.getDenominator());
-
- f = Fraction.getReducedFraction(2, 4);
- assertEquals(1, f.getNumerator());
- assertEquals(2, f.getDenominator());
-
- f = Fraction.getReducedFraction(15, 10);
- assertEquals(3, f.getNumerator());
- assertEquals(2, f.getDenominator());
-
- f = Fraction.getReducedFraction(121, 22);
- assertEquals(11, f.getNumerator());
- assertEquals(2, f.getDenominator());
-
- // Extreme values
- // OK, can reduce before negating
- f = Fraction.getReducedFraction(-2, Integer.MIN_VALUE);
- assertEquals(1, f.getNumerator());
- assertEquals(-(Integer.MIN_VALUE / 2), f.getDenominator());
-
- // Can't reduce, negation will throw
- assertThrows(ArithmeticException.class, () ->
Fraction.getReducedFraction(-7, Integer.MIN_VALUE));
-
- // LANG-662
- f = Fraction.getReducedFraction(Integer.MIN_VALUE, 2);
- assertEquals(Integer.MIN_VALUE / 2, f.getNumerator());
- assertEquals(1, f.getDenominator());
+ public void testFactory_String() {
+ assertThrows(NullPointerException.class, () ->
Fraction.getFraction(null));
}
@Test
- public void testFactory_double() {
- assertThrows(ArithmeticException.class, () ->
Fraction.getFraction(Double.NaN));
- assertThrows(ArithmeticException.class, () ->
Fraction.getFraction(Double.POSITIVE_INFINITY));
- assertThrows(ArithmeticException.class, () ->
Fraction.getFraction(Double.NEGATIVE_INFINITY));
- assertThrows(ArithmeticException.class, () ->
Fraction.getFraction((double) Integer.MAX_VALUE + 1));
+ public void testFactory_String_double() {
+ Fraction f;
- // zero
- Fraction f = Fraction.getFraction(0.0d);
+ f = Fraction.getFraction("0.0");
assertEquals(0, f.getNumerator());
assertEquals(1, f.getDenominator());
- // one
- f = Fraction.getFraction(1.0d);
+ f = Fraction.getFraction("0.2");
assertEquals(1, f.getNumerator());
- assertEquals(1, f.getDenominator());
+ assertEquals(5, f.getDenominator());
- // one half
- f = Fraction.getFraction(0.5d);
+ f = Fraction.getFraction("0.5");
assertEquals(1, f.getNumerator());
assertEquals(2, f.getDenominator());
- // negative
- f = Fraction.getFraction(-0.875d);
- assertEquals(-7, f.getNumerator());
- assertEquals(8, f.getDenominator());
-
- // over 1
- f = Fraction.getFraction(1.25d);
- assertEquals(5, f.getNumerator());
- assertEquals(4, f.getDenominator());
-
- // two thirds
- f = Fraction.getFraction(0.66666d);
+ f = Fraction.getFraction("0.66666");
assertEquals(2, f.getNumerator());
assertEquals(3, f.getDenominator());
- // small
- f = Fraction.getFraction(1.0d/10001d);
- assertEquals(0, f.getNumerator());
- assertEquals(1, f.getDenominator());
-
- // normal
- Fraction f2 = null;
- for (int i = 1; i <= 100; i++) { // denominator
- for (int j = 1; j <= i; j++) { // numerator
- f = Fraction.getFraction((double) j / (double) i);
-
- f2 = Fraction.getReducedFraction(j, i);
- assertEquals(f2.getNumerator(), f.getNumerator());
- assertEquals(f2.getDenominator(), f.getDenominator());
- }
- }
- // save time by skipping some tests! (
- for (int i = 1001; i <= 10000; i+=SKIP) { // denominator
- for (int j = 1; j <= i; j++) { // numerator
- f = Fraction.getFraction((double) j / (double) i);
- f2 = Fraction.getReducedFraction(j, i);
- assertEquals(f2.getNumerator(), f.getNumerator());
- assertEquals(f2.getDenominator(), f.getDenominator());
- }
- }
- }
-
- @Test
- public void testFactory_String() {
- assertThrows(NullPointerException.class, () ->
Fraction.getFraction(null));
+ assertThrows(NumberFormatException.class, () ->
Fraction.getFraction("2.3R"));
+ assertThrows(NumberFormatException.class, () ->
Fraction.getFraction("2147483648")); // too big
+ assertThrows(NumberFormatException.class, () ->
Fraction.getFraction("."));
}
-
@Test
- public void testFactory_String_double() {
+ public void testFactory_String_improper() {
Fraction f;
- f = Fraction.getFraction("0.0");
+ f = Fraction.getFraction("0/1");
assertEquals(0, f.getNumerator());
assertEquals(1, f.getDenominator());
- f = Fraction.getFraction("0.2");
+ f = Fraction.getFraction("1/5");
assertEquals(1, f.getNumerator());
assertEquals(5, f.getDenominator());
- f = Fraction.getFraction("0.5");
+ f = Fraction.getFraction("1/2");
assertEquals(1, f.getNumerator());
assertEquals(2, f.getDenominator());
- f = Fraction.getFraction("0.66666");
+ f = Fraction.getFraction("2/3");
assertEquals(2, f.getNumerator());
assertEquals(3, f.getDenominator());
- assertThrows(NumberFormatException.class, () ->
Fraction.getFraction("2.3R"));
- assertThrows(NumberFormatException.class, () ->
Fraction.getFraction("2147483648")); // too big
- assertThrows(NumberFormatException.class, () ->
Fraction.getFraction("."));
+ f = Fraction.getFraction("7/3");
+ assertEquals(7, f.getNumerator());
+ assertEquals(3, f.getDenominator());
+
+ f = Fraction.getFraction("2/4");
+ assertEquals(2, f.getNumerator());
+ assertEquals(4, f.getDenominator());
+
+ assertThrows(NumberFormatException.class, () ->
Fraction.getFraction("2/d"));
+ assertThrows(NumberFormatException.class, () ->
Fraction.getFraction("2e/3"));
+ assertThrows(NumberFormatException.class, () ->
Fraction.getFraction("2/"));
+ assertThrows(NumberFormatException.class, () ->
Fraction.getFraction("/"));
}
@Test
@@ -390,40 +588,6 @@ public class FractionTest {
}
@Test
- public void testFactory_String_improper() {
- Fraction f;
-
- f = Fraction.getFraction("0/1");
- assertEquals(0, f.getNumerator());
- assertEquals(1, f.getDenominator());
-
- f = Fraction.getFraction("1/5");
- assertEquals(1, f.getNumerator());
- assertEquals(5, f.getDenominator());
-
- f = Fraction.getFraction("1/2");
- assertEquals(1, f.getNumerator());
- assertEquals(2, f.getDenominator());
-
- f = Fraction.getFraction("2/3");
- assertEquals(2, f.getNumerator());
- assertEquals(3, f.getDenominator());
-
- f = Fraction.getFraction("7/3");
- assertEquals(7, f.getNumerator());
- assertEquals(3, f.getDenominator());
-
- f = Fraction.getFraction("2/4");
- assertEquals(2, f.getNumerator());
- assertEquals(4, f.getDenominator());
-
- assertThrows(NumberFormatException.class, () ->
Fraction.getFraction("2/d"));
- assertThrows(NumberFormatException.class, () ->
Fraction.getFraction("2e/3"));
- assertThrows(NumberFormatException.class, () ->
Fraction.getFraction("2/"));
- assertThrows(NumberFormatException.class, () ->
Fraction.getFraction("/"));
- }
-
- @Test
public void testGets() {
Fraction f;
@@ -446,64 +610,18 @@ public class FractionTest {
assertEquals(1, f.getDenominator());
}
- @Test
- public void testConversions() {
- Fraction f;
-
- f = Fraction.getFraction(3, 7, 8);
- assertEquals(3, f.intValue());
- assertEquals(3L, f.longValue());
- assertEquals(3.875f, f.floatValue(), 0.00001f);
- assertEquals(3.875d, f.doubleValue(), 0.00001d);
- }
-
- @Test
- public void testReduce() {
- Fraction f;
-
- f = Fraction.getFraction(50, 75);
- Fraction result = f.reduce();
- assertEquals(2, result.getNumerator());
- assertEquals(3, result.getDenominator());
-
- f = Fraction.getFraction(-2, -3);
- result = f.reduce();
- assertEquals(2, result.getNumerator());
- assertEquals(3, result.getDenominator());
-
- f = Fraction.getFraction(2, -3);
- result = f.reduce();
- assertEquals(-2, result.getNumerator());
- assertEquals(3, result.getDenominator());
-
- f = Fraction.getFraction(-2, 3);
- result = f.reduce();
- assertEquals(-2, result.getNumerator());
- assertEquals(3, result.getDenominator());
- assertSame(f, result);
-
- f = Fraction.getFraction(2, 3);
- result = f.reduce();
- assertEquals(2, result.getNumerator());
- assertEquals(3, result.getDenominator());
- assertSame(f, result);
-
- f = Fraction.getFraction(0, 1);
- result = f.reduce();
- assertEquals(0, result.getNumerator());
- assertEquals(1, result.getDenominator());
- assertSame(f, result);
+ @Test
+ public void testHashCode() {
+ final Fraction f1 = Fraction.getFraction(3, 5);
+ Fraction f2 = Fraction.getFraction(3, 5);
- f = Fraction.getFraction(0, 100);
- result = f.reduce();
- assertEquals(0, result.getNumerator());
- assertEquals(1, result.getDenominator());
- assertSame(result, Fraction.ZERO);
+ assertEquals(f1.hashCode(), f2.hashCode());
- f = Fraction.getFraction(Integer.MIN_VALUE, 2);
- result = f.reduce();
- assertEquals(Integer.MIN_VALUE / 2, result.getNumerator());
- assertEquals(1, result.getDenominator());
+ f2 = Fraction.getFraction(2, 5);
+ assertTrue(f1.hashCode() != f2.hashCode());
+
+ f2 = Fraction.getFraction(6, 10);
+ assertTrue(f1.hashCode() != f2.hashCode());
}
@Test
@@ -535,6 +653,67 @@ public class FractionTest {
}
@Test
+ public void testMultiply() {
+ Fraction f;
+ Fraction f1;
+ Fraction f2;
+
+ f1 = Fraction.getFraction(3, 5);
+ f2 = Fraction.getFraction(2, 5);
+ f = f1.multiplyBy(f2);
+ assertEquals(6, f.getNumerator());
+ assertEquals(25, f.getDenominator());
+
+ f1 = Fraction.getFraction(6, 10);
+ f2 = Fraction.getFraction(6, 10);
+ f = f1.multiplyBy(f2);
+ assertEquals(9, f.getNumerator());
+ assertEquals(25, f.getDenominator());
+ f = f.multiplyBy(f2);
+ assertEquals(27, f.getNumerator());
+ assertEquals(125, f.getDenominator());
+
+ f1 = Fraction.getFraction(3, 5);
+ f2 = Fraction.getFraction(-2, 5);
+ f = f1.multiplyBy(f2);
+ assertEquals(-6, f.getNumerator());
+ assertEquals(25, f.getDenominator());
+
+ f1 = Fraction.getFraction(-3, 5);
+ f2 = Fraction.getFraction(-2, 5);
+ f = f1.multiplyBy(f2);
+ assertEquals(6, f.getNumerator());
+ assertEquals(25, f.getDenominator());
+
+
+ f1 = Fraction.getFraction(0, 5);
+ f2 = Fraction.getFraction(2, 7);
+ f = f1.multiplyBy(f2);
+ assertSame(Fraction.ZERO, f);
+
+ f1 = Fraction.getFraction(2, 7);
+ f2 = Fraction.ONE;
+ f = f1.multiplyBy(f2);
+ assertEquals(2, f.getNumerator());
+ assertEquals(7, f.getDenominator());
+
+ f1 = Fraction.getFraction(Integer.MAX_VALUE, 1);
+ f2 = Fraction.getFraction(Integer.MIN_VALUE, Integer.MAX_VALUE);
+ f = f1.multiplyBy(f2);
+ assertEquals(Integer.MIN_VALUE, f.getNumerator());
+ assertEquals(1, f.getDenominator());
+
+ final Fraction fr = f;
+ assertThrows(NullPointerException.class, () -> fr.multiplyBy(null));
+
+ final Fraction fr1 = Fraction.getFraction(1, Integer.MAX_VALUE);
+ assertThrows(ArithmeticException.class, () -> fr1.multiplyBy(fr1));
+
+ final Fraction fr2 = Fraction.getFraction(1, -Integer.MAX_VALUE);
+ assertThrows(ArithmeticException.class, () -> fr2.multiplyBy(fr2));
+ }
+
+ @Test
public void testNegate() {
Fraction f;
@@ -558,33 +737,6 @@ public class FractionTest {
}
@Test
- public void testAbs() {
- Fraction f;
-
- f = Fraction.getFraction(50, 75);
- f = f.abs();
- assertEquals(50, f.getNumerator());
- assertEquals(75, f.getDenominator());
-
- f = Fraction.getFraction(-50, 75);
- f = f.abs();
- assertEquals(50, f.getNumerator());
- assertEquals(75, f.getDenominator());
-
- f = Fraction.getFraction(Integer.MAX_VALUE, 1);
- f = f.abs();
- assertEquals(Integer.MAX_VALUE, f.getNumerator());
- assertEquals(1, f.getDenominator());
-
- f = Fraction.getFraction(Integer.MAX_VALUE, -1);
- f = f.abs();
- assertEquals(Integer.MAX_VALUE, f.getNumerator());
- assertEquals(1, f.getDenominator());
-
- assertThrows(ArithmeticException.class, () ->
Fraction.getFraction(Integer.MIN_VALUE, 1).abs());
- }
-
- @Test
public void testPow() {
Fraction f;
@@ -681,105 +833,129 @@ public class FractionTest {
}
@Test
- public void testAdd() {
+ public void testReduce() {
Fraction f;
- Fraction f1;
- Fraction f2;
- f1 = Fraction.getFraction(3, 5);
- f2 = Fraction.getFraction(1, 5);
- f = f1.add(f2);
- assertEquals(4, f.getNumerator());
- assertEquals(5, f.getDenominator());
+ f = Fraction.getFraction(50, 75);
+ Fraction result = f.reduce();
+ assertEquals(2, result.getNumerator());
+ assertEquals(3, result.getDenominator());
- f1 = Fraction.getFraction(3, 5);
- f2 = Fraction.getFraction(2, 5);
- f = f1.add(f2);
- assertEquals(1, f.getNumerator());
- assertEquals(1, f.getDenominator());
+ f = Fraction.getFraction(-2, -3);
+ result = f.reduce();
+ assertEquals(2, result.getNumerator());
+ assertEquals(3, result.getDenominator());
- f1 = Fraction.getFraction(3, 5);
- f2 = Fraction.getFraction(3, 5);
- f = f1.add(f2);
- assertEquals(6, f.getNumerator());
- assertEquals(5, f.getDenominator());
+ f = Fraction.getFraction(2, -3);
+ result = f.reduce();
+ assertEquals(-2, result.getNumerator());
+ assertEquals(3, result.getDenominator());
- f1 = Fraction.getFraction(3, 5);
- f2 = Fraction.getFraction(-4, 5);
- f = f1.add(f2);
- assertEquals(-1, f.getNumerator());
- assertEquals(5, f.getDenominator());
+ f = Fraction.getFraction(-2, 3);
+ result = f.reduce();
+ assertEquals(-2, result.getNumerator());
+ assertEquals(3, result.getDenominator());
+ assertSame(f, result);
- f1 = Fraction.getFraction(Integer.MAX_VALUE - 1, 1);
- f2 = Fraction.ONE;
- f = f1.add(f2);
- assertEquals(Integer.MAX_VALUE, f.getNumerator());
+ f = Fraction.getFraction(2, 3);
+ result = f.reduce();
+ assertEquals(2, result.getNumerator());
+ assertEquals(3, result.getDenominator());
+ assertSame(f, result);
+
+ f = Fraction.getFraction(0, 1);
+ result = f.reduce();
+ assertEquals(0, result.getNumerator());
+ assertEquals(1, result.getDenominator());
+ assertSame(f, result);
+
+ f = Fraction.getFraction(0, 100);
+ result = f.reduce();
+ assertEquals(0, result.getNumerator());
+ assertEquals(1, result.getDenominator());
+ assertSame(result, Fraction.ZERO);
+
+ f = Fraction.getFraction(Integer.MIN_VALUE, 2);
+ result = f.reduce();
+ assertEquals(Integer.MIN_VALUE / 2, result.getNumerator());
+ assertEquals(1, result.getDenominator());
+ }
+
+ @Test
+ public void testReducedFactory_int_int() {
+ Fraction f;
+
+ // zero
+ f = Fraction.getReducedFraction(0, 1);
+ assertEquals(0, f.getNumerator());
assertEquals(1, f.getDenominator());
- f1 = Fraction.getFraction(3, 5);
- f2 = Fraction.getFraction(1, 2);
- f = f1.add(f2);
- assertEquals(11, f.getNumerator());
- assertEquals(10, f.getDenominator());
+ // normal
+ f = Fraction.getReducedFraction(1, 1);
+ assertEquals(1, f.getNumerator());
+ assertEquals(1, f.getDenominator());
- f1 = Fraction.getFraction(3, 8);
- f2 = Fraction.getFraction(1, 6);
- f = f1.add(f2);
- assertEquals(13, f.getNumerator());
- assertEquals(24, f.getDenominator());
+ f = Fraction.getReducedFraction(2, 1);
+ assertEquals(2, f.getNumerator());
+ assertEquals(1, f.getDenominator());
- f1 = Fraction.getFraction(0, 5);
- f2 = Fraction.getFraction(1, 5);
- f = f1.add(f2);
- assertSame(f2, f);
- f = f2.add(f1);
- assertSame(f2, f);
+ // improper
+ f = Fraction.getReducedFraction(22, 7);
+ assertEquals(22, f.getNumerator());
+ assertEquals(7, f.getDenominator());
- f1 = Fraction.getFraction(-1, 13*13*2*2);
- f2 = Fraction.getFraction(-2, 13*17*2);
- final Fraction fr = f1.add(f2);
- assertEquals(13*13*17*2*2, fr.getDenominator());
- assertEquals(-17 - 2*13*2, fr.getNumerator());
+ // negatives
+ f = Fraction.getReducedFraction(-6, 10);
+ assertEquals(-3, f.getNumerator());
+ assertEquals(5, f.getDenominator());
- assertThrows(NullPointerException.class, () -> fr.add(null));
+ f = Fraction.getReducedFraction(6, -10);
+ assertEquals(-3, f.getNumerator());
+ assertEquals(5, f.getDenominator());
- // if this fraction is added naively, it will overflow.
- // check that it doesn't.
- f1 = Fraction.getFraction(1, 32768*3);
- f2 = Fraction.getFraction(1, 59049);
- f = f1.add(f2);
- assertEquals(52451, f.getNumerator());
- assertEquals(1934917632, f.getDenominator());
+ f = Fraction.getReducedFraction(-6, -10);
+ assertEquals(3, f.getNumerator());
+ assertEquals(5, f.getDenominator());
- f1 = Fraction.getFraction(Integer.MIN_VALUE, 3);
- f2 = Fraction.ONE_THIRD;
- f = f1.add(f2);
- assertEquals(Integer.MIN_VALUE+1, f.getNumerator());
- assertEquals(3, f.getDenominator());
+ // zero denominator
+ assertThrows(ArithmeticException.class, () ->
Fraction.getReducedFraction(1, 0));
+ assertThrows(ArithmeticException.class, () ->
Fraction.getReducedFraction(2, 0));
+ assertThrows(ArithmeticException.class, () ->
Fraction.getReducedFraction(-3, 0));
- f1 = Fraction.getFraction(Integer.MAX_VALUE - 1, 1);
- f2 = Fraction.ONE;
- f = f1.add(f2);
- assertEquals(Integer.MAX_VALUE, f.getNumerator());
+ // reduced
+ f = Fraction.getReducedFraction(0, 2);
+ assertEquals(0, f.getNumerator());
+ assertEquals(1, f.getDenominator());
+
+ f = Fraction.getReducedFraction(2, 2);
+ assertEquals(1, f.getNumerator());
assertEquals(1, f.getDenominator());
- final Fraction overflower = f;
- assertThrows(ArithmeticException.class, () ->
overflower.add(Fraction.ONE)); // should overflow
+ f = Fraction.getReducedFraction(2, 4);
+ assertEquals(1, f.getNumerator());
+ assertEquals(2, f.getDenominator());
- // denominator should not be a multiple of 2 or 3 to trigger overflow
- assertThrows(
- ArithmeticException.class,
- () -> Fraction.getFraction(Integer.MIN_VALUE,
5).add(Fraction.getFraction(-1, 5)));
+ f = Fraction.getReducedFraction(15, 10);
+ assertEquals(3, f.getNumerator());
+ assertEquals(2, f.getDenominator());
- final Fraction maxValue = Fraction.getFraction(-Integer.MAX_VALUE, 1);
- assertThrows(ArithmeticException.class, () -> maxValue.add(maxValue));
+ f = Fraction.getReducedFraction(121, 22);
+ assertEquals(11, f.getNumerator());
+ assertEquals(2, f.getDenominator());
- final Fraction negativeMaxValue =
Fraction.getFraction(-Integer.MAX_VALUE, 1);
- assertThrows(ArithmeticException.class, () ->
negativeMaxValue.add(negativeMaxValue));
+ // Extreme values
+ // OK, can reduce before negating
+ f = Fraction.getReducedFraction(-2, Integer.MIN_VALUE);
+ assertEquals(1, f.getNumerator());
+ assertEquals(-(Integer.MIN_VALUE / 2), f.getDenominator());
- final Fraction f3 = Fraction.getFraction(3, 327680);
- final Fraction f4 = Fraction.getFraction(2, 59049);
- assertThrows(ArithmeticException.class, () -> f3.add(f4)); // should
overflow
+ // Can't reduce, negation will throw
+ assertThrows(ArithmeticException.class, () ->
Fraction.getReducedFraction(-7, Integer.MIN_VALUE));
+
+ // LANG-662
+ f = Fraction.getReducedFraction(Integer.MIN_VALUE, 2);
+ assertEquals(Integer.MIN_VALUE / 2, f.getNumerator());
+ assertEquals(1, f.getDenominator());
}
@Test
@@ -883,179 +1059,39 @@ public class FractionTest {
}
@Test
- public void testMultiply() {
- Fraction f;
- Fraction f1;
- Fraction f2;
-
- f1 = Fraction.getFraction(3, 5);
- f2 = Fraction.getFraction(2, 5);
- f = f1.multiplyBy(f2);
- assertEquals(6, f.getNumerator());
- assertEquals(25, f.getDenominator());
-
- f1 = Fraction.getFraction(6, 10);
- f2 = Fraction.getFraction(6, 10);
- f = f1.multiplyBy(f2);
- assertEquals(9, f.getNumerator());
- assertEquals(25, f.getDenominator());
- f = f.multiplyBy(f2);
- assertEquals(27, f.getNumerator());
- assertEquals(125, f.getDenominator());
-
- f1 = Fraction.getFraction(3, 5);
- f2 = Fraction.getFraction(-2, 5);
- f = f1.multiplyBy(f2);
- assertEquals(-6, f.getNumerator());
- assertEquals(25, f.getDenominator());
-
- f1 = Fraction.getFraction(-3, 5);
- f2 = Fraction.getFraction(-2, 5);
- f = f1.multiplyBy(f2);
- assertEquals(6, f.getNumerator());
- assertEquals(25, f.getDenominator());
-
-
- f1 = Fraction.getFraction(0, 5);
- f2 = Fraction.getFraction(2, 7);
- f = f1.multiplyBy(f2);
- assertSame(Fraction.ZERO, f);
-
- f1 = Fraction.getFraction(2, 7);
- f2 = Fraction.ONE;
- f = f1.multiplyBy(f2);
- assertEquals(2, f.getNumerator());
- assertEquals(7, f.getDenominator());
-
- f1 = Fraction.getFraction(Integer.MAX_VALUE, 1);
- f2 = Fraction.getFraction(Integer.MIN_VALUE, Integer.MAX_VALUE);
- f = f1.multiplyBy(f2);
- assertEquals(Integer.MIN_VALUE, f.getNumerator());
- assertEquals(1, f.getDenominator());
-
- final Fraction fr = f;
- assertThrows(NullPointerException.class, () -> fr.multiplyBy(null));
-
- final Fraction fr1 = Fraction.getFraction(1, Integer.MAX_VALUE);
- assertThrows(ArithmeticException.class, () -> fr1.multiplyBy(fr1));
-
- final Fraction fr2 = Fraction.getFraction(1, -Integer.MAX_VALUE);
- assertThrows(ArithmeticException.class, () -> fr2.multiplyBy(fr2));
- }
-
- @Test
- public void testDivide() {
+ public void testToProperString() {
Fraction f;
- Fraction f1;
- Fraction f2;
-
- f1 = Fraction.getFraction(3, 5);
- f2 = Fraction.getFraction(2, 5);
- f = f1.divideBy(f2);
- assertEquals(3, f.getNumerator());
- assertEquals(2, f.getDenominator());
-
- assertThrows(ArithmeticException.class, () -> Fraction.getFraction(3,
5).divideBy(Fraction.ZERO));
-
- f1 = Fraction.getFraction(0, 5);
- f2 = Fraction.getFraction(2, 7);
- f = f1.divideBy(f2);
- assertSame(Fraction.ZERO, f);
-
- f1 = Fraction.getFraction(2, 7);
- f2 = Fraction.ONE;
- f = f1.divideBy(f2);
- assertEquals(2, f.getNumerator());
- assertEquals(7, f.getDenominator());
-
- f1 = Fraction.getFraction(1, Integer.MAX_VALUE);
- f = f1.divideBy(f1);
- assertEquals(1, f.getNumerator());
- assertEquals(1, f.getDenominator());
-
- f1 = Fraction.getFraction(Integer.MIN_VALUE, Integer.MAX_VALUE);
- f2 = Fraction.getFraction(1, Integer.MAX_VALUE);
- final Fraction fr = f1.divideBy(f2);
- assertEquals(Integer.MIN_VALUE, fr.getNumerator());
- assertEquals(1, fr.getDenominator());
-
- assertThrows(NullPointerException.class, () -> fr.divideBy(null));
-
- final Fraction smallest = Fraction.getFraction(1, Integer.MAX_VALUE);
- assertThrows(ArithmeticException.class, () ->
smallest.divideBy(smallest.invert())); // Should overflow
-
- final Fraction negative = Fraction.getFraction(1, -Integer.MAX_VALUE);
- assertThrows(ArithmeticException.class, () ->
negative.divideBy(negative.invert())); // Should overflow
- }
-
- @Test
- public void testEquals() {
- Fraction f1;
- Fraction f2;
-
- f1 = Fraction.getFraction(3, 5);
- assertNotEquals(null, f1);
- assertNotEquals(f1, new Object());
- assertNotEquals(f1, Integer.valueOf(6));
-
- f1 = Fraction.getFraction(3, 5);
- f2 = Fraction.getFraction(2, 5);
- assertNotEquals(f1, f2);
- assertEquals(f1, f1);
- assertEquals(f2, f2);
-
- f2 = Fraction.getFraction(3, 5);
- assertEquals(f1, f2);
-
- f2 = Fraction.getFraction(6, 10);
- assertNotEquals(f1, f2);
- }
-
- @Test
- public void testHashCode() {
- final Fraction f1 = Fraction.getFraction(3, 5);
- Fraction f2 = Fraction.getFraction(3, 5);
- assertEquals(f1.hashCode(), f2.hashCode());
-
- f2 = Fraction.getFraction(2, 5);
- assertTrue(f1.hashCode() != f2.hashCode());
-
- f2 = Fraction.getFraction(6, 10);
- assertTrue(f1.hashCode() != f2.hashCode());
- }
+ f = Fraction.getFraction(3, 5);
+ final String str = f.toProperString();
+ assertEquals("3/5", str);
+ assertSame(str, f.toProperString());
- @Test
- public void testCompareTo() {
- Fraction f1;
- Fraction f2;
+ f = Fraction.getFraction(7, 5);
+ assertEquals("1 2/5", f.toProperString());
- f1 = Fraction.getFraction(3, 5);
- assertEquals(0, f1.compareTo(f1));
+ f = Fraction.getFraction(14, 10);
+ assertEquals("1 4/10", f.toProperString());
- final Fraction fr = f1;
- assertThrows(NullPointerException.class, () -> fr.compareTo(null));
+ f = Fraction.getFraction(4, 2);
+ assertEquals("2", f.toProperString());
- f2 = Fraction.getFraction(2, 5);
- assertTrue(f1.compareTo(f2) > 0);
- assertEquals(0, f2.compareTo(f2));
+ f = Fraction.getFraction(0, 2);
+ assertEquals("0", f.toProperString());
- f2 = Fraction.getFraction(4, 5);
- assertTrue(f1.compareTo(f2) < 0);
- assertEquals(0, f2.compareTo(f2));
+ f = Fraction.getFraction(2, 2);
+ assertEquals("1", f.toProperString());
- f2 = Fraction.getFraction(3, 5);
- assertEquals(0, f1.compareTo(f2));
- assertEquals(0, f2.compareTo(f2));
+ f = Fraction.getFraction(-7, 5);
+ assertEquals("-1 2/5", f.toProperString());
- f2 = Fraction.getFraction(6, 10);
- assertEquals(0, f1.compareTo(f2));
- assertEquals(0, f2.compareTo(f2));
+ f = Fraction.getFraction(Integer.MIN_VALUE, 0, 1);
+ assertEquals("-2147483648", f.toProperString());
- f2 = Fraction.getFraction(-1, 1, Integer.MAX_VALUE);
- assertTrue(f1.compareTo(f2) > 0);
- assertEquals(0, f2.compareTo(f2));
+ f = Fraction.getFraction(-1, 1, Integer.MAX_VALUE);
+ assertEquals("-1 1/2147483647", f.toProperString());
+ assertEquals("-1", Fraction.getFraction(-1).toProperString());
}
@Test
@@ -1085,40 +1121,4 @@ public class FractionTest {
f = Fraction.getFraction(-1, 1, Integer.MAX_VALUE);
assertEquals("-2147483648/2147483647", f.toString());
}
-
- @Test
- public void testToProperString() {
- Fraction f;
-
- f = Fraction.getFraction(3, 5);
- final String str = f.toProperString();
- assertEquals("3/5", str);
- assertSame(str, f.toProperString());
-
- f = Fraction.getFraction(7, 5);
- assertEquals("1 2/5", f.toProperString());
-
- f = Fraction.getFraction(14, 10);
- assertEquals("1 4/10", f.toProperString());
-
- f = Fraction.getFraction(4, 2);
- assertEquals("2", f.toProperString());
-
- f = Fraction.getFraction(0, 2);
- assertEquals("0", f.toProperString());
-
- f = Fraction.getFraction(2, 2);
- assertEquals("1", f.toProperString());
-
- f = Fraction.getFraction(-7, 5);
- assertEquals("-1 2/5", f.toProperString());
-
- f = Fraction.getFraction(Integer.MIN_VALUE, 0, 1);
- assertEquals("-2147483648", f.toProperString());
-
- f = Fraction.getFraction(-1, 1, Integer.MAX_VALUE);
- assertEquals("-1 1/2147483647", f.toProperString());
-
- assertEquals("-1", Fraction.getFraction(-1).toProperString());
- }
}
diff --git a/src/test/java/org/apache/commons/lang3/math/IEEE754rUtilsTest.java
b/src/test/java/org/apache/commons/lang3/math/IEEE754rUtilsTest.java
index 8312f03..2a4374e 100644
--- a/src/test/java/org/apache/commons/lang3/math/IEEE754rUtilsTest.java
+++ b/src/test/java/org/apache/commons/lang3/math/IEEE754rUtilsTest.java
@@ -28,29 +28,8 @@ import org.junit.jupiter.api.Test;
public class IEEE754rUtilsTest {
@Test
- public void testLang381() {
- assertEquals(1.2, IEEE754rUtils.min(1.2, 2.5, Double.NaN), 0.01);
- assertEquals(2.5, IEEE754rUtils.max(1.2, 2.5, Double.NaN), 0.01);
- assertTrue(Double.isNaN(IEEE754rUtils.max(Double.NaN, Double.NaN,
Double.NaN)));
- assertEquals(1.2f, IEEE754rUtils.min(1.2f, 2.5f, Float.NaN), 0.01);
- assertEquals(2.5f, IEEE754rUtils.max(1.2f, 2.5f, Float.NaN), 0.01);
- assertTrue(Float.isNaN(IEEE754rUtils.max(Float.NaN, Float.NaN,
Float.NaN)));
-
- final double[] a = new double[] { 1.2, Double.NaN, 3.7, 27.0, 42.0,
Double.NaN };
- assertEquals(42.0, IEEE754rUtils.max(a), 0.01);
- assertEquals(1.2, IEEE754rUtils.min(a), 0.01);
-
- final double[] b = new double[] { Double.NaN, 1.2, Double.NaN, 3.7,
27.0, 42.0, Double.NaN };
- assertEquals(42.0, IEEE754rUtils.max(b), 0.01);
- assertEquals(1.2, IEEE754rUtils.min(b), 0.01);
-
- final float[] aF = new float[] { 1.2f, Float.NaN, 3.7f, 27.0f, 42.0f,
Float.NaN };
- assertEquals(1.2f, IEEE754rUtils.min(aF), 0.01);
- assertEquals(42.0f, IEEE754rUtils.max(aF), 0.01);
-
- final float[] bF = new float[] { Float.NaN, 1.2f, Float.NaN, 3.7f,
27.0f, 42.0f, Float.NaN };
- assertEquals(1.2f, IEEE754rUtils.min(bF), 0.01);
- assertEquals(42.0f, IEEE754rUtils.max(bF), 0.01);
+ public void testConstructorExists() {
+ new IEEE754rUtils();
}
@Test
@@ -97,8 +76,29 @@ public class IEEE754rUtilsTest {
}
@Test
- public void testConstructorExists() {
- new IEEE754rUtils();
+ public void testLang381() {
+ assertEquals(1.2, IEEE754rUtils.min(1.2, 2.5, Double.NaN), 0.01);
+ assertEquals(2.5, IEEE754rUtils.max(1.2, 2.5, Double.NaN), 0.01);
+ assertTrue(Double.isNaN(IEEE754rUtils.max(Double.NaN, Double.NaN,
Double.NaN)));
+ assertEquals(1.2f, IEEE754rUtils.min(1.2f, 2.5f, Float.NaN), 0.01);
+ assertEquals(2.5f, IEEE754rUtils.max(1.2f, 2.5f, Float.NaN), 0.01);
+ assertTrue(Float.isNaN(IEEE754rUtils.max(Float.NaN, Float.NaN,
Float.NaN)));
+
+ final double[] a = new double[] { 1.2, Double.NaN, 3.7, 27.0, 42.0,
Double.NaN };
+ assertEquals(42.0, IEEE754rUtils.max(a), 0.01);
+ assertEquals(1.2, IEEE754rUtils.min(a), 0.01);
+
+ final double[] b = new double[] { Double.NaN, 1.2, Double.NaN, 3.7,
27.0, 42.0, Double.NaN };
+ assertEquals(42.0, IEEE754rUtils.max(b), 0.01);
+ assertEquals(1.2, IEEE754rUtils.min(b), 0.01);
+
+ final float[] aF = new float[] { 1.2f, Float.NaN, 3.7f, 27.0f, 42.0f,
Float.NaN };
+ assertEquals(1.2f, IEEE754rUtils.min(aF), 0.01);
+ assertEquals(42.0f, IEEE754rUtils.max(aF), 0.01);
+
+ final float[] bF = new float[] { Float.NaN, 1.2f, Float.NaN, 3.7f,
27.0f, 42.0f, Float.NaN };
+ assertEquals(1.2f, IEEE754rUtils.min(bF), 0.01);
+ assertEquals(42.0f, IEEE754rUtils.max(bF), 0.01);
}
}
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 02155a2..53ece82 100644
--- a/src/test/java/org/apache/commons/lang3/mutable/MutableBooleanTest.java
+++ b/src/test/java/org/apache/commons/lang3/mutable/MutableBooleanTest.java
@@ -50,6 +50,11 @@ public class MutableBooleanTest {
assertThrows(NullPointerException.class, () ->
mutBool.compareTo(null));
}
+ @Test
+ public void testConstructorNull() {
+ assertThrows(NullPointerException.class, () -> new
MutableBoolean(null));
+ }
+
// ----------------------------------------------------------------
@Test
public void testConstructors() {
@@ -64,11 +69,6 @@ public class MutableBooleanTest {
}
@Test
- public void testConstructorNull() {
- assertThrows(NullPointerException.class, () -> new
MutableBoolean(null));
- }
-
- @Test
public void testEquals() {
final MutableBoolean mutBoolA = new MutableBoolean(false);
final MutableBoolean mutBoolB = new MutableBoolean(false);
@@ -118,12 +118,6 @@ public class MutableBooleanTest {
}
@Test
- public void testSetNull() {
- final MutableBoolean mutBool = new MutableBoolean(false);
- assertThrows(NullPointerException.class, () -> mutBool.setValue(null));
- }
-
- @Test
public void testHashCode() {
final MutableBoolean mutBoolA = new MutableBoolean(false);
final MutableBoolean mutBoolB = new MutableBoolean(false);
@@ -137,6 +131,12 @@ public class MutableBooleanTest {
}
@Test
+ public void testSetNull() {
+ final MutableBoolean mutBool = new MutableBoolean(false);
+ assertThrows(NullPointerException.class, () -> mutBool.setValue(null));
+ }
+
+ @Test
public void testToString() {
assertEquals(Boolean.FALSE.toString(), new
MutableBoolean(false).toString());
assertEquals(Boolean.TRUE.toString(), new
MutableBoolean(true).toString());
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 1f2e978..fa94ee0 100644
--- a/src/test/java/org/apache/commons/lang3/mutable/MutableByteTest.java
+++ b/src/test/java/org/apache/commons/lang3/mutable/MutableByteTest.java
@@ -29,78 +29,38 @@ import org.junit.jupiter.api.Test;
*/
public class MutableByteTest {
- // ----------------------------------------------------------------
@Test
- public void testConstructors() {
- assertEquals((byte) 0, new MutableByte().byteValue());
-
- assertEquals((byte) 1, new MutableByte((byte) 1).byteValue());
-
- assertEquals((byte) 2, new MutableByte(Byte.valueOf((byte)
2)).byteValue());
- assertEquals((byte) 3, new MutableByte(new MutableByte((byte)
3)).byteValue());
-
- assertEquals((byte) 2, new MutableByte("2").byteValue());
-
- }
+ public void testAddAndGetValueObject() {
+ final MutableByte mutableByte = new MutableByte((byte) 0);
+ final byte result = mutableByte.addAndGet(Byte.valueOf((byte) 1));
- @Test
- public void testConstructorNull() {
- assertThrows(NullPointerException.class, () -> new
MutableByte((Number) null));
+ assertEquals((byte) 1, result);
+ assertEquals((byte) 1, mutableByte.byteValue());
}
@Test
- public void testGetSet() {
- final MutableByte mutNum = new MutableByte((byte) 0);
- assertEquals((byte) 0, new MutableByte().byteValue());
- assertEquals(Byte.valueOf((byte) 0), new MutableByte().getValue());
-
- mutNum.setValue((byte) 1);
- assertEquals((byte) 1, mutNum.byteValue());
- assertEquals(Byte.valueOf((byte) 1), mutNum.getValue());
-
- mutNum.setValue(Byte.valueOf((byte) 2));
- assertEquals((byte) 2, mutNum.byteValue());
- assertEquals(Byte.valueOf((byte) 2), mutNum.getValue());
-
- mutNum.setValue(new MutableByte((byte) 3));
- assertEquals((byte) 3, mutNum.byteValue());
- assertEquals(Byte.valueOf((byte) 3), mutNum.getValue());
- }
+ public void testAddAndGetValuePrimitive() {
+ final MutableByte mutableByte = new MutableByte((byte) 0);
+ final byte result = mutableByte.addAndGet((byte) 1);
- @Test
- public void testSetNull() {
- final MutableByte mutNum = new MutableByte((byte) 0);
- assertThrows(NullPointerException.class, () -> mutNum.setValue(null));
+ assertEquals((byte) 1, result);
+ assertEquals((byte) 1, mutableByte.byteValue());
}
@Test
- public void testEquals() {
- final MutableByte mutNumA = new MutableByte((byte) 0);
- final MutableByte mutNumB = new MutableByte((byte) 0);
- final MutableByte mutNumC = new MutableByte((byte) 1);
+ public void testAddValueObject() {
+ final MutableByte mutNum = new MutableByte((byte) 1);
+ mutNum.add(Integer.valueOf(1));
- 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);
+ assertEquals((byte) 2, mutNum.byteValue());
}
@Test
- public void testHashCode() {
- final MutableByte mutNumA = new MutableByte((byte) 0);
- final MutableByte mutNumB = new MutableByte((byte) 0);
- final MutableByte mutNumC = new MutableByte((byte) 1);
+ public void testAddValuePrimitive() {
+ final MutableByte mutNum = new MutableByte((byte) 1);
+ mutNum.add((byte) 1);
- assertEquals(mutNumA.hashCode(), mutNumA.hashCode());
- assertEquals(mutNumA.hashCode(), mutNumB.hashCode());
- assertNotEquals(mutNumA.hashCode(), mutNumC.hashCode());
- assertEquals(mutNumA.hashCode(), Byte.valueOf((byte) 0).hashCode());
+ assertEquals((byte) 2, mutNum.byteValue());
}
@Test
@@ -119,49 +79,22 @@ public class MutableByteTest {
}
@Test
- public void testPrimitiveValues() {
- final MutableByte mutNum = new MutableByte( (byte) 1 );
- assertEquals(1.0F, mutNum.floatValue());
- assertEquals(1.0, mutNum.doubleValue());
- assertEquals( (byte) 1, mutNum.byteValue() );
- assertEquals( (short) 1, mutNum.shortValue() );
- assertEquals( 1, mutNum.intValue() );
- assertEquals( 1L, mutNum.longValue() );
- }
-
- @Test
- public void testToByte() {
- assertEquals(Byte.valueOf((byte) 0), new MutableByte((byte)
0).toByte());
- assertEquals(Byte.valueOf((byte) 123), new MutableByte((byte)
123).toByte());
+ public void testConstructorNull() {
+ assertThrows(NullPointerException.class, () -> new
MutableByte((Number) null));
}
+ // ----------------------------------------------------------------
@Test
- public void testIncrement() {
- final MutableByte mutNum = new MutableByte((byte) 1);
- mutNum.increment();
-
- assertEquals(2, mutNum.intValue());
- assertEquals(2L, mutNum.longValue());
- }
+ public void testConstructors() {
+ assertEquals((byte) 0, new MutableByte().byteValue());
- @Test
- public void testIncrementAndGet() {
- final MutableByte mutNum = new MutableByte((byte) 1);
- final byte result = mutNum.incrementAndGet();
+ assertEquals((byte) 1, new MutableByte((byte) 1).byteValue());
- assertEquals(2, result);
- assertEquals(2, mutNum.intValue());
- assertEquals(2L, mutNum.longValue());
- }
+ assertEquals((byte) 2, new MutableByte(Byte.valueOf((byte)
2)).byteValue());
+ assertEquals((byte) 3, new MutableByte(new MutableByte((byte)
3)).byteValue());
- @Test
- public void testGetAndIncrement() {
- final MutableByte mutNum = new MutableByte((byte) 1);
- final byte result = mutNum.getAndIncrement();
+ assertEquals((byte) 2, new MutableByte("2").byteValue());
- assertEquals(1, result);
- assertEquals(2, mutNum.intValue());
- assertEquals(2L, mutNum.longValue());
}
@Test
@@ -184,6 +117,42 @@ public class MutableByteTest {
}
@Test
+ public void testEquals() {
+ final MutableByte mutNumA = new MutableByte((byte) 0);
+ final MutableByte mutNumB = new MutableByte((byte) 0);
+ final MutableByte mutNumC = new MutableByte((byte) 1);
+
+ 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
+ public void testGetAndAddValueObject() {
+ final MutableByte mutableByte = new MutableByte((byte) 0);
+ final byte result = mutableByte.getAndAdd(Byte.valueOf((byte) 1));
+
+ assertEquals((byte) 0, result);
+ assertEquals((byte) 1, mutableByte.byteValue());
+ }
+
+ @Test
+ public void testGetAndAddValuePrimitive() {
+ final MutableByte mutableByte = new MutableByte((byte) 0);
+ final byte result = mutableByte.getAndAdd((byte) 1);
+
+ assertEquals((byte) 0, result);
+ assertEquals((byte) 1, mutableByte.byteValue());
+ }
+
+ @Test
public void testGetAndDecrement() {
final MutableByte mutNum = new MutableByte((byte) 1);
final byte result = mutNum.getAndDecrement();
@@ -194,74 +163,105 @@ public class MutableByteTest {
}
@Test
- public void testAddValuePrimitive() {
+ public void testGetAndIncrement() {
final MutableByte mutNum = new MutableByte((byte) 1);
- mutNum.add((byte) 1);
+ final byte result = mutNum.getAndIncrement();
- assertEquals((byte) 2, mutNum.byteValue());
+ assertEquals(1, result);
+ assertEquals(2, mutNum.intValue());
+ assertEquals(2L, mutNum.longValue());
}
@Test
- public void testAddValueObject() {
- final MutableByte mutNum = new MutableByte((byte) 1);
- mutNum.add(Integer.valueOf(1));
+ public void testGetSet() {
+ final MutableByte mutNum = new MutableByte((byte) 0);
+ assertEquals((byte) 0, new MutableByte().byteValue());
+ assertEquals(Byte.valueOf((byte) 0), new MutableByte().getValue());
+
+ mutNum.setValue((byte) 1);
+ assertEquals((byte) 1, mutNum.byteValue());
+ assertEquals(Byte.valueOf((byte) 1), mutNum.getValue());
+ mutNum.setValue(Byte.valueOf((byte) 2));
assertEquals((byte) 2, mutNum.byteValue());
+ assertEquals(Byte.valueOf((byte) 2), mutNum.getValue());
+
+ mutNum.setValue(new MutableByte((byte) 3));
+ assertEquals((byte) 3, mutNum.byteValue());
+ assertEquals(Byte.valueOf((byte) 3), mutNum.getValue());
}
@Test
- public void testGetAndAddValuePrimitive() {
- final MutableByte mutableByte = new MutableByte((byte) 0);
- final byte result = mutableByte.getAndAdd((byte) 1);
+ public void testHashCode() {
+ final MutableByte mutNumA = new MutableByte((byte) 0);
+ final MutableByte mutNumB = new MutableByte((byte) 0);
+ final MutableByte mutNumC = new MutableByte((byte) 1);
- assertEquals((byte) 0, result);
- assertEquals((byte) 1, mutableByte.byteValue());
+ assertEquals(mutNumA.hashCode(), mutNumA.hashCode());
+ assertEquals(mutNumA.hashCode(), mutNumB.hashCode());
+ assertNotEquals(mutNumA.hashCode(), mutNumC.hashCode());
+ assertEquals(mutNumA.hashCode(), Byte.valueOf((byte) 0).hashCode());
}
@Test
- public void testGetAndAddValueObject() {
- final MutableByte mutableByte = new MutableByte((byte) 0);
- final byte result = mutableByte.getAndAdd(Byte.valueOf((byte) 1));
+ public void testIncrement() {
+ final MutableByte mutNum = new MutableByte((byte) 1);
+ mutNum.increment();
- assertEquals((byte) 0, result);
- assertEquals((byte) 1, mutableByte.byteValue());
+ assertEquals(2, mutNum.intValue());
+ assertEquals(2L, mutNum.longValue());
}
@Test
- public void testAddAndGetValuePrimitive() {
- final MutableByte mutableByte = new MutableByte((byte) 0);
- final byte result = mutableByte.addAndGet((byte) 1);
+ public void testIncrementAndGet() {
+ final MutableByte mutNum = new MutableByte((byte) 1);
+ final byte result = mutNum.incrementAndGet();
- assertEquals((byte) 1, result);
- assertEquals((byte) 1, mutableByte.byteValue());
+ assertEquals(2, result);
+ assertEquals(2, mutNum.intValue());
+ assertEquals(2L, mutNum.longValue());
}
@Test
- public void testAddAndGetValueObject() {
- final MutableByte mutableByte = new MutableByte((byte) 0);
- final byte result = mutableByte.addAndGet(Byte.valueOf((byte) 1));
+ public void testPrimitiveValues() {
+ final MutableByte mutNum = new MutableByte( (byte) 1 );
+ assertEquals(1.0F, mutNum.floatValue());
+ assertEquals(1.0, mutNum.doubleValue());
+ assertEquals( (byte) 1, mutNum.byteValue() );
+ assertEquals( (short) 1, mutNum.shortValue() );
+ assertEquals( 1, mutNum.intValue() );
+ assertEquals( 1L, mutNum.longValue() );
+ }
- assertEquals((byte) 1, result);
- assertEquals((byte) 1, mutableByte.byteValue());
+ @Test
+ public void testSetNull() {
+ final MutableByte mutNum = new MutableByte((byte) 0);
+ assertThrows(NullPointerException.class, () -> mutNum.setValue(null));
}
@Test
- public void testSubtractValuePrimitive() {
+ public void testSubtractValueObject() {
final MutableByte mutNum = new MutableByte((byte) 1);
- mutNum.subtract((byte) 1);
+ mutNum.subtract(Integer.valueOf(1));
assertEquals((byte) 0, mutNum.byteValue());
}
@Test
- public void testSubtractValueObject() {
+ public void testSubtractValuePrimitive() {
final MutableByte mutNum = new MutableByte((byte) 1);
- mutNum.subtract(Integer.valueOf(1));
+ mutNum.subtract((byte) 1);
assertEquals((byte) 0, mutNum.byteValue());
}
@Test
+ public void testToByte() {
+ assertEquals(Byte.valueOf((byte) 0), new MutableByte((byte)
0).toByte());
+ assertEquals(Byte.valueOf((byte) 123), new MutableByte((byte)
123).toByte());
+ }
+
+ @Test
public void testToString() {
assertEquals("0", new MutableByte((byte) 0).toString());
assertEquals("10", new MutableByte((byte) 10).toString());
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 ccb8fc7..cf51933 100644
--- a/src/test/java/org/apache/commons/lang3/mutable/MutableDoubleTest.java
+++ b/src/test/java/org/apache/commons/lang3/mutable/MutableDoubleTest.java
@@ -30,18 +30,53 @@ import org.junit.jupiter.api.Test;
*/
public class MutableDoubleTest {
- // ----------------------------------------------------------------
@Test
- public void testConstructors() {
- assertEquals(0d, new MutableDouble().doubleValue(), 0.0001d);
+ public void testAddAndGetValueObject() {
+ final MutableDouble mutableDouble = new MutableDouble(7.5d);
+ final double result = mutableDouble.addAndGet(Double.valueOf(-2.5d));
- assertEquals(1d, new MutableDouble(1d).doubleValue(), 0.0001d);
+ assertEquals(5d, result, 0.01d);
+ assertEquals(5d, mutableDouble.doubleValue(), 0.01d);
+ }
- assertEquals(2d, new MutableDouble(Double.valueOf(2d)).doubleValue(),
0.0001d);
- assertEquals(3d, new MutableDouble(new
MutableDouble(3d)).doubleValue(), 0.0001d);
+ @Test
+ public void testAddAndGetValuePrimitive() {
+ final MutableDouble mutableDouble = new MutableDouble(10.5d);
+ final double result = mutableDouble.addAndGet(-0.5d);
- assertEquals(2d, new MutableDouble("2.0").doubleValue(), 0.0001d);
+ assertEquals(10d, result, 0.01d);
+ assertEquals(10d, mutableDouble.doubleValue(), 0.01d);
+ }
+ @Test
+ public void testAddValueObject() {
+ final MutableDouble mutNum = new MutableDouble(1);
+ mutNum.add(Double.valueOf(1.1d));
+
+ assertEquals(2.1d, mutNum.doubleValue(), 0.01d);
+ }
+
+ @Test
+ public void testAddValuePrimitive() {
+ final MutableDouble mutNum = new MutableDouble(1);
+ mutNum.add(1.1d);
+
+ assertEquals(2.1d, mutNum.doubleValue(), 0.01d);
+ }
+
+ @Test
+ public void testCompareTo() {
+ final MutableDouble mutNum = new MutableDouble(0d);
+
+ assertEquals(0, mutNum.compareTo(new MutableDouble(0d)));
+ assertEquals(+1, mutNum.compareTo(new MutableDouble(-1d)));
+ assertEquals(-1, mutNum.compareTo(new MutableDouble(1d)));
+ }
+
+ @Test
+ public void testCompareToNull() {
+ final MutableDouble mutNum = new MutableDouble(0d);
+ assertThrows(NullPointerException.class, () -> mutNum.compareTo(null));
}
@Test
@@ -49,41 +84,37 @@ public class MutableDoubleTest {
assertThrows(NullPointerException.class, () -> new
MutableDouble((Number) null));
}
+ // ----------------------------------------------------------------
@Test
- public void testGetSet() {
- final MutableDouble mutNum = new MutableDouble(0d);
+ public void testConstructors() {
assertEquals(0d, new MutableDouble().doubleValue(), 0.0001d);
- assertEquals(Double.valueOf(0), new MutableDouble().getValue());
- mutNum.setValue(1);
- assertEquals(1d, mutNum.doubleValue(), 0.0001d);
- assertEquals(Double.valueOf(1d), mutNum.getValue());
+ assertEquals(1d, new MutableDouble(1d).doubleValue(), 0.0001d);
- mutNum.setValue(Double.valueOf(2d));
- assertEquals(2d, mutNum.doubleValue(), 0.0001d);
- assertEquals(Double.valueOf(2d), mutNum.getValue());
+ assertEquals(2d, new MutableDouble(Double.valueOf(2d)).doubleValue(),
0.0001d);
+ assertEquals(3d, new MutableDouble(new
MutableDouble(3d)).doubleValue(), 0.0001d);
+
+ assertEquals(2d, new MutableDouble("2.0").doubleValue(), 0.0001d);
- mutNum.setValue(new MutableDouble(3d));
- assertEquals(3d, mutNum.doubleValue(), 0.0001d);
- assertEquals(Double.valueOf(3d), mutNum.getValue());
}
@Test
- public void testSetNull() {
- final MutableDouble mutNum = new MutableDouble(0d);
- assertThrows(NullPointerException.class, () -> mutNum.setValue(null));
+ public void testDecrement() {
+ final MutableDouble mutNum = new MutableDouble(1);
+ mutNum.decrement();
+
+ assertEquals(0, mutNum.intValue());
+ assertEquals(0L, mutNum.longValue());
}
@Test
- public void testNanInfinite() {
- MutableDouble mutNum = new MutableDouble(Double.NaN);
- assertTrue(mutNum.isNaN());
-
- mutNum = new MutableDouble(Double.POSITIVE_INFINITY);
- assertTrue(mutNum.isInfinite());
+ public void testDecrementAndGet() {
+ final MutableDouble mutNum = new MutableDouble(1d);
+ final double result = mutNum.decrementAndGet();
- mutNum = new MutableDouble(Double.NEGATIVE_INFINITY);
- assertTrue(mutNum.isInfinite());
+ assertEquals(0d, result, 0.01d);
+ assertEquals(0, mutNum.intValue());
+ assertEquals(0L, mutNum.longValue());
}
@Test
@@ -105,66 +136,31 @@ public class MutableDoubleTest {
}
@Test
- public void testHashCode() {
- final MutableDouble mutNumA = new MutableDouble(0d);
- final MutableDouble mutNumB = new MutableDouble(0d);
- final MutableDouble mutNumC = new MutableDouble(1d);
-
- assertEquals(mutNumA.hashCode(), mutNumA.hashCode());
- assertEquals(mutNumA.hashCode(), mutNumB.hashCode());
- assertNotEquals(mutNumA.hashCode(), mutNumC.hashCode());
- assertEquals(mutNumA.hashCode(), Double.valueOf(0d).hashCode());
- }
-
- @Test
- public void testCompareTo() {
- final MutableDouble mutNum = new MutableDouble(0d);
-
- assertEquals(0, mutNum.compareTo(new MutableDouble(0d)));
- assertEquals(+1, mutNum.compareTo(new MutableDouble(-1d)));
- assertEquals(-1, mutNum.compareTo(new MutableDouble(1d)));
- }
-
- @Test
- public void testCompareToNull() {
- final MutableDouble mutNum = new MutableDouble(0d);
- assertThrows(NullPointerException.class, () -> mutNum.compareTo(null));
- }
-
- @Test
- public void testPrimitiveValues() {
- final MutableDouble mutNum = new MutableDouble(1.7);
- assertEquals(1.7F, mutNum.floatValue());
- assertEquals(1.7, mutNum.doubleValue());
- assertEquals( (byte) 1, mutNum.byteValue() );
- assertEquals( (short) 1, mutNum.shortValue() );
- assertEquals( 1, mutNum.intValue() );
- assertEquals( 1L, mutNum.longValue() );
- }
+ public void testGetAndAddValueObject() {
+ final MutableDouble mutableDouble = new MutableDouble(0.5d);
+ final double result = mutableDouble.getAndAdd(Double.valueOf(2d));
- @Test
- public void testToDouble() {
- assertEquals(Double.valueOf(0d), new MutableDouble(0d).toDouble());
- assertEquals(Double.valueOf(12.3d), new
MutableDouble(12.3d).toDouble());
+ assertEquals(0.5d, result, 0.01d);
+ assertEquals(2.5d, mutableDouble.doubleValue(), 0.01d);
}
@Test
- public void testIncrement() {
- final MutableDouble mutNum = new MutableDouble(1);
- mutNum.increment();
+ public void testGetAndAddValuePrimitive() {
+ final MutableDouble mutableDouble = new MutableDouble(0.5d);
+ final double result = mutableDouble.getAndAdd(1d);
- assertEquals(2, mutNum.intValue());
- assertEquals(2L, mutNum.longValue());
+ assertEquals(0.5d, result, 0.01d);
+ assertEquals(1.5d, mutableDouble.doubleValue(), 0.01d);
}
@Test
- public void testIncrementAndGet() {
+ public void testGetAndDecrement() {
final MutableDouble mutNum = new MutableDouble(1d);
- final double result = mutNum.incrementAndGet();
+ final double result = mutNum.getAndDecrement();
- assertEquals(2d, result, 0.01d);
- assertEquals(2, mutNum.intValue());
- assertEquals(2L, mutNum.longValue());
+ assertEquals(1d, result, 0.01d);
+ assertEquals(0, mutNum.intValue());
+ assertEquals(0L, mutNum.longValue());
}
@Test
@@ -178,84 +174,90 @@ public class MutableDoubleTest {
}
@Test
- public void testDecrement() {
- final MutableDouble mutNum = new MutableDouble(1);
- mutNum.decrement();
+ public void testGetSet() {
+ final MutableDouble mutNum = new MutableDouble(0d);
+ assertEquals(0d, new MutableDouble().doubleValue(), 0.0001d);
+ assertEquals(Double.valueOf(0), new MutableDouble().getValue());
- assertEquals(0, mutNum.intValue());
- assertEquals(0L, mutNum.longValue());
- }
+ mutNum.setValue(1);
+ assertEquals(1d, mutNum.doubleValue(), 0.0001d);
+ assertEquals(Double.valueOf(1d), mutNum.getValue());
- @Test
- public void testDecrementAndGet() {
- final MutableDouble mutNum = new MutableDouble(1d);
- final double result = mutNum.decrementAndGet();
+ mutNum.setValue(Double.valueOf(2d));
+ assertEquals(2d, mutNum.doubleValue(), 0.0001d);
+ assertEquals(Double.valueOf(2d), mutNum.getValue());
- assertEquals(0d, result, 0.01d);
- assertEquals(0, mutNum.intValue());
- assertEquals(0L, mutNum.longValue());
+ mutNum.setValue(new MutableDouble(3d));
+ assertEquals(3d, mutNum.doubleValue(), 0.0001d);
+ assertEquals(Double.valueOf(3d), mutNum.getValue());
}
@Test
- public void testGetAndDecrement() {
- final MutableDouble mutNum = new MutableDouble(1d);
- final double result = mutNum.getAndDecrement();
+ public void testHashCode() {
+ final MutableDouble mutNumA = new MutableDouble(0d);
+ final MutableDouble mutNumB = new MutableDouble(0d);
+ final MutableDouble mutNumC = new MutableDouble(1d);
- assertEquals(1d, result, 0.01d);
- assertEquals(0, mutNum.intValue());
- assertEquals(0L, mutNum.longValue());
+ assertEquals(mutNumA.hashCode(), mutNumA.hashCode());
+ assertEquals(mutNumA.hashCode(), mutNumB.hashCode());
+ assertNotEquals(mutNumA.hashCode(), mutNumC.hashCode());
+ assertEquals(mutNumA.hashCode(), Double.valueOf(0d).hashCode());
}
@Test
- public void testAddValuePrimitive() {
+ public void testIncrement() {
final MutableDouble mutNum = new MutableDouble(1);
- mutNum.add(1.1d);
+ mutNum.increment();
- assertEquals(2.1d, mutNum.doubleValue(), 0.01d);
+ assertEquals(2, mutNum.intValue());
+ assertEquals(2L, mutNum.longValue());
}
@Test
- public void testAddValueObject() {
- final MutableDouble mutNum = new MutableDouble(1);
- mutNum.add(Double.valueOf(1.1d));
+ public void testIncrementAndGet() {
+ final MutableDouble mutNum = new MutableDouble(1d);
+ final double result = mutNum.incrementAndGet();
- assertEquals(2.1d, mutNum.doubleValue(), 0.01d);
+ assertEquals(2d, result, 0.01d);
+ assertEquals(2, mutNum.intValue());
+ assertEquals(2L, mutNum.longValue());
}
@Test
- public void testGetAndAddValuePrimitive() {
- final MutableDouble mutableDouble = new MutableDouble(0.5d);
- final double result = mutableDouble.getAndAdd(1d);
+ public void testNanInfinite() {
+ MutableDouble mutNum = new MutableDouble(Double.NaN);
+ assertTrue(mutNum.isNaN());
- assertEquals(0.5d, result, 0.01d);
- assertEquals(1.5d, mutableDouble.doubleValue(), 0.01d);
+ mutNum = new MutableDouble(Double.POSITIVE_INFINITY);
+ assertTrue(mutNum.isInfinite());
+
+ mutNum = new MutableDouble(Double.NEGATIVE_INFINITY);
+ assertTrue(mutNum.isInfinite());
}
@Test
- public void testGetAndAddValueObject() {
- final MutableDouble mutableDouble = new MutableDouble(0.5d);
- final double result = mutableDouble.getAndAdd(Double.valueOf(2d));
-
- assertEquals(0.5d, result, 0.01d);
- assertEquals(2.5d, mutableDouble.doubleValue(), 0.01d);
+ public void testPrimitiveValues() {
+ final MutableDouble mutNum = new MutableDouble(1.7);
+ assertEquals(1.7F, mutNum.floatValue());
+ assertEquals(1.7, mutNum.doubleValue());
+ assertEquals( (byte) 1, mutNum.byteValue() );
+ assertEquals( (short) 1, mutNum.shortValue() );
+ assertEquals( 1, mutNum.intValue() );
+ assertEquals( 1L, mutNum.longValue() );
}
@Test
- public void testAddAndGetValuePrimitive() {
- final MutableDouble mutableDouble = new MutableDouble(10.5d);
- final double result = mutableDouble.addAndGet(-0.5d);
-
- assertEquals(10d, result, 0.01d);
- assertEquals(10d, mutableDouble.doubleValue(), 0.01d);
+ public void testSetNull() {
+ final MutableDouble mutNum = new MutableDouble(0d);
+ assertThrows(NullPointerException.class, () -> mutNum.setValue(null));
}
@Test
- public void testAddAndGetValueObject() {
- final MutableDouble mutableDouble = new MutableDouble(7.5d);
- final double result = mutableDouble.addAndGet(Double.valueOf(-2.5d));
+ public void testSubtractValueObject() {
+ final MutableDouble mutNum = new MutableDouble(1);
+ mutNum.subtract(Double.valueOf(0.9d));
- assertEquals(5d, result, 0.01d);
- assertEquals(5d, mutableDouble.doubleValue(), 0.01d);
+ assertEquals(0.1d, mutNum.doubleValue(), 0.01d);
}
@Test
@@ -267,11 +269,9 @@ public class MutableDoubleTest {
}
@Test
- public void testSubtractValueObject() {
- final MutableDouble mutNum = new MutableDouble(1);
- mutNum.subtract(Double.valueOf(0.9d));
-
- assertEquals(0.1d, mutNum.doubleValue(), 0.01d);
+ public void testToDouble() {
+ assertEquals(Double.valueOf(0d), new MutableDouble(0d).toDouble());
+ assertEquals(Double.valueOf(12.3d), new
MutableDouble(12.3d).toDouble());
}
@Test
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 f3105bb..7538367 100644
--- a/src/test/java/org/apache/commons/lang3/mutable/MutableFloatTest.java
+++ b/src/test/java/org/apache/commons/lang3/mutable/MutableFloatTest.java
@@ -30,18 +30,53 @@ import org.junit.jupiter.api.Test;
*/
public class MutableFloatTest {
- // ----------------------------------------------------------------
@Test
- public void testConstructors() {
- assertEquals(0f, new MutableFloat().floatValue(), 0.0001f);
+ public void testAddAndGetValueObject() {
+ final MutableFloat mutableFloat = new MutableFloat(5f);
+ final float result = mutableFloat.addAndGet(Float.valueOf(2.5f));
- assertEquals(1f, new MutableFloat(1f).floatValue(), 0.0001f);
+ assertEquals(7.5f, result, 0.01f);
+ assertEquals(7.5f, mutableFloat.floatValue(), 0.01f);
+ }
- assertEquals(2f, new MutableFloat(Float.valueOf(2f)).floatValue(),
0.0001f);
- assertEquals(3f, new MutableFloat(new MutableFloat(3f)).floatValue(),
0.0001f);
+ @Test
+ public void testAddAndGetValuePrimitive() {
+ final MutableFloat mutableFloat = new MutableFloat(0.5f);
+ final float result = mutableFloat.addAndGet(1f);
- assertEquals(2f, new MutableFloat("2.0").floatValue(), 0.0001f);
+ assertEquals(1.5f, result, 0.01f);
+ assertEquals(1.5f, mutableFloat.floatValue(), 0.01f);
+ }
+ @Test
+ public void testAddValueObject() {
+ final MutableFloat mutNum = new MutableFloat(1);
+ mutNum.add(Float.valueOf(1.1f));
+
+ assertEquals(2.1f, mutNum.floatValue(), 0.01f);
+ }
+
+ @Test
+ public void testAddValuePrimitive() {
+ final MutableFloat mutNum = new MutableFloat(1);
+ mutNum.add(1.1f);
+
+ assertEquals(2.1f, mutNum.floatValue(), 0.01f);
+ }
+
+ @Test
+ public void testCompareTo() {
+ final MutableFloat mutNum = new MutableFloat(0f);
+
+ assertEquals(0, mutNum.compareTo(new MutableFloat(0f)));
+ assertEquals(+1, mutNum.compareTo(new MutableFloat(-1f)));
+ assertEquals(-1, mutNum.compareTo(new MutableFloat(1f)));
+ }
+
+ @Test
+ public void testCompareToNull() {
+ final MutableFloat mutNum = new MutableFloat(0f);
+ assertThrows(NullPointerException.class, () -> mutNum.compareTo(null));
}
@Test
@@ -49,41 +84,37 @@ public class MutableFloatTest {
assertThrows(NullPointerException.class, () -> new
MutableFloat((Number) null));
}
+ // ----------------------------------------------------------------
@Test
- public void testGetSet() {
- final MutableFloat mutNum = new MutableFloat(0f);
+ public void testConstructors() {
assertEquals(0f, new MutableFloat().floatValue(), 0.0001f);
- assertEquals(Float.valueOf(0), new MutableFloat().getValue());
- mutNum.setValue(1);
- assertEquals(1f, mutNum.floatValue(), 0.0001f);
- assertEquals(Float.valueOf(1f), mutNum.getValue());
+ assertEquals(1f, new MutableFloat(1f).floatValue(), 0.0001f);
- mutNum.setValue(Float.valueOf(2f));
- assertEquals(2f, mutNum.floatValue(), 0.0001f);
- assertEquals(Float.valueOf(2f), mutNum.getValue());
+ assertEquals(2f, new MutableFloat(Float.valueOf(2f)).floatValue(),
0.0001f);
+ assertEquals(3f, new MutableFloat(new MutableFloat(3f)).floatValue(),
0.0001f);
+
+ assertEquals(2f, new MutableFloat("2.0").floatValue(), 0.0001f);
- mutNum.setValue(new MutableFloat(3f));
- assertEquals(3f, mutNum.floatValue(), 0.0001f);
- assertEquals(Float.valueOf(3f), mutNum.getValue());
}
@Test
- public void testSetNull() {
- final MutableFloat mutNum = new MutableFloat(0f);
- assertThrows(NullPointerException.class, () -> mutNum.setValue(null));
+ public void testDecrement() {
+ final MutableFloat mutNum = new MutableFloat(1);
+ mutNum.decrement();
+
+ assertEquals(0, mutNum.intValue());
+ assertEquals(0L, mutNum.longValue());
}
@Test
- public void testNanInfinite() {
- MutableFloat mutNum = new MutableFloat(Float.NaN);
- assertTrue(mutNum.isNaN());
-
- mutNum = new MutableFloat(Float.POSITIVE_INFINITY);
- assertTrue(mutNum.isInfinite());
+ public void testDecrementAndGet() {
+ final MutableFloat mutNum = new MutableFloat(1f);
+ final float result = mutNum.decrementAndGet();
- mutNum = new MutableFloat(Float.NEGATIVE_INFINITY);
- assertTrue(mutNum.isInfinite());
+ assertEquals(0f, result, 0.01f);
+ assertEquals(0, mutNum.intValue());
+ assertEquals(0L, mutNum.longValue());
}
@Test
@@ -105,67 +136,31 @@ public class MutableFloatTest {
}
@Test
- public void testHashCode() {
- final MutableFloat mutNumA = new MutableFloat(0f);
- final MutableFloat mutNumB = new MutableFloat(0f);
- final MutableFloat mutNumC = new MutableFloat(1f);
-
- assertEquals(mutNumA.hashCode(), mutNumA.hashCode());
- assertEquals(mutNumA.hashCode(), mutNumB.hashCode());
- assertNotEquals(mutNumA.hashCode(), mutNumC.hashCode());
- assertEquals(mutNumA.hashCode(), Float.valueOf(0f).hashCode());
- }
-
- @Test
- public void testCompareTo() {
- final MutableFloat mutNum = new MutableFloat(0f);
-
- assertEquals(0, mutNum.compareTo(new MutableFloat(0f)));
- assertEquals(+1, mutNum.compareTo(new MutableFloat(-1f)));
- assertEquals(-1, mutNum.compareTo(new MutableFloat(1f)));
- }
-
- @Test
- public void testCompareToNull() {
- final MutableFloat mutNum = new MutableFloat(0f);
- assertThrows(NullPointerException.class, () -> mutNum.compareTo(null));
- }
-
- @Test
- public void testPrimitiveValues() {
- final MutableFloat mutNum = new MutableFloat(1.7F);
-
- assertEquals( 1, mutNum.intValue() );
- assertEquals( 1.7, mutNum.doubleValue(), 0.00001 );
- assertEquals( (byte) 1, mutNum.byteValue() );
- assertEquals( (short) 1, mutNum.shortValue() );
- assertEquals( 1, mutNum.intValue() );
- assertEquals( 1L, mutNum.longValue() );
- }
+ public void testGetAndAddValueObject() {
+ final MutableFloat mutableFloat = new MutableFloat(7.75f);
+ final float result = mutableFloat.getAndAdd(Float.valueOf(2.25f));
- @Test
- public void testToFloat() {
- assertEquals(Float.valueOf(0f), new MutableFloat(0f).toFloat());
- assertEquals(Float.valueOf(12.3f), new MutableFloat(12.3f).toFloat());
+ assertEquals(7.75f, result, 0.01f);
+ assertEquals(10f, mutableFloat.floatValue(), 0.01f);
}
@Test
- public void testIncrement() {
- final MutableFloat mutNum = new MutableFloat(1);
- mutNum.increment();
+ public void testGetAndAddValuePrimitive() {
+ final MutableFloat mutableFloat = new MutableFloat(1.25f);
+ final float result = mutableFloat.getAndAdd(0.75f);
- assertEquals(2, mutNum.intValue());
- assertEquals(2L, mutNum.longValue());
+ assertEquals(1.25f, result, 0.01f);
+ assertEquals(2f, mutableFloat.floatValue(), 0.01f);
}
@Test
- public void testIncrementAndGet() {
+ public void testGetAndDecrement() {
final MutableFloat mutNum = new MutableFloat(1f);
- final float result = mutNum.incrementAndGet();
+ final float result = mutNum.getAndDecrement();
- assertEquals(2f, result, 0.01f);
- assertEquals(2, mutNum.intValue());
- assertEquals(2L, mutNum.longValue());
+ assertEquals(1f, result, 0.01f);
+ assertEquals(0, mutNum.intValue());
+ assertEquals(0L, mutNum.longValue());
}
@Test
@@ -179,84 +174,91 @@ public class MutableFloatTest {
}
@Test
- public void testDecrement() {
- final MutableFloat mutNum = new MutableFloat(1);
- mutNum.decrement();
+ public void testGetSet() {
+ final MutableFloat mutNum = new MutableFloat(0f);
+ assertEquals(0f, new MutableFloat().floatValue(), 0.0001f);
+ assertEquals(Float.valueOf(0), new MutableFloat().getValue());
- assertEquals(0, mutNum.intValue());
- assertEquals(0L, mutNum.longValue());
- }
+ mutNum.setValue(1);
+ assertEquals(1f, mutNum.floatValue(), 0.0001f);
+ assertEquals(Float.valueOf(1f), mutNum.getValue());
- @Test
- public void testDecrementAndGet() {
- final MutableFloat mutNum = new MutableFloat(1f);
- final float result = mutNum.decrementAndGet();
+ mutNum.setValue(Float.valueOf(2f));
+ assertEquals(2f, mutNum.floatValue(), 0.0001f);
+ assertEquals(Float.valueOf(2f), mutNum.getValue());
- assertEquals(0f, result, 0.01f);
- assertEquals(0, mutNum.intValue());
- assertEquals(0L, mutNum.longValue());
+ mutNum.setValue(new MutableFloat(3f));
+ assertEquals(3f, mutNum.floatValue(), 0.0001f);
+ assertEquals(Float.valueOf(3f), mutNum.getValue());
}
@Test
- public void testGetAndDecrement() {
- final MutableFloat mutNum = new MutableFloat(1f);
- final float result = mutNum.getAndDecrement();
+ public void testHashCode() {
+ final MutableFloat mutNumA = new MutableFloat(0f);
+ final MutableFloat mutNumB = new MutableFloat(0f);
+ final MutableFloat mutNumC = new MutableFloat(1f);
- assertEquals(1f, result, 0.01f);
- assertEquals(0, mutNum.intValue());
- assertEquals(0L, mutNum.longValue());
+ assertEquals(mutNumA.hashCode(), mutNumA.hashCode());
+ assertEquals(mutNumA.hashCode(), mutNumB.hashCode());
+ assertNotEquals(mutNumA.hashCode(), mutNumC.hashCode());
+ assertEquals(mutNumA.hashCode(), Float.valueOf(0f).hashCode());
}
@Test
- public void testAddValuePrimitive() {
+ public void testIncrement() {
final MutableFloat mutNum = new MutableFloat(1);
- mutNum.add(1.1f);
+ mutNum.increment();
- assertEquals(2.1f, mutNum.floatValue(), 0.01f);
+ assertEquals(2, mutNum.intValue());
+ assertEquals(2L, mutNum.longValue());
}
@Test
- public void testAddValueObject() {
- final MutableFloat mutNum = new MutableFloat(1);
- mutNum.add(Float.valueOf(1.1f));
+ public void testIncrementAndGet() {
+ final MutableFloat mutNum = new MutableFloat(1f);
+ final float result = mutNum.incrementAndGet();
- assertEquals(2.1f, mutNum.floatValue(), 0.01f);
+ assertEquals(2f, result, 0.01f);
+ assertEquals(2, mutNum.intValue());
+ assertEquals(2L, mutNum.longValue());
}
@Test
- public void testGetAndAddValuePrimitive() {
- final MutableFloat mutableFloat = new MutableFloat(1.25f);
- final float result = mutableFloat.getAndAdd(0.75f);
+ public void testNanInfinite() {
+ MutableFloat mutNum = new MutableFloat(Float.NaN);
+ assertTrue(mutNum.isNaN());
- assertEquals(1.25f, result, 0.01f);
- assertEquals(2f, mutableFloat.floatValue(), 0.01f);
+ mutNum = new MutableFloat(Float.POSITIVE_INFINITY);
+ assertTrue(mutNum.isInfinite());
+
+ mutNum = new MutableFloat(Float.NEGATIVE_INFINITY);
+ assertTrue(mutNum.isInfinite());
}
@Test
- public void testGetAndAddValueObject() {
- final MutableFloat mutableFloat = new MutableFloat(7.75f);
- final float result = mutableFloat.getAndAdd(Float.valueOf(2.25f));
+ public void testPrimitiveValues() {
+ final MutableFloat mutNum = new MutableFloat(1.7F);
- assertEquals(7.75f, result, 0.01f);
- assertEquals(10f, mutableFloat.floatValue(), 0.01f);
+ assertEquals( 1, mutNum.intValue() );
+ assertEquals( 1.7, mutNum.doubleValue(), 0.00001 );
+ assertEquals( (byte) 1, mutNum.byteValue() );
+ assertEquals( (short) 1, mutNum.shortValue() );
+ assertEquals( 1, mutNum.intValue() );
+ assertEquals( 1L, mutNum.longValue() );
}
@Test
- public void testAddAndGetValuePrimitive() {
- final MutableFloat mutableFloat = new MutableFloat(0.5f);
- final float result = mutableFloat.addAndGet(1f);
-
- assertEquals(1.5f, result, 0.01f);
- assertEquals(1.5f, mutableFloat.floatValue(), 0.01f);
+ public void testSetNull() {
+ final MutableFloat mutNum = new MutableFloat(0f);
+ assertThrows(NullPointerException.class, () -> mutNum.setValue(null));
}
@Test
- public void testAddAndGetValueObject() {
- final MutableFloat mutableFloat = new MutableFloat(5f);
- final float result = mutableFloat.addAndGet(Float.valueOf(2.5f));
+ public void testSubtractValueObject() {
+ final MutableFloat mutNum = new MutableFloat(1);
+ mutNum.subtract(Float.valueOf(0.9f));
- assertEquals(7.5f, result, 0.01f);
- assertEquals(7.5f, mutableFloat.floatValue(), 0.01f);
+ assertEquals(0.1f, mutNum.floatValue(), 0.01f);
}
@Test
@@ -268,11 +270,9 @@ public class MutableFloatTest {
}
@Test
- public void testSubtractValueObject() {
- final MutableFloat mutNum = new MutableFloat(1);
- mutNum.subtract(Float.valueOf(0.9f));
-
- assertEquals(0.1f, mutNum.floatValue(), 0.01f);
+ public void testToFloat() {
+ assertEquals(Float.valueOf(0f), new MutableFloat(0f).toFloat());
+ assertEquals(Float.valueOf(12.3f), new MutableFloat(12.3f).toFloat());
}
@Test
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 a02a2c5..6892fa1 100644
--- a/src/test/java/org/apache/commons/lang3/mutable/MutableIntTest.java
+++ b/src/test/java/org/apache/commons/lang3/mutable/MutableIntTest.java
@@ -29,18 +29,55 @@ import org.junit.jupiter.api.Test;
*/
public class MutableIntTest {
- // ----------------------------------------------------------------
@Test
- public void testConstructors() {
- assertEquals(0, new MutableInt().intValue());
+ public void testAddAndGetValueObject() {
+ final MutableInt mutableInteger = new MutableInt(0);
+ final int result = mutableInteger.addAndGet(Integer.valueOf(1));
- assertEquals(1, new MutableInt(1).intValue());
+ assertEquals(1, result);
+ assertEquals(1, mutableInteger.intValue());
+ }
- assertEquals(2, new MutableInt(Integer.valueOf(2)).intValue());
- assertEquals(3, new MutableInt(new MutableLong(3)).intValue());
+ @Test
+ public void testAddAndGetValuePrimitive() {
+ final MutableInt mutableInteger = new MutableInt(0);
+ final int result = mutableInteger.addAndGet(1);
- assertEquals(2, new MutableInt("2").intValue());
+ assertEquals(1, result);
+ assertEquals(1, mutableInteger.intValue());
+ }
+
+ @Test
+ public void testAddValueObject() {
+ final MutableInt mutNum = new MutableInt(1);
+ mutNum.add(Integer.valueOf(1));
+ assertEquals(2, mutNum.intValue());
+ assertEquals(2L, mutNum.longValue());
+ }
+
+ @Test
+ public void testAddValuePrimitive() {
+ final MutableInt mutNum = new MutableInt(1);
+ mutNum.add(1);
+
+ assertEquals(2, mutNum.intValue());
+ assertEquals(2L, mutNum.longValue());
+ }
+
+ @Test
+ public void testCompareTo() {
+ final MutableInt mutNum = new MutableInt(0);
+
+ assertEquals(0, mutNum.compareTo(new MutableInt(0)));
+ assertEquals(+1, mutNum.compareTo(new MutableInt(-1)));
+ assertEquals(-1, mutNum.compareTo(new MutableInt(1)));
+ }
+
+ @Test
+ public void testCompareToNull() {
+ final MutableInt mutNum = new MutableInt(0);
+ assertThrows(NullPointerException.class, () -> mutNum.compareTo(null));
}
@Test
@@ -48,29 +85,37 @@ public class MutableIntTest {
assertThrows(NullPointerException.class, () -> new MutableInt((Number)
null));
}
+ // ----------------------------------------------------------------
@Test
- public void testGetSet() {
- final MutableInt mutNum = new MutableInt(0);
+ public void testConstructors() {
assertEquals(0, new MutableInt().intValue());
- assertEquals(Integer.valueOf(0), new MutableInt().getValue());
- mutNum.setValue(1);
- assertEquals(1, mutNum.intValue());
- assertEquals(Integer.valueOf(1), mutNum.getValue());
+ assertEquals(1, new MutableInt(1).intValue());
- mutNum.setValue(Integer.valueOf(2));
- assertEquals(2, mutNum.intValue());
- assertEquals(Integer.valueOf(2), mutNum.getValue());
+ assertEquals(2, new MutableInt(Integer.valueOf(2)).intValue());
+ assertEquals(3, new MutableInt(new MutableLong(3)).intValue());
+
+ assertEquals(2, new MutableInt("2").intValue());
- mutNum.setValue(new MutableLong(3));
- assertEquals(3, mutNum.intValue());
- assertEquals(Integer.valueOf(3), mutNum.getValue());
}
@Test
- public void testSetNull() {
- final MutableInt mutNum = new MutableInt(0);
- assertThrows(NullPointerException.class, () -> mutNum.setValue(null));
+ public void testDecrement() {
+ final MutableInt mutNum = new MutableInt(1);
+ mutNum.decrement();
+
+ assertEquals(0, mutNum.intValue());
+ assertEquals(0L, mutNum.longValue());
+ }
+
+ @Test
+ public void testDecrementAndGet() {
+ final MutableInt mutNum = new MutableInt(1);
+ final int result = mutNum.decrementAndGet();
+
+ assertEquals(0, result);
+ assertEquals(0, mutNum.intValue());
+ assertEquals(0L, mutNum.longValue());
}
@Test
@@ -99,65 +144,31 @@ public class MutableIntTest {
}
@Test
- public void testHashCode() {
- final MutableInt mutNumA = new MutableInt(0);
- final MutableInt mutNumB = new MutableInt(0);
- final MutableInt mutNumC = new MutableInt(1);
-
- assertEquals(mutNumA.hashCode(), mutNumA.hashCode());
- assertEquals(mutNumA.hashCode(), mutNumB.hashCode());
- assertNotEquals(mutNumA.hashCode(), mutNumC.hashCode());
- assertEquals(mutNumA.hashCode(), Integer.valueOf(0).hashCode());
- }
-
- @Test
- public void testCompareTo() {
- final MutableInt mutNum = new MutableInt(0);
-
- assertEquals(0, mutNum.compareTo(new MutableInt(0)));
- assertEquals(+1, mutNum.compareTo(new MutableInt(-1)));
- assertEquals(-1, mutNum.compareTo(new MutableInt(1)));
- }
-
- @Test
- public void testCompareToNull() {
- final MutableInt mutNum = new MutableInt(0);
- assertThrows(NullPointerException.class, () -> mutNum.compareTo(null));
- }
-
- @Test
- public void testPrimitiveValues() {
- final MutableInt mutNum = new MutableInt(1);
- assertEquals( (byte) 1, mutNum.byteValue() );
- assertEquals( (short) 1, mutNum.shortValue() );
- assertEquals(1.0F, mutNum.floatValue());
- assertEquals(1.0, mutNum.doubleValue());
- assertEquals( 1L, mutNum.longValue() );
- }
+ public void testGetAndAddValueObject() {
+ final MutableInt mutableInteger = new MutableInt(0);
+ final int result = mutableInteger.getAndAdd(Integer.valueOf(1));
- @Test
- public void testToInteger() {
- assertEquals(Integer.valueOf(0), new MutableInt(0).toInteger());
- assertEquals(Integer.valueOf(123), new MutableInt(123).toInteger());
+ assertEquals(0, result);
+ assertEquals(1, mutableInteger.intValue());
}
@Test
- public void testIncrement() {
- final MutableInt mutNum = new MutableInt(1);
- mutNum.increment();
+ public void testGetAndAddValuePrimitive() {
+ final MutableInt mutableInteger = new MutableInt(0);
+ final int result = mutableInteger.getAndAdd(1);
- assertEquals(2, mutNum.intValue());
- assertEquals(2L, mutNum.longValue());
+ assertEquals(0, result);
+ assertEquals(1, mutableInteger.intValue());
}
@Test
- public void testIncrementAndGet() {
+ public void testGetAndDecrement() {
final MutableInt mutNum = new MutableInt(1);
- final int result = mutNum.incrementAndGet();
+ final int result = mutNum.getAndDecrement();
- assertEquals(2, result);
- assertEquals(2, mutNum.intValue());
- assertEquals(2L, mutNum.longValue());
+ assertEquals(1, result);
+ assertEquals(0, mutNum.intValue());
+ assertEquals(0L, mutNum.longValue());
}
@Test
@@ -171,86 +182,78 @@ public class MutableIntTest {
}
@Test
- public void testDecrement() {
- final MutableInt mutNum = new MutableInt(1);
- mutNum.decrement();
+ public void testGetSet() {
+ final MutableInt mutNum = new MutableInt(0);
+ assertEquals(0, new MutableInt().intValue());
+ assertEquals(Integer.valueOf(0), new MutableInt().getValue());
- assertEquals(0, mutNum.intValue());
- assertEquals(0L, mutNum.longValue());
- }
+ mutNum.setValue(1);
+ assertEquals(1, mutNum.intValue());
+ assertEquals(Integer.valueOf(1), mutNum.getValue());
- @Test
- public void testDecrementAndGet() {
- final MutableInt mutNum = new MutableInt(1);
- final int result = mutNum.decrementAndGet();
+ mutNum.setValue(Integer.valueOf(2));
+ assertEquals(2, mutNum.intValue());
+ assertEquals(Integer.valueOf(2), mutNum.getValue());
- assertEquals(0, result);
- assertEquals(0, mutNum.intValue());
- assertEquals(0L, mutNum.longValue());
+ mutNum.setValue(new MutableLong(3));
+ assertEquals(3, mutNum.intValue());
+ assertEquals(Integer.valueOf(3), mutNum.getValue());
}
@Test
- public void testGetAndDecrement() {
- final MutableInt mutNum = new MutableInt(1);
- final int result = mutNum.getAndDecrement();
+ public void testHashCode() {
+ final MutableInt mutNumA = new MutableInt(0);
+ final MutableInt mutNumB = new MutableInt(0);
+ final MutableInt mutNumC = new MutableInt(1);
- assertEquals(1, result);
- assertEquals(0, mutNum.intValue());
- assertEquals(0L, mutNum.longValue());
+ assertEquals(mutNumA.hashCode(), mutNumA.hashCode());
+ assertEquals(mutNumA.hashCode(), mutNumB.hashCode());
+ assertNotEquals(mutNumA.hashCode(), mutNumC.hashCode());
+ assertEquals(mutNumA.hashCode(), Integer.valueOf(0).hashCode());
}
@Test
- public void testAddValuePrimitive() {
+ public void testIncrement() {
final MutableInt mutNum = new MutableInt(1);
- mutNum.add(1);
+ mutNum.increment();
assertEquals(2, mutNum.intValue());
assertEquals(2L, mutNum.longValue());
}
@Test
- public void testAddValueObject() {
+ public void testIncrementAndGet() {
final MutableInt mutNum = new MutableInt(1);
- mutNum.add(Integer.valueOf(1));
+ final int result = mutNum.incrementAndGet();
+ assertEquals(2, result);
assertEquals(2, mutNum.intValue());
assertEquals(2L, mutNum.longValue());
}
@Test
- public void testGetAndAddValuePrimitive() {
- final MutableInt mutableInteger = new MutableInt(0);
- final int result = mutableInteger.getAndAdd(1);
-
- assertEquals(0, result);
- assertEquals(1, mutableInteger.intValue());
- }
-
- @Test
- public void testGetAndAddValueObject() {
- final MutableInt mutableInteger = new MutableInt(0);
- final int result = mutableInteger.getAndAdd(Integer.valueOf(1));
-
- assertEquals(0, result);
- assertEquals(1, mutableInteger.intValue());
+ public void testPrimitiveValues() {
+ final MutableInt mutNum = new MutableInt(1);
+ assertEquals( (byte) 1, mutNum.byteValue() );
+ assertEquals( (short) 1, mutNum.shortValue() );
+ assertEquals(1.0F, mutNum.floatValue());
+ assertEquals(1.0, mutNum.doubleValue());
+ assertEquals( 1L, mutNum.longValue() );
}
@Test
- public void testAddAndGetValuePrimitive() {
- final MutableInt mutableInteger = new MutableInt(0);
- final int result = mutableInteger.addAndGet(1);
-
- assertEquals(1, result);
- assertEquals(1, mutableInteger.intValue());
+ public void testSetNull() {
+ final MutableInt mutNum = new MutableInt(0);
+ assertThrows(NullPointerException.class, () -> mutNum.setValue(null));
}
@Test
- public void testAddAndGetValueObject() {
- final MutableInt mutableInteger = new MutableInt(0);
- final int result = mutableInteger.addAndGet(Integer.valueOf(1));
+ public void testSubtractValueObject() {
+ final MutableInt mutNum = new MutableInt(1);
+ mutNum.subtract(Integer.valueOf(1));
- assertEquals(1, result);
- assertEquals(1, mutableInteger.intValue());
+ assertEquals(0, mutNum.intValue());
+ assertEquals(0L, mutNum.longValue());
}
@Test
@@ -263,12 +266,9 @@ public class MutableIntTest {
}
@Test
- public void testSubtractValueObject() {
- final MutableInt mutNum = new MutableInt(1);
- mutNum.subtract(Integer.valueOf(1));
-
- assertEquals(0, mutNum.intValue());
- assertEquals(0L, mutNum.longValue());
+ public void testToInteger() {
+ assertEquals(Integer.valueOf(0), new MutableInt(0).toInteger());
+ assertEquals(Integer.valueOf(123), new MutableInt(123).toInteger());
}
@Test
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 8d1b999..e7dbe57 100644
--- a/src/test/java/org/apache/commons/lang3/mutable/MutableLongTest.java
+++ b/src/test/java/org/apache/commons/lang3/mutable/MutableLongTest.java
@@ -29,78 +29,40 @@ import org.junit.jupiter.api.Test;
*/
public class MutableLongTest {
- // ----------------------------------------------------------------
@Test
- public void testConstructors() {
- assertEquals(0, new MutableLong().longValue());
-
- assertEquals(1, new MutableLong(1).longValue());
-
- assertEquals(2, new MutableLong(Long.valueOf(2)).longValue());
- assertEquals(3, new MutableLong(new MutableLong(3)).longValue());
-
- assertEquals(2, new MutableLong("2").longValue());
-
- }
+ public void testAddAndGetValueObject() {
+ final MutableLong mutableLong = new MutableLong(0L);
+ final long result = mutableLong.addAndGet(Long.valueOf(1L));
- @Test
- public void testConstructorNull() {
- assertThrows(NullPointerException.class, () -> new
MutableLong((Number) null));
+ assertEquals(1L, result);
+ assertEquals(1L, mutableLong.longValue());
}
@Test
- public void testGetSet() {
- final MutableLong mutNum = new MutableLong(0);
- assertEquals(0, new MutableLong().longValue());
- assertEquals(Long.valueOf(0), new MutableLong().getValue());
-
- mutNum.setValue(1);
- assertEquals(1, mutNum.longValue());
- assertEquals(Long.valueOf(1), mutNum.getValue());
-
- mutNum.setValue(Long.valueOf(2));
- assertEquals(2, mutNum.longValue());
- assertEquals(Long.valueOf(2), mutNum.getValue());
-
- mutNum.setValue(new MutableLong(3));
- assertEquals(3, mutNum.longValue());
- assertEquals(Long.valueOf(3), mutNum.getValue());
- }
+ public void testAddAndGetValuePrimitive() {
+ final MutableLong mutableLong = new MutableLong(0L);
+ final long result = mutableLong.addAndGet(1L);
- @Test
- public void testSetNull() {
- final MutableLong mutNum = new MutableLong(0);
- assertThrows(NullPointerException.class, () -> mutNum.setValue(null));
+ assertEquals(1L, result);
+ assertEquals(1L, mutableLong.longValue());
}
@Test
- public void testEquals() {
- final MutableLong mutNumA = new MutableLong(0);
- final MutableLong mutNumB = new MutableLong(0);
- final MutableLong mutNumC = new MutableLong(1);
+ public void testAddValueObject() {
+ final MutableLong mutNum = new MutableLong(1);
+ mutNum.add(Long.valueOf(1));
- 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);
+ assertEquals(2, mutNum.intValue());
+ assertEquals(2L, mutNum.longValue());
}
@Test
- public void testHashCode() {
- final MutableLong mutNumA = new MutableLong(0);
- final MutableLong mutNumB = new MutableLong(0);
- final MutableLong mutNumC = new MutableLong(1);
+ public void testAddValuePrimitive() {
+ final MutableLong mutNum = new MutableLong(1);
+ mutNum.add(1);
- assertEquals(mutNumA.hashCode(), mutNumA.hashCode());
- assertEquals(mutNumA.hashCode(), mutNumB.hashCode());
- assertNotEquals(mutNumA.hashCode(), mutNumC.hashCode());
- assertEquals(mutNumA.hashCode(), Long.valueOf(0).hashCode());
+ assertEquals(2, mutNum.intValue());
+ assertEquals(2L, mutNum.longValue());
}
@Test
@@ -119,49 +81,22 @@ public class MutableLongTest {
}
@Test
- public void testPrimitiveValues() {
- final MutableLong mutNum = new MutableLong(1L);
- assertEquals(1.0F, mutNum.floatValue());
- assertEquals(1.0, mutNum.doubleValue());
- assertEquals( (byte) 1, mutNum.byteValue() );
- assertEquals( (short) 1, mutNum.shortValue() );
- assertEquals( 1, mutNum.intValue() );
- assertEquals( 1L, mutNum.longValue() );
- }
-
- @Test
- public void testToLong() {
- assertEquals(Long.valueOf(0L), new MutableLong(0L).toLong());
- assertEquals(Long.valueOf(123L), new MutableLong(123L).toLong());
+ public void testConstructorNull() {
+ assertThrows(NullPointerException.class, () -> new
MutableLong((Number) null));
}
+ // ----------------------------------------------------------------
@Test
- public void testIncrement() {
- final MutableLong mutNum = new MutableLong(1);
- mutNum.increment();
-
- assertEquals(2, mutNum.intValue());
- assertEquals(2L, mutNum.longValue());
- }
+ public void testConstructors() {
+ assertEquals(0, new MutableLong().longValue());
- @Test
- public void testIncrementAndGet() {
- final MutableLong mutNum = new MutableLong(1L);
- final long result = mutNum.incrementAndGet();
+ assertEquals(1, new MutableLong(1).longValue());
- assertEquals(2, result);
- assertEquals(2, mutNum.intValue());
- assertEquals(2L, mutNum.longValue());
- }
+ assertEquals(2, new MutableLong(Long.valueOf(2)).longValue());
+ assertEquals(3, new MutableLong(new MutableLong(3)).longValue());
- @Test
- public void testGetAndIncrement() {
- final MutableLong mutNum = new MutableLong(1L);
- final long result = mutNum.getAndIncrement();
+ assertEquals(2, new MutableLong("2").longValue());
- assertEquals(1, result);
- assertEquals(2, mutNum.intValue());
- assertEquals(2L, mutNum.longValue());
}
@Test
@@ -184,6 +119,42 @@ public class MutableLongTest {
}
@Test
+ public void testEquals() {
+ final MutableLong mutNumA = new MutableLong(0);
+ final MutableLong mutNumB = new MutableLong(0);
+ final MutableLong mutNumC = new MutableLong(1);
+
+ 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
+ public void testGetAndAddValueObject() {
+ final MutableLong mutableLong = new MutableLong(0L);
+ final long result = mutableLong.getAndAdd(Long.valueOf(1L));
+
+ assertEquals(0L, result);
+ assertEquals(1L, mutableLong.longValue());
+ }
+
+ @Test
+ public void testGetAndAddValuePrimitive() {
+ final MutableLong mutableLong = new MutableLong(0L);
+ final long result = mutableLong.getAndAdd(1L);
+
+ assertEquals(0L, result);
+ assertEquals(1L, mutableLong.longValue());
+ }
+
+ @Test
public void testGetAndDecrement() {
final MutableLong mutNum = new MutableLong(1L);
final long result = mutNum.getAndDecrement();
@@ -194,78 +165,107 @@ public class MutableLongTest {
}
@Test
- public void testAddValuePrimitive() {
- final MutableLong mutNum = new MutableLong(1);
- mutNum.add(1);
+ public void testGetAndIncrement() {
+ final MutableLong mutNum = new MutableLong(1L);
+ final long result = mutNum.getAndIncrement();
+ assertEquals(1, result);
assertEquals(2, mutNum.intValue());
assertEquals(2L, mutNum.longValue());
}
@Test
- public void testAddValueObject() {
- final MutableLong mutNum = new MutableLong(1);
- mutNum.add(Long.valueOf(1));
+ public void testGetSet() {
+ final MutableLong mutNum = new MutableLong(0);
+ assertEquals(0, new MutableLong().longValue());
+ assertEquals(Long.valueOf(0), new MutableLong().getValue());
- assertEquals(2, mutNum.intValue());
- assertEquals(2L, mutNum.longValue());
+ mutNum.setValue(1);
+ assertEquals(1, mutNum.longValue());
+ assertEquals(Long.valueOf(1), mutNum.getValue());
+
+ mutNum.setValue(Long.valueOf(2));
+ assertEquals(2, mutNum.longValue());
+ assertEquals(Long.valueOf(2), mutNum.getValue());
+
+ mutNum.setValue(new MutableLong(3));
+ assertEquals(3, mutNum.longValue());
+ assertEquals(Long.valueOf(3), mutNum.getValue());
}
@Test
- public void testGetAndAddValuePrimitive() {
- final MutableLong mutableLong = new MutableLong(0L);
- final long result = mutableLong.getAndAdd(1L);
+ public void testHashCode() {
+ final MutableLong mutNumA = new MutableLong(0);
+ final MutableLong mutNumB = new MutableLong(0);
+ final MutableLong mutNumC = new MutableLong(1);
- assertEquals(0L, result);
- assertEquals(1L, mutableLong.longValue());
+ assertEquals(mutNumA.hashCode(), mutNumA.hashCode());
+ assertEquals(mutNumA.hashCode(), mutNumB.hashCode());
+ assertNotEquals(mutNumA.hashCode(), mutNumC.hashCode());
+ assertEquals(mutNumA.hashCode(), Long.valueOf(0).hashCode());
}
@Test
- public void testGetAndAddValueObject() {
- final MutableLong mutableLong = new MutableLong(0L);
- final long result = mutableLong.getAndAdd(Long.valueOf(1L));
+ public void testIncrement() {
+ final MutableLong mutNum = new MutableLong(1);
+ mutNum.increment();
- assertEquals(0L, result);
- assertEquals(1L, mutableLong.longValue());
+ assertEquals(2, mutNum.intValue());
+ assertEquals(2L, mutNum.longValue());
}
@Test
- public void testAddAndGetValuePrimitive() {
- final MutableLong mutableLong = new MutableLong(0L);
- final long result = mutableLong.addAndGet(1L);
+ public void testIncrementAndGet() {
+ final MutableLong mutNum = new MutableLong(1L);
+ final long result = mutNum.incrementAndGet();
- assertEquals(1L, result);
- assertEquals(1L, mutableLong.longValue());
+ assertEquals(2, result);
+ assertEquals(2, mutNum.intValue());
+ assertEquals(2L, mutNum.longValue());
}
@Test
- public void testAddAndGetValueObject() {
- final MutableLong mutableLong = new MutableLong(0L);
- final long result = mutableLong.addAndGet(Long.valueOf(1L));
+ public void testPrimitiveValues() {
+ final MutableLong mutNum = new MutableLong(1L);
+ assertEquals(1.0F, mutNum.floatValue());
+ assertEquals(1.0, mutNum.doubleValue());
+ assertEquals( (byte) 1, mutNum.byteValue() );
+ assertEquals( (short) 1, mutNum.shortValue() );
+ assertEquals( 1, mutNum.intValue() );
+ assertEquals( 1L, mutNum.longValue() );
+ }
- assertEquals(1L, result);
- assertEquals(1L, mutableLong.longValue());
+ @Test
+ public void testSetNull() {
+ final MutableLong mutNum = new MutableLong(0);
+ assertThrows(NullPointerException.class, () -> mutNum.setValue(null));
}
@Test
- public void testSubtractValuePrimitive() {
+ public void testSubtractValueObject() {
final MutableLong mutNum = new MutableLong(1);
- mutNum.subtract(1);
+ mutNum.subtract(Long.valueOf(1));
assertEquals(0, mutNum.intValue());
assertEquals(0L, mutNum.longValue());
}
@Test
- public void testSubtractValueObject() {
+ public void testSubtractValuePrimitive() {
final MutableLong mutNum = new MutableLong(1);
- mutNum.subtract(Long.valueOf(1));
+ mutNum.subtract(1);
assertEquals(0, mutNum.intValue());
assertEquals(0L, mutNum.longValue());
}
@Test
+ public void testToLong() {
+ assertEquals(Long.valueOf(0L), new MutableLong(0L).toLong());
+ assertEquals(Long.valueOf(123L), new MutableLong(123L).toLong());
+ }
+
+ @Test
public void testToString() {
assertEquals("0", new MutableLong(0).toString());
assertEquals("10", new MutableLong(10).toString());
diff --git
a/src/test/java/org/apache/commons/lang3/mutable/MutableObjectTest.java
b/src/test/java/org/apache/commons/lang3/mutable/MutableObjectTest.java
index ac05ce6..96b39f7 100644
--- a/src/test/java/org/apache/commons/lang3/mutable/MutableObjectTest.java
+++ b/src/test/java/org/apache/commons/lang3/mutable/MutableObjectTest.java
@@ -43,18 +43,6 @@ public class MutableObjectTest {
}
@Test
- public void testGetSet() {
- final MutableObject<String> mutNum = new MutableObject<>();
- assertNull(new MutableObject<>().getValue());
-
- mutNum.setValue("HELLO");
- assertSame("HELLO", mutNum.getValue());
-
- mutNum.setValue(null);
- assertSame(null, mutNum.getValue());
- }
-
- @Test
public void testEquals() {
final MutableObject<String> mutNumA = new MutableObject<>("ALPHA");
final MutableObject<String> mutNumB = new MutableObject<>("ALPHA");
@@ -77,6 +65,18 @@ public class MutableObjectTest {
}
@Test
+ public void testGetSet() {
+ final MutableObject<String> mutNum = new MutableObject<>();
+ assertNull(new MutableObject<>().getValue());
+
+ mutNum.setValue("HELLO");
+ assertSame("HELLO", mutNum.getValue());
+
+ mutNum.setValue(null);
+ assertSame(null, mutNum.getValue());
+ }
+
+ @Test
public void testHashCode() {
final MutableObject<String> mutNumA = new MutableObject<>("ALPHA");
final MutableObject<String> mutNumB = new MutableObject<>("ALPHA");
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 c5b32cf..c775931 100644
--- a/src/test/java/org/apache/commons/lang3/mutable/MutableShortTest.java
+++ b/src/test/java/org/apache/commons/lang3/mutable/MutableShortTest.java
@@ -29,6 +29,50 @@ import org.junit.jupiter.api.Test;
*/
public class MutableShortTest {
+ @Test
+ public void testAddAndGetValueObject() {
+ final MutableShort mutableShort = new MutableShort((short) 0);
+ final short result = mutableShort.addAndGet(Short.valueOf((short) 1));
+
+ assertEquals((short) 1, result);
+ assertEquals((short) 1, mutableShort.shortValue());
+ }
+
+ @Test
+ public void testAddAndGetValuePrimitive() {
+ final MutableShort mutableShort = new MutableShort((short) 0);
+ final short result = mutableShort.addAndGet((short) 1);
+
+ assertEquals((short) 1, result);
+ assertEquals((short) 1, mutableShort.shortValue());
+ }
+
+ @Test
+ public void testAddValueObject() {
+ final MutableShort mutNum = new MutableShort((short) 1);
+ mutNum.add(Short.valueOf((short) 1));
+
+ assertEquals((short) 2, mutNum.shortValue());
+ }
+
+ @Test
+ public void testAddValuePrimitive() {
+ final MutableShort mutNum = new MutableShort((short) 1);
+ mutNum.add((short) 1);
+
+ assertEquals((short) 2, mutNum.shortValue());
+ }
+
+ @Test
+ public void testCompareTo() {
+ final MutableShort mutNum = new MutableShort((short) 0);
+
+ assertEquals((short) 0, mutNum.compareTo(new MutableShort((short) 0)));
+ assertEquals((short) +1, mutNum.compareTo(new MutableShort((short)
-1)));
+ assertEquals((short) -1, mutNum.compareTo(new MutableShort((short)
1)));
+ assertThrows(NullPointerException.class, () -> mutNum.compareTo(null));
+ }
+
// ----------------------------------------------------------------
@Test
public void testConstructors() {
@@ -45,23 +89,22 @@ public class MutableShortTest {
}
@Test
- public void testGetSet() {
- final MutableShort mutNum = new MutableShort((short) 0);
- assertEquals((short) 0, new MutableShort().shortValue());
- assertEquals(Short.valueOf((short) 0), new MutableShort().getValue());
+ public void testDecrement() {
+ final MutableShort mutNum = new MutableShort((short) 1);
+ mutNum.decrement();
- mutNum.setValue((short) 1);
- assertEquals((short) 1, mutNum.shortValue());
- assertEquals(Short.valueOf((short) 1), mutNum.getValue());
+ assertEquals(0, mutNum.intValue());
+ assertEquals(0L, mutNum.longValue());
+ }
- mutNum.setValue(Short.valueOf((short) 2));
- assertEquals((short) 2, mutNum.shortValue());
- assertEquals(Short.valueOf((short) 2), mutNum.getValue());
+ @Test
+ public void testDecrementAndGet() {
+ final MutableShort mutNum = new MutableShort((short) 1);
+ final short result = mutNum.decrementAndGet();
- mutNum.setValue(new MutableShort((short) 3));
- assertEquals((short) 3, mutNum.shortValue());
- assertEquals(Short.valueOf((short) 3), mutNum.getValue());
- assertThrows(NullPointerException.class, () -> mutNum.setValue(null));
+ assertEquals(0, result);
+ assertEquals(0, mutNum.intValue());
+ assertEquals(0L, mutNum.longValue());
}
@Test
@@ -83,61 +126,31 @@ public class MutableShortTest {
}
@Test
- public void testHashCode() {
- final MutableShort mutNumA = new MutableShort((short) 0);
- final MutableShort mutNumB = new MutableShort((short) 0);
- final MutableShort mutNumC = new MutableShort((short) 1);
-
- assertEquals(mutNumA.hashCode(), mutNumA.hashCode());
- assertEquals(mutNumA.hashCode(), mutNumB.hashCode());
- assertNotEquals(mutNumA.hashCode(), mutNumC.hashCode());
- assertEquals(mutNumA.hashCode(), Short.valueOf((short) 0).hashCode());
- }
-
- @Test
- public void testCompareTo() {
- final MutableShort mutNum = new MutableShort((short) 0);
-
- assertEquals((short) 0, mutNum.compareTo(new MutableShort((short) 0)));
- assertEquals((short) +1, mutNum.compareTo(new MutableShort((short)
-1)));
- assertEquals((short) -1, mutNum.compareTo(new MutableShort((short)
1)));
- assertThrows(NullPointerException.class, () -> mutNum.compareTo(null));
- }
-
- @Test
- public void testPrimitiveValues() {
- final MutableShort mutNum = new MutableShort( (short) 1 );
- assertEquals(1.0F, mutNum.floatValue());
- assertEquals(1.0, mutNum.doubleValue());
- assertEquals( (byte) 1, mutNum.byteValue() );
- assertEquals( (short) 1, mutNum.shortValue() );
- assertEquals( 1, mutNum.intValue() );
- assertEquals( 1L, mutNum.longValue() );
- }
+ public void testGetAndAddValueObject() {
+ final MutableShort mutableShort = new MutableShort((short) 0);
+ final short result = mutableShort.getAndAdd(Short.valueOf((short) 1));
- @Test
- public void testToShort() {
- assertEquals(Short.valueOf((short) 0), new MutableShort((short)
0).toShort());
- assertEquals(Short.valueOf((short) 123), new MutableShort((short)
123).toShort());
+ assertEquals((short) 0, result);
+ assertEquals((short) 1, mutableShort.shortValue());
}
@Test
- public void testIncrement() {
- final MutableShort mutNum = new MutableShort((short) 1);
- mutNum.increment();
+ public void testGetAndAddValuePrimitive() {
+ final MutableShort mutableShort = new MutableShort((short) 0);
+ final short result = mutableShort.getAndAdd((short) 1);
- assertEquals(2, mutNum.intValue());
- assertEquals(2L, mutNum.longValue());
+ assertEquals((short) 0, result);
+ assertEquals((short) 1, mutableShort.shortValue());
}
@Test
- public void testIncrementAndGet() {
+ public void testGetAndDecrement() {
final MutableShort mutNum = new MutableShort((short) 1);
- final short result = mutNum.incrementAndGet();
+ final short result = mutNum.getAndDecrement();
- assertEquals(2, result);
- assertEquals(2, mutNum.intValue());
- assertEquals(2L, mutNum.longValue());
+ assertEquals(1, result);
+ assertEquals(0, mutNum.intValue());
+ assertEquals(0L, mutNum.longValue());
}
@Test
@@ -151,84 +164,73 @@ public class MutableShortTest {
}
@Test
- public void testDecrement() {
- final MutableShort mutNum = new MutableShort((short) 1);
- mutNum.decrement();
+ public void testGetSet() {
+ final MutableShort mutNum = new MutableShort((short) 0);
+ assertEquals((short) 0, new MutableShort().shortValue());
+ assertEquals(Short.valueOf((short) 0), new MutableShort().getValue());
- assertEquals(0, mutNum.intValue());
- assertEquals(0L, mutNum.longValue());
- }
+ mutNum.setValue((short) 1);
+ assertEquals((short) 1, mutNum.shortValue());
+ assertEquals(Short.valueOf((short) 1), mutNum.getValue());
- @Test
- public void testDecrementAndGet() {
- final MutableShort mutNum = new MutableShort((short) 1);
- final short result = mutNum.decrementAndGet();
+ mutNum.setValue(Short.valueOf((short) 2));
+ assertEquals((short) 2, mutNum.shortValue());
+ assertEquals(Short.valueOf((short) 2), mutNum.getValue());
- assertEquals(0, result);
- assertEquals(0, mutNum.intValue());
- assertEquals(0L, mutNum.longValue());
+ mutNum.setValue(new MutableShort((short) 3));
+ assertEquals((short) 3, mutNum.shortValue());
+ assertEquals(Short.valueOf((short) 3), mutNum.getValue());
+ assertThrows(NullPointerException.class, () -> mutNum.setValue(null));
}
@Test
- public void testGetAndDecrement() {
- final MutableShort mutNum = new MutableShort((short) 1);
- final short result = mutNum.getAndDecrement();
+ public void testHashCode() {
+ final MutableShort mutNumA = new MutableShort((short) 0);
+ final MutableShort mutNumB = new MutableShort((short) 0);
+ final MutableShort mutNumC = new MutableShort((short) 1);
- assertEquals(1, result);
- assertEquals(0, mutNum.intValue());
- assertEquals(0L, mutNum.longValue());
+ assertEquals(mutNumA.hashCode(), mutNumA.hashCode());
+ assertEquals(mutNumA.hashCode(), mutNumB.hashCode());
+ assertNotEquals(mutNumA.hashCode(), mutNumC.hashCode());
+ assertEquals(mutNumA.hashCode(), Short.valueOf((short) 0).hashCode());
}
@Test
- public void testAddValuePrimitive() {
+ public void testIncrement() {
final MutableShort mutNum = new MutableShort((short) 1);
- mutNum.add((short) 1);
+ mutNum.increment();
- assertEquals((short) 2, mutNum.shortValue());
+ assertEquals(2, mutNum.intValue());
+ assertEquals(2L, mutNum.longValue());
}
@Test
- public void testAddValueObject() {
+ public void testIncrementAndGet() {
final MutableShort mutNum = new MutableShort((short) 1);
- mutNum.add(Short.valueOf((short) 1));
-
- assertEquals((short) 2, mutNum.shortValue());
- }
-
- @Test
- public void testGetAndAddValuePrimitive() {
- final MutableShort mutableShort = new MutableShort((short) 0);
- final short result = mutableShort.getAndAdd((short) 1);
-
- assertEquals((short) 0, result);
- assertEquals((short) 1, mutableShort.shortValue());
- }
-
- @Test
- public void testGetAndAddValueObject() {
- final MutableShort mutableShort = new MutableShort((short) 0);
- final short result = mutableShort.getAndAdd(Short.valueOf((short) 1));
+ final short result = mutNum.incrementAndGet();
- assertEquals((short) 0, result);
- assertEquals((short) 1, mutableShort.shortValue());
+ assertEquals(2, result);
+ assertEquals(2, mutNum.intValue());
+ assertEquals(2L, mutNum.longValue());
}
@Test
- public void testAddAndGetValuePrimitive() {
- final MutableShort mutableShort = new MutableShort((short) 0);
- final short result = mutableShort.addAndGet((short) 1);
-
- assertEquals((short) 1, result);
- assertEquals((short) 1, mutableShort.shortValue());
+ public void testPrimitiveValues() {
+ final MutableShort mutNum = new MutableShort( (short) 1 );
+ assertEquals(1.0F, mutNum.floatValue());
+ assertEquals(1.0, mutNum.doubleValue());
+ assertEquals( (byte) 1, mutNum.byteValue() );
+ assertEquals( (short) 1, mutNum.shortValue() );
+ assertEquals( 1, mutNum.intValue() );
+ assertEquals( 1L, mutNum.longValue() );
}
@Test
- public void testAddAndGetValueObject() {
- final MutableShort mutableShort = new MutableShort((short) 0);
- final short result = mutableShort.addAndGet(Short.valueOf((short) 1));
+ public void testSubtractValueObject() {
+ final MutableShort mutNum = new MutableShort((short) 1);
+ mutNum.subtract(Short.valueOf((short) 1));
- assertEquals((short) 1, result);
- assertEquals((short) 1, mutableShort.shortValue());
+ assertEquals((short) 0, mutNum.shortValue());
}
@Test
@@ -240,11 +242,9 @@ public class MutableShortTest {
}
@Test
- public void testSubtractValueObject() {
- final MutableShort mutNum = new MutableShort((short) 1);
- mutNum.subtract(Short.valueOf((short) 1));
-
- assertEquals((short) 0, mutNum.shortValue());
+ public void testToShort() {
+ assertEquals(Short.valueOf((short) 0), new MutableShort((short)
0).toShort());
+ assertEquals(Short.valueOf((short) 123), new MutableShort((short)
123).toShort());
}
@Test
diff --git
a/src/test/java/org/apache/commons/lang3/tuple/ImmutablePairTest.java
b/src/test/java/org/apache/commons/lang3/tuple/ImmutablePairTest.java
index 4dc1f42..c1b9f35 100644
--- a/src/test/java/org/apache/commons/lang3/tuple/ImmutablePairTest.java
+++ b/src/test/java/org/apache/commons/lang3/tuple/ImmutablePairTest.java
@@ -38,19 +38,6 @@ import org.junit.jupiter.api.Test;
public class ImmutablePairTest {
@Test
- public void testEmptyArrayLength() {
- @SuppressWarnings("unchecked")
- final ImmutablePair<Integer, String>[] empty = (ImmutablePair<Integer,
String>[]) ImmutablePair.EMPTY_ARRAY;
- assertEquals(0, empty.length);
- }
-
- @Test
- public void testEmptyArrayGenerics() {
- final ImmutablePair<Integer, String>[] empty =
ImmutablePair.emptyArray();
- assertEquals(0, empty.length);
- }
-
- @Test
public void testBasic() {
ImmutablePair<Integer, String> oldPair = new ImmutablePair<>(0, "foo");
ImmutablePair<Integer, String> nowPair;
@@ -77,6 +64,43 @@ public class ImmutablePairTest {
}
@Test
+ public void testComparableLeftOnly() {
+ final Pair<String, String> pair1 = ImmutablePair.left("A");
+ final Pair<String, String> pair2 = ImmutablePair.left("B");
+ assertEquals("A", pair1.getLeft());
+ assertEquals("B", pair2.getLeft());
+ assertEquals(0, pair1.compareTo(pair1));
+ assertTrue(pair1.compareTo(pair2) < 0);
+ assertEquals(0, pair2.compareTo(pair2));
+ assertTrue(pair2.compareTo(pair1) > 0);
+ }
+
+ @Test
+ public void testComparableRightOnly() {
+ final Pair<String, String> pair1 = ImmutablePair.right("A");
+ final Pair<String, String> pair2 = ImmutablePair.right("B");
+ assertEquals("A", pair1.getRight());
+ assertEquals("B", pair2.getRight());
+ assertEquals(0, pair1.compareTo(pair1));
+ assertTrue(pair1.compareTo(pair2) < 0);
+ assertEquals(0, pair2.compareTo(pair2));
+ assertTrue(pair2.compareTo(pair1) > 0);
+ }
+
+ @Test
+ public void testEmptyArrayGenerics() {
+ final ImmutablePair<Integer, String>[] empty =
ImmutablePair.emptyArray();
+ assertEquals(0, empty.length);
+ }
+
+ @Test
+ public void testEmptyArrayLength() {
+ @SuppressWarnings("unchecked")
+ final ImmutablePair<Integer, String>[] empty = (ImmutablePair<Integer,
String>[]) ImmutablePair.EMPTY_ARRAY;
+ assertEquals(0, empty.length);
+ }
+
+ @Test
public void testEquals() {
assertEquals(ImmutablePair.of(null, "foo"), ImmutablePair.of(null,
"foo"));
assertNotEquals(ImmutablePair.of("foo", 0), ImmutablePair.of("foo",
null));
@@ -175,6 +199,18 @@ public class ImmutablePairTest {
}
@Test
+ public void testToStringLeft() {
+ final Pair<String, String> pair = ImmutablePair.left("Key");
+ assertEquals("(Key,null)", pair.toString());
+ }
+
+ @Test
+ public void testToStringRight() {
+ final Pair<String, String> pair = ImmutablePair.right("Value");
+ assertEquals("(null,Value)", pair.toString());
+ }
+
+ @Test
public void testUseAsKeyOfHashMap() {
final HashMap<ImmutablePair<Object, Object>, String> map = new
HashMap<>();
final Object o1 = new Object();
@@ -203,40 +239,4 @@ public class ImmutablePairTest {
assertEquals(item.getLeft() + "" + item.getRight(),
entry.getValue());
}
}
-
- @Test
- public void testComparableLeftOnly() {
- final Pair<String, String> pair1 = ImmutablePair.left("A");
- final Pair<String, String> pair2 = ImmutablePair.left("B");
- assertEquals("A", pair1.getLeft());
- assertEquals("B", pair2.getLeft());
- assertEquals(0, pair1.compareTo(pair1));
- assertTrue(pair1.compareTo(pair2) < 0);
- assertEquals(0, pair2.compareTo(pair2));
- assertTrue(pair2.compareTo(pair1) > 0);
- }
-
- @Test
- public void testComparableRightOnly() {
- final Pair<String, String> pair1 = ImmutablePair.right("A");
- final Pair<String, String> pair2 = ImmutablePair.right("B");
- assertEquals("A", pair1.getRight());
- assertEquals("B", pair2.getRight());
- assertEquals(0, pair1.compareTo(pair1));
- assertTrue(pair1.compareTo(pair2) < 0);
- assertEquals(0, pair2.compareTo(pair2));
- assertTrue(pair2.compareTo(pair1) > 0);
- }
-
- @Test
- public void testToStringLeft() {
- final Pair<String, String> pair = ImmutablePair.left("Key");
- assertEquals("(Key,null)", pair.toString());
- }
-
- @Test
- public void testToStringRight() {
- final Pair<String, String> pair = ImmutablePair.right("Value");
- assertEquals("(null,Value)", pair.toString());
- }
}
diff --git
a/src/test/java/org/apache/commons/lang3/tuple/ImmutableTripleTest.java
b/src/test/java/org/apache/commons/lang3/tuple/ImmutableTripleTest.java
index 0af0535..cd18bce 100644
--- a/src/test/java/org/apache/commons/lang3/tuple/ImmutableTripleTest.java
+++ b/src/test/java/org/apache/commons/lang3/tuple/ImmutableTripleTest.java
@@ -37,19 +37,6 @@ import org.junit.jupiter.api.Test;
public class ImmutableTripleTest {
@Test
- public void testEmptyArrayLength() {
- @SuppressWarnings("unchecked")
- final ImmutableTriple<Integer, String, Boolean>[] empty =
(ImmutableTriple<Integer, String, Boolean>[]) ImmutableTriple.EMPTY_ARRAY;
- assertEquals(0, empty.length);
- }
-
- @Test
- public void testEmptyArrayGenerics() {
- final ImmutableTriple<Integer, String, Boolean>[] empty =
ImmutableTriple.emptyArray();
- assertEquals(0, empty.length);
- }
-
- @Test
public void testBasic() {
final ImmutableTriple<Integer, String, Boolean> triple = new
ImmutableTriple<>(0, "foo", Boolean.TRUE);
assertEquals(0, triple.left.intValue());
@@ -68,6 +55,19 @@ public class ImmutableTripleTest {
}
@Test
+ public void testEmptyArrayGenerics() {
+ final ImmutableTriple<Integer, String, Boolean>[] empty =
ImmutableTriple.emptyArray();
+ assertEquals(0, empty.length);
+ }
+
+ @Test
+ public void testEmptyArrayLength() {
+ @SuppressWarnings("unchecked")
+ final ImmutableTriple<Integer, String, Boolean>[] empty =
(ImmutableTriple<Integer, String, Boolean>[]) ImmutableTriple.EMPTY_ARRAY;
+ assertEquals(0, empty.length);
+ }
+
+ @Test
public void testEquals() {
assertEquals(ImmutableTriple.of(null, "foo", 42),
ImmutableTriple.of(null, "foo", 42));
assertNotEquals(ImmutableTriple.of("foo", 0, Boolean.TRUE),
ImmutableTriple.of("foo", null, null));
diff --git a/src/test/java/org/apache/commons/lang3/tuple/MutablePairTest.java
b/src/test/java/org/apache/commons/lang3/tuple/MutablePairTest.java
index 1f6c04e..045b02c 100644
--- a/src/test/java/org/apache/commons/lang3/tuple/MutablePairTest.java
+++ b/src/test/java/org/apache/commons/lang3/tuple/MutablePairTest.java
@@ -32,19 +32,6 @@ import org.junit.jupiter.api.Test;
public class MutablePairTest {
@Test
- public void testEmptyArrayLength() {
- @SuppressWarnings("unchecked")
- final MutablePair<Integer, String>[] empty = (MutablePair<Integer,
String>[]) MutablePair.EMPTY_ARRAY;
- assertEquals(0, empty.length);
- }
-
- @Test
- public void testEmptyArrayGenerics() {
- final MutablePair<Integer, String>[] empty = MutablePair.emptyArray();
- assertEquals(0, empty.length);
- }
-
- @Test
public void testBasic() {
MutablePair<Integer, String> oldPair = new MutablePair<>(0, "foo");
MutablePair<Integer, String> nowPair;
@@ -78,6 +65,19 @@ public class MutablePairTest {
}
@Test
+ public void testEmptyArrayGenerics() {
+ final MutablePair<Integer, String>[] empty = MutablePair.emptyArray();
+ assertEquals(0, empty.length);
+ }
+
+ @Test
+ public void testEmptyArrayLength() {
+ @SuppressWarnings("unchecked")
+ final MutablePair<Integer, String>[] empty = (MutablePair<Integer,
String>[]) MutablePair.EMPTY_ARRAY;
+ assertEquals(0, empty.length);
+ }
+
+ @Test
public void testEquals() {
assertEquals(MutablePair.of(null, "foo"), MutablePair.of(null, "foo"));
assertNotEquals(MutablePair.of("foo", 0), MutablePair.of("foo", null));
diff --git
a/src/test/java/org/apache/commons/lang3/tuple/MutableTripleTest.java
b/src/test/java/org/apache/commons/lang3/tuple/MutableTripleTest.java
index 830e062..d4de141 100644
--- a/src/test/java/org/apache/commons/lang3/tuple/MutableTripleTest.java
+++ b/src/test/java/org/apache/commons/lang3/tuple/MutableTripleTest.java
@@ -29,19 +29,6 @@ import org.junit.jupiter.api.Test;
public class MutableTripleTest {
@Test
- public void testEmptyArrayLength() {
- @SuppressWarnings("unchecked")
- final MutableTriple<Integer, String, Boolean>[] empty =
(MutableTriple<Integer, String, Boolean>[]) MutableTriple.EMPTY_ARRAY;
- assertEquals(0, empty.length);
- }
-
- @Test
- public void testEmptyArrayGenerics() {
- final MutableTriple<Integer, String, Boolean>[] empty =
MutableTriple.emptyArray();
- assertEquals(0, empty.length);
- }
-
- @Test
public void testBasic() {
final MutableTriple<Integer, String, Boolean> triple = new
MutableTriple<>(0, "foo", Boolean.FALSE);
assertEquals(0, triple.getLeft().intValue());
@@ -62,6 +49,19 @@ public class MutableTripleTest {
}
@Test
+ public void testEmptyArrayGenerics() {
+ final MutableTriple<Integer, String, Boolean>[] empty =
MutableTriple.emptyArray();
+ assertEquals(0, empty.length);
+ }
+
+ @Test
+ public void testEmptyArrayLength() {
+ @SuppressWarnings("unchecked")
+ final MutableTriple<Integer, String, Boolean>[] empty =
(MutableTriple<Integer, String, Boolean>[]) MutableTriple.EMPTY_ARRAY;
+ assertEquals(0, empty.length);
+ }
+
+ @Test
public void testEquals() {
assertEquals(MutableTriple.of(null, "foo", "baz"),
MutableTriple.of(null, "foo", "baz"));
assertNotEquals(MutableTriple.of("foo", 0, Boolean.TRUE),
MutableTriple.of("foo", null, Boolean.TRUE));
diff --git a/src/test/java/org/apache/commons/lang3/tuple/PairTest.java
b/src/test/java/org/apache/commons/lang3/tuple/PairTest.java
index 2ad4f50..80bae12 100644
--- a/src/test/java/org/apache/commons/lang3/tuple/PairTest.java
+++ b/src/test/java/org/apache/commons/lang3/tuple/PairTest.java
@@ -34,19 +34,6 @@ import org.junit.jupiter.api.Test;
public class PairTest {
@Test
- public void testEmptyArrayLength() {
- @SuppressWarnings("unchecked")
- final Pair<Integer, String>[] empty = (Pair<Integer, String>[])
Pair.EMPTY_ARRAY;
- assertEquals(0, empty.length);
- }
-
- @Test
- public void testEmptyArrayGenerics() {
- final Pair<Integer, String>[] empty = Pair.emptyArray();
- assertEquals(0, empty.length);
- }
-
- @Test
public void testComparable1() {
final Pair<String, String> pair1 = Pair.of("A", "D");
final Pair<String, String> pair2 = Pair.of("B", "C");
@@ -82,6 +69,19 @@ public class PairTest {
}
@Test
+ public void testEmptyArrayGenerics() {
+ final Pair<Integer, String>[] empty = Pair.emptyArray();
+ assertEquals(0, empty.length);
+ }
+
+ @Test
+ public void testEmptyArrayLength() {
+ @SuppressWarnings("unchecked")
+ final Pair<Integer, String>[] empty = (Pair<Integer, String>[])
Pair.EMPTY_ARRAY;
+ assertEquals(0, empty.length);
+ }
+
+ @Test
public void testFormattable_padded() {
final Pair<String, String> pair = Pair.of("Key", "Value");
assertEquals(" (Key,Value)", String.format("%1$20s", pair));
diff --git a/src/test/java/org/apache/commons/lang3/tuple/TripleTest.java
b/src/test/java/org/apache/commons/lang3/tuple/TripleTest.java
index d2baeaa..dbf06f3 100644
--- a/src/test/java/org/apache/commons/lang3/tuple/TripleTest.java
+++ b/src/test/java/org/apache/commons/lang3/tuple/TripleTest.java
@@ -31,19 +31,6 @@ import org.junit.jupiter.api.Test;
public class TripleTest {
@Test
- public void testEmptyArrayLength() {
- @SuppressWarnings("unchecked")
- final Triple<Integer, String, Boolean>[] empty = (Triple<Integer,
String, Boolean>[]) Triple.EMPTY_ARRAY;
- assertEquals(0, empty.length);
- }
-
- @Test
- public void testEmptyArrayGenerics() {
- final Triple<Integer, String, Boolean>[] empty = Triple.emptyArray();
- assertEquals(0, empty.length);
- }
-
- @Test
public void testComparable1() {
final Triple<String, String, String> triple1 = Triple.of("A", "D",
"A");
final Triple<String, String, String> triple2 = Triple.of("B", "C",
"A");
@@ -95,6 +82,19 @@ public class TripleTest {
}
@Test
+ public void testEmptyArrayGenerics() {
+ final Triple<Integer, String, Boolean>[] empty = Triple.emptyArray();
+ assertEquals(0, empty.length);
+ }
+
+ @Test
+ public void testEmptyArrayLength() {
+ @SuppressWarnings("unchecked")
+ final Triple<Integer, String, Boolean>[] empty = (Triple<Integer,
String, Boolean>[]) Triple.EMPTY_ARRAY;
+ assertEquals(0, empty.length);
+ }
+
+ @Test
public void testFormattable_padded() {
final Triple<String, String, String> triple = Triple.of("Key",
"Something", "Value");
assertEquals(" (Key,Something,Value)", String.format("%1$30s",
triple));
