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

commit f2b7f988407a55de784f4cb259dc066d3538c5a0
Author: Gary Gregory <[email protected]>
AuthorDate: Thu May 9 14:34:53 2019 -0400

    Sort methods.
---
 .../commons/lang3/tuple/ImmutablePairTest.java     | 56 ++++++++--------
 .../commons/lang3/tuple/ImmutableTripleTest.java   | 66 +++++++++----------
 .../commons/lang3/tuple/MutablePairTest.java       | 48 +++++++-------
 .../commons/lang3/tuple/MutableTripleTest.java     | 62 +++++++++---------
 .../org/apache/commons/lang3/tuple/PairTest.java   | 76 +++++++++++-----------
 .../org/apache/commons/lang3/tuple/TripleTest.java | 68 +++++++++----------
 6 files changed, 188 insertions(+), 188 deletions(-)

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 d9635a2..2aca73c 100644
--- a/src/test/java/org/apache/commons/lang3/tuple/ImmutablePairTest.java
+++ b/src/test/java/org/apache/commons/lang3/tuple/ImmutablePairTest.java
@@ -54,20 +54,6 @@ public class ImmutablePairTest {
     }
 
     @Test
-    public void testPairOf() {
-        final ImmutablePair<Integer, String> pair = ImmutablePair.of(0, "foo");
-        assertEquals(0, pair.left.intValue());
-        assertEquals(0, pair.getLeft().intValue());
-        assertEquals("foo", pair.right);
-        assertEquals("foo", pair.getRight());
-        final ImmutablePair<Object, String> pair2 = ImmutablePair.of(null, 
"bar");
-        assertNull(pair2.left);
-        assertNull(pair2.getLeft());
-        assertEquals("bar", pair2.right);
-        assertEquals("bar", pair2.getRight());
-    }
-
-    @Test
     public void testEquals() {
         assertEquals(ImmutablePair.of(null, "foo"), ImmutablePair.of(null, 
"foo"));
         assertNotEquals(ImmutablePair.of("foo", 0), ImmutablePair.of("foo", 
null));
@@ -89,8 +75,8 @@ public class ImmutablePairTest {
     }
 
     @Test
-    public void testNullPairSame() {
-        assertSame(ImmutablePair.nullPair(), ImmutablePair.nullPair());
+    public void testNullPairKey() {
+        assertNull(ImmutablePair.nullPair().getKey());
     }
 
     @Test
@@ -99,18 +85,13 @@ public class ImmutablePairTest {
     }
 
     @Test
-    public void testNullPairKey() {
-        assertNull(ImmutablePair.nullPair().getKey());
-    }
-
-    @Test
     public void testNullPairRight() {
         assertNull(ImmutablePair.nullPair().getRight());
     }
 
     @Test
-    public void testNullPairValue() {
-        assertNull(ImmutablePair.nullPair().getValue());
+    public void testNullPairSame() {
+        assertSame(ImmutablePair.nullPair(), ImmutablePair.nullPair());
     }
 
     @Test
@@ -122,11 +103,22 @@ public class ImmutablePairTest {
     }
 
     @Test
-    public void testToString() {
-        assertEquals("(null,null)", ImmutablePair.of(null, null).toString());
-        assertEquals("(null,two)", ImmutablePair.of(null, "two").toString());
-        assertEquals("(one,null)", ImmutablePair.of("one", null).toString());
-        assertEquals("(one,two)", ImmutablePair.of("one", "two").toString());
+    public void testNullPairValue() {
+        assertNull(ImmutablePair.nullPair().getValue());
+    }
+
+    @Test
+    public void testPairOf() {
+        final ImmutablePair<Integer, String> pair = ImmutablePair.of(0, "foo");
+        assertEquals(0, pair.left.intValue());
+        assertEquals(0, pair.getLeft().intValue());
+        assertEquals("foo", pair.right);
+        assertEquals("foo", pair.getRight());
+        final ImmutablePair<Object, String> pair2 = ImmutablePair.of(null, 
"bar");
+        assertNull(pair2.left);
+        assertNull(pair2.getLeft());
+        assertEquals("bar", pair2.right);
+        assertEquals("bar", pair2.getRight());
     }
 
     @Test
@@ -143,6 +135,14 @@ public class ImmutablePairTest {
     }
 
     @Test
+    public void testToString() {
+        assertEquals("(null,null)", ImmutablePair.of(null, null).toString());
+        assertEquals("(null,two)", ImmutablePair.of(null, "two").toString());
+        assertEquals("(one,null)", ImmutablePair.of("one", null).toString());
+        assertEquals("(one,two)", ImmutablePair.of("one", "two").toString());
+    }
+
+    @Test
     public void testUseAsKeyOfHashMap() {
         HashMap<ImmutablePair<Object, Object>, String> map = new HashMap<>();
         Object o1 = new Object();
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 f5205d2..fc27ac8 100644
--- a/src/test/java/org/apache/commons/lang3/tuple/ImmutableTripleTest.java
+++ b/src/test/java/org/apache/commons/lang3/tuple/ImmutableTripleTest.java
@@ -58,24 +58,6 @@ public class ImmutableTripleTest {
     }
 
     @Test
-    public void testTripleOf() {
-        final ImmutableTriple<Integer, String, Boolean> triple = 
ImmutableTriple.of(0, "foo", Boolean.FALSE);
-        assertEquals(0, triple.left.intValue());
-        assertEquals(0, triple.getLeft().intValue());
-        assertEquals("foo", triple.middle);
-        assertEquals("foo", triple.getMiddle());
-        assertEquals(Boolean.FALSE, triple.right);
-        assertEquals(Boolean.FALSE, triple.getRight());
-        final ImmutableTriple<Object, String, Boolean> triple2 = 
ImmutableTriple.of(null, "bar", Boolean.TRUE);
-        assertNull(triple2.left);
-        assertNull(triple2.getLeft());
-        assertEquals("bar", triple2.middle);
-        assertEquals("bar", triple2.getMiddle());
-        assertEquals(Boolean.TRUE, triple2.right);
-        assertEquals(Boolean.TRUE, triple2.getRight());
-    }
-
-    @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));
@@ -97,11 +79,6 @@ public class ImmutableTripleTest {
     }
 
     @Test
-    public void testNullTripleSame() {
-        assertSame(ImmutableTriple.nullTriple(), ImmutableTriple.nullTriple());
-    }
-
-    @Test
     public void testNullTripleLeft() {
         assertNull(ImmutableTriple.nullTriple().getLeft());
     }
@@ -117,6 +94,11 @@ public class ImmutableTripleTest {
     }
 
     @Test
+    public void testNullTripleSame() {
+        assertSame(ImmutableTriple.nullTriple(), ImmutableTriple.nullTriple());
+    }
+
+    @Test
     public void testNullTripleTyped() {
         // No compiler warnings
         // How do we assert that?
@@ -125,6 +107,19 @@ public class ImmutableTripleTest {
     }
 
     @Test
+    @SuppressWarnings("unchecked")
+    public void testSerialization() throws Exception {
+        final ImmutableTriple<Integer, String, Boolean> origTriple = 
ImmutableTriple.of(0, "foo", Boolean.TRUE);
+        final ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        final ObjectOutputStream out = new ObjectOutputStream(baos);
+        out.writeObject(origTriple);
+        final ImmutableTriple<Integer, String, Boolean> deserializedTriple = 
(ImmutableTriple<Integer, String, Boolean>) new ObjectInputStream(
+                new ByteArrayInputStream(baos.toByteArray())).readObject();
+        assertEquals(origTriple, deserializedTriple);
+        assertEquals(origTriple.hashCode(), deserializedTriple.hashCode());
+    }
+
+    @Test
     public void testToString() {
         assertEquals("(null,null,null)", ImmutableTriple.of(null, null, 
null).toString());
         assertEquals("(null,two,null)", ImmutableTriple.of(null, "two", 
null).toString());
@@ -136,16 +131,21 @@ public class ImmutableTripleTest {
     }
 
     @Test
-    @SuppressWarnings("unchecked")
-    public void testSerialization() throws Exception {
-        final ImmutableTriple<Integer, String, Boolean> origTriple = 
ImmutableTriple.of(0, "foo", Boolean.TRUE);
-        final ByteArrayOutputStream baos = new ByteArrayOutputStream();
-        final ObjectOutputStream out = new ObjectOutputStream(baos);
-        out.writeObject(origTriple);
-        final ImmutableTriple<Integer, String, Boolean> deserializedTriple = 
(ImmutableTriple<Integer, String, Boolean>) new ObjectInputStream(
-                new ByteArrayInputStream(baos.toByteArray())).readObject();
-        assertEquals(origTriple, deserializedTriple);
-        assertEquals(origTriple.hashCode(), deserializedTriple.hashCode());
+    public void testTripleOf() {
+        final ImmutableTriple<Integer, String, Boolean> triple = 
ImmutableTriple.of(0, "foo", Boolean.FALSE);
+        assertEquals(0, triple.left.intValue());
+        assertEquals(0, triple.getLeft().intValue());
+        assertEquals("foo", triple.middle);
+        assertEquals("foo", triple.getMiddle());
+        assertEquals(Boolean.FALSE, triple.right);
+        assertEquals(Boolean.FALSE, triple.getRight());
+        final ImmutableTriple<Object, String, Boolean> triple2 = 
ImmutableTriple.of(null, "bar", Boolean.TRUE);
+        assertNull(triple2.left);
+        assertNull(triple2.getLeft());
+        assertEquals("bar", triple2.middle);
+        assertEquals("bar", triple2.getMiddle());
+        assertEquals(Boolean.TRUE, triple2.right);
+        assertEquals(Boolean.TRUE, triple2.getRight());
     }
 
     @Test
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 9d45621..2e2da23 100644
--- a/src/test/java/org/apache/commons/lang3/tuple/MutablePairTest.java
+++ b/src/test/java/org/apache/commons/lang3/tuple/MutablePairTest.java
@@ -50,25 +50,6 @@ public class MutablePairTest {
     }
 
     @Test
-    public void testMutate() {
-        final MutablePair<Integer, String> pair = new MutablePair<>(0, "foo");
-        pair.setLeft(42);
-        pair.setRight("bar");
-        assertEquals(42, pair.getLeft().intValue());
-        assertEquals("bar", pair.getRight());
-    }
-
-    @Test
-    public void testPairOf() {
-        final MutablePair<Integer, String> pair = MutablePair.of(0, "foo");
-        assertEquals(0, pair.getLeft().intValue());
-        assertEquals("foo", pair.getRight());
-        final MutablePair<Object, String> pair2 = MutablePair.of(null, "bar");
-        assertNull(pair2.getLeft());
-        assertEquals("bar", pair2.getRight());
-    }
-
-    @Test
     public void testEquals() {
         assertEquals(MutablePair.of(null, "foo"), MutablePair.of(null, "foo"));
         assertNotEquals(MutablePair.of("foo", 0), MutablePair.of("foo", null));
@@ -85,11 +66,22 @@ public class MutablePairTest {
     }
 
     @Test
-    public void testToString() {
-        assertEquals("(null,null)", MutablePair.of(null, null).toString());
-        assertEquals("(null,two)", MutablePair.of(null, "two").toString());
-        assertEquals("(one,null)", MutablePair.of("one", null).toString());
-        assertEquals("(one,two)", MutablePair.of("one", "two").toString());
+    public void testMutate() {
+        final MutablePair<Integer, String> pair = new MutablePair<>(0, "foo");
+        pair.setLeft(42);
+        pair.setRight("bar");
+        assertEquals(42, pair.getLeft().intValue());
+        assertEquals("bar", pair.getRight());
+    }
+
+    @Test
+    public void testPairOf() {
+        final MutablePair<Integer, String> pair = MutablePair.of(0, "foo");
+        assertEquals(0, pair.getLeft().intValue());
+        assertEquals("foo", pair.getRight());
+        final MutablePair<Object, String> pair2 = MutablePair.of(null, "bar");
+        assertNull(pair2.getLeft());
+        assertEquals("bar", pair2.getRight());
     }
 
     @Test
@@ -104,4 +96,12 @@ public class MutablePairTest {
         assertEquals(origPair, deserializedPair);
         assertEquals(origPair.hashCode(), deserializedPair.hashCode());
     }
+
+    @Test
+    public void testToString() {
+        assertEquals("(null,null)", MutablePair.of(null, null).toString());
+        assertEquals("(null,two)", MutablePair.of(null, "two").toString());
+        assertEquals("(one,null)", MutablePair.of("one", null).toString());
+        assertEquals("(one,two)", MutablePair.of("one", "two").toString());
+    }
 }
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 b5cca98..0c513c6 100644
--- a/src/test/java/org/apache/commons/lang3/tuple/MutableTripleTest.java
+++ b/src/test/java/org/apache/commons/lang3/tuple/MutableTripleTest.java
@@ -53,29 +53,6 @@ public class MutableTripleTest {
     }
 
     @Test
-    public void testMutate() {
-        final MutableTriple<Integer, String, Boolean> triple = new 
MutableTriple<>(0, "foo", Boolean.TRUE);
-        triple.setLeft(42);
-        triple.setMiddle("bar");
-        triple.setRight(Boolean.FALSE);
-        assertEquals(42, triple.getLeft().intValue());
-        assertEquals("bar", triple.getMiddle());
-        assertEquals(Boolean.FALSE, triple.getRight());
-    }
-
-    @Test
-    public void testTripleOf() {
-        final MutableTriple<Integer, String, Boolean> triple = 
MutableTriple.of(0, "foo", Boolean.TRUE);
-        assertEquals(0, triple.getLeft().intValue());
-        assertEquals("foo", triple.getMiddle());
-        assertEquals(Boolean.TRUE, triple.getRight());
-        final MutableTriple<Object, String, String> triple2 = 
MutableTriple.of(null, "bar", "hello");
-        assertNull(triple2.getLeft());
-        assertEquals("bar", triple2.getMiddle());
-        assertEquals("hello", triple2.getRight());
-    }
-
-    @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));
@@ -93,14 +70,14 @@ public class MutableTripleTest {
     }
 
     @Test
-    public void testToString() {
-        assertEquals("(null,null,null)", MutableTriple.of(null, null, 
null).toString());
-        assertEquals("(null,two,null)", MutableTriple.of(null, "two", 
null).toString());
-        assertEquals("(one,null,null)", MutableTriple.of("one", null, 
null).toString());
-        assertEquals("(one,two,null)", MutableTriple.of("one", "two", 
null).toString());
-        assertEquals("(null,two,three)", MutableTriple.of(null, "two", 
"three").toString());
-        assertEquals("(one,null,three)", MutableTriple.of("one", null, 
"three").toString());
-        assertEquals("(one,two,three)", MutableTriple.of("one", "two", 
"three").toString());
+    public void testMutate() {
+        final MutableTriple<Integer, String, Boolean> triple = new 
MutableTriple<>(0, "foo", Boolean.TRUE);
+        triple.setLeft(42);
+        triple.setMiddle("bar");
+        triple.setRight(Boolean.FALSE);
+        assertEquals(42, triple.getLeft().intValue());
+        assertEquals("bar", triple.getMiddle());
+        assertEquals(Boolean.FALSE, triple.getRight());
     }
 
     @Test
@@ -115,5 +92,28 @@ public class MutableTripleTest {
         assertEquals(origTriple, deserializedTriple);
         assertEquals(origTriple.hashCode(), deserializedTriple.hashCode());
     }
+
+    @Test
+    public void testToString() {
+        assertEquals("(null,null,null)", MutableTriple.of(null, null, 
null).toString());
+        assertEquals("(null,two,null)", MutableTriple.of(null, "two", 
null).toString());
+        assertEquals("(one,null,null)", MutableTriple.of("one", null, 
null).toString());
+        assertEquals("(one,two,null)", MutableTriple.of("one", "two", 
null).toString());
+        assertEquals("(null,two,three)", MutableTriple.of(null, "two", 
"three").toString());
+        assertEquals("(one,null,three)", MutableTriple.of("one", null, 
"three").toString());
+        assertEquals("(one,two,three)", MutableTriple.of("one", "two", 
"three").toString());
+    }
+
+    @Test
+    public void testTripleOf() {
+        final MutableTriple<Integer, String, Boolean> triple = 
MutableTriple.of(0, "foo", Boolean.TRUE);
+        assertEquals(0, triple.getLeft().intValue());
+        assertEquals("foo", triple.getMiddle());
+        assertEquals(Boolean.TRUE, triple.getRight());
+        final MutableTriple<Object, String, String> triple2 = 
MutableTriple.of(null, "bar", "hello");
+        assertNull(triple2.getLeft());
+        assertEquals("bar", triple2.getMiddle());
+        assertEquals("hello", triple2.getRight());
+    }
 }
 
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 39c75eb..5de6f16 100644
--- a/src/test/java/org/apache/commons/lang3/tuple/PairTest.java
+++ b/src/test/java/org/apache/commons/lang3/tuple/PairTest.java
@@ -34,15 +34,23 @@ import org.junit.jupiter.api.Test;
 public class PairTest {
 
     @Test
-    public void testPairOf() {
-        final Pair<Integer, String> pair = Pair.of(0, "foo");
-        assertTrue(pair instanceof ImmutablePair<?, ?>);
-        assertEquals(0, ((ImmutablePair<Integer, String>) 
pair).left.intValue());
-        assertEquals("foo", ((ImmutablePair<Integer, String>) pair).right);
-        final Pair<Object, String> pair2 = Pair.of(null, "bar");
-        assertTrue(pair2 instanceof ImmutablePair<?, ?>);
-        assertNull(((ImmutablePair<Object, String>) pair2).left);
-        assertEquals("bar", ((ImmutablePair<Object, String>) pair2).right);
+    public void testComparable1() {
+        final Pair<String, String> pair1 = Pair.of("A", "D");
+        final Pair<String, String> pair2 = Pair.of("B", "C");
+        assertEquals(0, pair1.compareTo(pair1));
+        assertTrue(pair1.compareTo(pair2) < 0);
+        assertEquals(0, pair2.compareTo(pair2));
+        assertTrue(pair2.compareTo(pair1) > 0);
+    }
+
+    @Test
+    public void testComparable2() {
+        final Pair<String, String> pair1 = Pair.of("A", "C");
+        final Pair<String, String> pair2 = Pair.of("A", "D");
+        assertEquals(0, pair1.compareTo(pair1));
+        assertTrue(pair1.compareTo(pair2) < 0);
+        assertEquals(0, pair2.compareTo(pair2));
+        assertTrue(pair2.compareTo(pair1) > 0);
     }
 
     @Test
@@ -61,6 +69,18 @@ public class PairTest {
     }
 
     @Test
+    public void testFormattable_padded() {
+        final Pair<String, String> pair = Pair.of("Key", "Value");
+        assertEquals("         (Key,Value)", String.format("%1$20s", pair));
+    }
+
+    @Test
+    public void testFormattable_simple() {
+        final Pair<String, String> pair = Pair.of("Key", "Value");
+        assertEquals("(Key,Value)", String.format("%1$s", pair));
+    }
+
+    @Test
     public void testMapEntry() {
         final Pair<Integer, String> pair = ImmutablePair.of(0, "foo");
         final HashMap<Integer, String> map = new HashMap<>();
@@ -71,23 +91,15 @@ public class PairTest {
     }
 
     @Test
-    public void testComparable1() {
-        final Pair<String, String> pair1 = Pair.of("A", "D");
-        final Pair<String, String> pair2 = Pair.of("B", "C");
-        assertEquals(0, pair1.compareTo(pair1));
-        assertTrue(pair1.compareTo(pair2) < 0);
-        assertEquals(0, pair2.compareTo(pair2));
-        assertTrue(pair2.compareTo(pair1) > 0);
-    }
-
-    @Test
-    public void testComparable2() {
-        final Pair<String, String> pair1 = Pair.of("A", "C");
-        final Pair<String, String> pair2 = Pair.of("A", "D");
-        assertEquals(0, pair1.compareTo(pair1));
-        assertTrue(pair1.compareTo(pair2) < 0);
-        assertEquals(0, pair2.compareTo(pair2));
-        assertTrue(pair2.compareTo(pair1) > 0);
+    public void testPairOf() {
+        final Pair<Integer, String> pair = Pair.of(0, "foo");
+        assertTrue(pair instanceof ImmutablePair<?, ?>);
+        assertEquals(0, ((ImmutablePair<Integer, String>) 
pair).left.intValue());
+        assertEquals("foo", ((ImmutablePair<Integer, String>) pair).right);
+        final Pair<Object, String> pair2 = Pair.of(null, "bar");
+        assertTrue(pair2 instanceof ImmutablePair<?, ?>);
+        assertNull(((ImmutablePair<Object, String>) pair2).left);
+        assertEquals("bar", ((ImmutablePair<Object, String>) pair2).right);
     }
 
     @Test
@@ -104,16 +116,4 @@ public class PairTest {
         assertEquals("Test created on " + "04-25-2011", pair.toString("Test 
created on %2$tm-%2$td-%2$tY"));
     }
 
-    @Test
-    public void testFormattable_simple() {
-        final Pair<String, String> pair = Pair.of("Key", "Value");
-        assertEquals("(Key,Value)", String.format("%1$s", pair));
-    }
-
-    @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 48ba48f..aad0373 100644
--- a/src/test/java/org/apache/commons/lang3/tuple/TripleTest.java
+++ b/src/test/java/org/apache/commons/lang3/tuple/TripleTest.java
@@ -31,31 +31,6 @@ import org.junit.jupiter.api.Test;
 public class TripleTest {
 
     @Test
-    public void testTripleOf() {
-        final Triple<Integer, String, Boolean> triple = Triple.of(0, "foo", 
Boolean.TRUE);
-        assertTrue(triple instanceof ImmutableTriple<?, ?, ?>);
-        assertEquals(0, ((ImmutableTriple<Integer, String, Boolean>) 
triple).left.intValue());
-        assertEquals("foo", ((ImmutableTriple<Integer, String, Boolean>) 
triple).middle);
-        assertEquals(Boolean.TRUE, ((ImmutableTriple<Integer, String, 
Boolean>) triple).right);
-        final Triple<Object, String, Long> triple2 = Triple.of(null, "bar", 
Long.valueOf(200L));
-        assertTrue(triple2 instanceof ImmutableTriple<?, ?, ?>);
-        assertNull(((ImmutableTriple<Object, String, Long>) triple2).left);
-        assertEquals("bar", ((ImmutableTriple<Object, String, Long>) 
triple2).middle);
-        assertEquals(new Long(200L), ((ImmutableTriple<Object, String, Long>) 
triple2).right);
-    }
-
-    @Test
-    public void testCompatibilityBetweenTriples() {
-        final Triple<Integer, String, Boolean> triple = ImmutableTriple.of(0, 
"foo", Boolean.TRUE);
-        final Triple<Integer, String, Boolean> triple2 = MutableTriple.of(0, 
"foo", Boolean.TRUE);
-        assertEquals(triple, triple2);
-        assertEquals(triple.hashCode(), triple2.hashCode());
-        final HashSet<Triple<Integer, String, Boolean>> set = new HashSet<>();
-        set.add(triple);
-        assertTrue(set.contains(triple2));
-    }
-
-    @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");
@@ -96,6 +71,29 @@ public class TripleTest {
     }
 
     @Test
+    public void testCompatibilityBetweenTriples() {
+        final Triple<Integer, String, Boolean> triple = ImmutableTriple.of(0, 
"foo", Boolean.TRUE);
+        final Triple<Integer, String, Boolean> triple2 = MutableTriple.of(0, 
"foo", Boolean.TRUE);
+        assertEquals(triple, triple2);
+        assertEquals(triple.hashCode(), triple2.hashCode());
+        final HashSet<Triple<Integer, String, Boolean>> set = new HashSet<>();
+        set.add(triple);
+        assertTrue(set.contains(triple2));
+    }
+
+    @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));
+    }
+
+    @Test
+    public void testFormattable_simple() {
+        final Triple<String, String, String> triple = Triple.of("Key", 
"Something", "Value");
+        assertEquals("(Key,Something,Value)", String.format("%1$s", triple));
+    }
+
+    @Test
     public void testToString() {
         final Triple<String, String, String> triple = Triple.of("Key", 
"Something", "Value");
         assertEquals("(Key,Something,Value)", triple.toString());
@@ -110,15 +108,17 @@ public class TripleTest {
     }
 
     @Test
-    public void testFormattable_simple() {
-        final Triple<String, String, String> triple = Triple.of("Key", 
"Something", "Value");
-        assertEquals("(Key,Something,Value)", String.format("%1$s", triple));
-    }
-
-    @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));
+    public void testTripleOf() {
+        final Triple<Integer, String, Boolean> triple = Triple.of(0, "foo", 
Boolean.TRUE);
+        assertTrue(triple instanceof ImmutableTriple<?, ?, ?>);
+        assertEquals(0, ((ImmutableTriple<Integer, String, Boolean>) 
triple).left.intValue());
+        assertEquals("foo", ((ImmutableTriple<Integer, String, Boolean>) 
triple).middle);
+        assertEquals(Boolean.TRUE, ((ImmutableTriple<Integer, String, 
Boolean>) triple).right);
+        final Triple<Object, String, Long> triple2 = Triple.of(null, "bar", 
Long.valueOf(200L));
+        assertTrue(triple2 instanceof ImmutableTriple<?, ?, ?>);
+        assertNull(((ImmutableTriple<Object, String, Long>) triple2).left);
+        assertEquals("bar", ((ImmutableTriple<Object, String, Long>) 
triple2).middle);
+        assertEquals(new Long(200L), ((ImmutableTriple<Object, String, Long>) 
triple2).right);
     }
 
 }

Reply via email to