Merge pull request skyscreamer#9 from hertzsprung/enum-enhance

carterpage · carterpage · commit f208db0ec5f7 · 2012-08-31T04:49:03.000-07:00
Enhance JSONCompareMode enum
diff --git a/src/main/java/org/skyscreamer/jsonassert/JSONCompareMode.java b/src/main/java/org/skyscreamer/jsonassert/JSONCompareMode.java
@@ -12,7 +12,7 @@
  *     <tr><th>STRICT_ORDER</th><th>yes</th><th>yes</th></tr>
  * </table>
  *
- * <p>If extensbility not allowed, then all of the expected values must match in what's being tested,
+ * <p>If extensibility not allowed, then all of the expected values must match in what's being tested,
  * but any additional fields will cause the test to fail.  When extensibility is allowed, all values
  * must still match.  For example, if you're expecting:</p>
  *
@@ -45,7 +45,7 @@ public enum JSONCompareMode {
      */
     NON_EXTENSIBLE(false, false),
     /**
-     * Strict order checking.  Not extensible, but strict array ordering.
+     * Strict order checking.  Extensible, and strict array ordering.
      */
     STRICT_ORDER(true, true);
 
@@ -72,4 +72,30 @@ public boolean isExtensible() {
     public boolean hasStrictOrder() {
         return _strictOrder;
     }
+    
+    /**
+     * Get the equivalent {@code JSONCompareMode} with or without strict ordering.
+     * 
+     * @return the equivalent {@code JSONCompareMode}
+     */
+    public JSONCompareMode withStrictOrdering(boolean strictOrdering) {
+        if (strictOrdering) {
+            return isExtensible() ? STRICT_ORDER : STRICT;
+        } else {
+            return isExtensible() ? LENIENT : NON_EXTENSIBLE;
+        }
+    }
+
+    /**
+     * Get the equivalent {@code JSONCompareMode} with or without extensibility.
+     * 
+     * @return the equivalent {@code JSONCompareMode}
+     */
+    public JSONCompareMode withExtensible(boolean extensible) {
+        if (extensible) {
+            return hasStrictOrder() ? STRICT_ORDER : LENIENT;
+        } else {
+            return hasStrictOrder() ? STRICT : NON_EXTENSIBLE;
+        }
+    }
 }
diff --git a/src/test/java/org/skyscreamer/jsonassert/JSONCompareModeTest.java b/src/test/java/org/skyscreamer/jsonassert/JSONCompareModeTest.java
@@ -0,0 +1,60 @@
+package org.skyscreamer.jsonassert;
+
+import static junit.framework.Assert.assertEquals;
+import static junit.framework.Assert.assertFalse;
+import static junit.framework.Assert.assertTrue;
+import static org.skyscreamer.jsonassert.JSONCompareMode.LENIENT;
+import static org.skyscreamer.jsonassert.JSONCompareMode.NON_EXTENSIBLE;
+import static org.skyscreamer.jsonassert.JSONCompareMode.STRICT;
+import static org.skyscreamer.jsonassert.JSONCompareMode.STRICT_ORDER;
+
+import org.junit.Test;
+
+/**
+ * Unit tests for {@link JSONCompareMode}
+ */
+public class JSONCompareModeTest {
+    @Test
+    public void testWithStrictOrdering() {
+        assertTrue(LENIENT.withStrictOrdering(true).hasStrictOrder());
+        assertTrue(LENIENT.withStrictOrdering(true).isExtensible());
+        assertTrue(NON_EXTENSIBLE.withStrictOrdering(true).hasStrictOrder());
+        assertFalse(NON_EXTENSIBLE.withStrictOrdering(true).isExtensible());
+        
+        assertEquals(STRICT.withStrictOrdering(true), STRICT);
+        assertEquals(STRICT_ORDER.withStrictOrdering(true), STRICT_ORDER);
+    }
+    
+    @Test
+    public void testWithoutStrictOrdering() {
+        assertFalse(STRICT_ORDER.withStrictOrdering(false).hasStrictOrder());
+        assertTrue(STRICT_ORDER.withStrictOrdering(false).isExtensible());
+        assertFalse(STRICT.withStrictOrdering(false).hasStrictOrder());
+        assertFalse(STRICT.withStrictOrdering(false).isExtensible());
+        
+        assertEquals(LENIENT.withStrictOrdering(false), LENIENT);
+        assertEquals(NON_EXTENSIBLE.withStrictOrdering(false), NON_EXTENSIBLE);
+    }
+    
+    @Test
+    public void testWithExtensibility() {
+        assertTrue(NON_EXTENSIBLE.withExtensible(true).isExtensible());
+        assertFalse(NON_EXTENSIBLE.withExtensible(true).hasStrictOrder());
+        assertTrue(STRICT.withExtensible(true).isExtensible());
+        assertTrue(STRICT.withExtensible(true).hasStrictOrder());
+        
+        assertEquals(LENIENT.withExtensible(true), LENIENT);
+        assertEquals(STRICT_ORDER.withExtensible(true), STRICT_ORDER);
+    }
+    
+    @Test
+    public void testWithoutExtensibility() {
+        assertFalse(STRICT_ORDER.withExtensible(false).isExtensible());
+        assertTrue(STRICT_ORDER.withExtensible(false).hasStrictOrder());
+        assertFalse(LENIENT.withExtensible(false).isExtensible());
+        assertFalse(LENIENT.withExtensible(false).hasStrictOrder());
+        
+        assertEquals(STRICT.withExtensible(false), STRICT);
+        assertEquals(NON_EXTENSIBLE.withExtensible(false), NON_EXTENSIBLE);
+    }
+}
