ignite-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ag...@apache.org
Subject ignite git commit: IGNITE-7881 Tests for using TreeMap or TreeSet as cache key.
Date Mon, 12 Mar 2018 12:19:27 GMT
Repository: ignite
Updated Branches:
  refs/heads/master 4ee181ce4 -> 29d56aede


IGNITE-7881 Tests for using TreeMap or TreeSet as cache key.

Signed-off-by: Andrey Gura <agura@apache.org>


Project: http://git-wip-us.apache.org/repos/asf/ignite/repo
Commit: http://git-wip-us.apache.org/repos/asf/ignite/commit/29d56aed
Tree: http://git-wip-us.apache.org/repos/asf/ignite/tree/29d56aed
Diff: http://git-wip-us.apache.org/repos/asf/ignite/diff/29d56aed

Branch: refs/heads/master
Commit: 29d56aedeae7c00ffe997530aeb7624d5863df5b
Parents: 4ee181c
Author: Ilya Kasnacheev <ilya.kasnacheev@gmail.com>
Authored: Mon Mar 12 15:19:10 2018 +0300
Committer: Andrey Gura <agura@apache.org>
Committed: Mon Mar 12 15:19:10 2018 +0300

----------------------------------------------------------------------
 .../internal/binary/BinaryTreeSelfTest.java     | 273 +++++++++++++++----
 1 file changed, 226 insertions(+), 47 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/ignite/blob/29d56aed/modules/core/src/test/java/org/apache/ignite/internal/binary/BinaryTreeSelfTest.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/binary/BinaryTreeSelfTest.java
b/modules/core/src/test/java/org/apache/ignite/internal/binary/BinaryTreeSelfTest.java
index 9481340..819e766 100644
--- a/modules/core/src/test/java/org/apache/ignite/internal/binary/BinaryTreeSelfTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/internal/binary/BinaryTreeSelfTest.java
@@ -17,6 +17,11 @@
 
 package org.apache.ignite.internal.binary;
 
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.TreeMap;
+import java.util.TreeSet;
+import javax.cache.Cache.Entry;
 import org.apache.ignite.IgniteCache;
 import org.apache.ignite.Ignition;
 import org.apache.ignite.binary.BinaryObject;
@@ -29,11 +34,6 @@ import org.apache.ignite.spi.discovery.tcp.ipfinder.vm.TcpDiscoveryVmIpFinder;
 import org.apache.ignite.testframework.junits.common.GridCommonAbstractTest;
 import org.jetbrains.annotations.NotNull;
 
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.TreeMap;
-import java.util.TreeSet;
-
 /**
  * Tests for TreeMap and TreeSet structures.
  */
@@ -71,8 +71,8 @@ public class BinaryTreeSelfTest extends GridCommonAbstractTest {
      *
      * @throws Exception If failed.
      */
-    public void testTreeMapRegularNoComparator() throws Exception {
-        checkTreeMap(false, false);
+    public void testTreeMapAsValueRegularNoComparator() throws Exception {
+        checkTreeMapAsValue(false, false);
     }
 
     /**
@@ -80,8 +80,8 @@ public class BinaryTreeSelfTest extends GridCommonAbstractTest {
      *
      * @throws Exception If failed.
      */
-    public void testTreeMapRegularComparator() throws Exception {
-        checkTreeMap(false, true);
+    public void testTreeMapAsValueRegularComparator() throws Exception {
+        checkTreeMapAsValue(false, true);
     }
 
     /**
@@ -89,8 +89,8 @@ public class BinaryTreeSelfTest extends GridCommonAbstractTest {
      *
      * @throws Exception If failed.
      */
-    public void testTreeMapBinaryNoComparator() throws Exception {
-        checkTreeMap(true, false);
+    public void testTreeMapAsValueBinaryNoComparator() throws Exception {
+        checkTreeMapAsValue(true, false);
     }
 
     /**
@@ -98,8 +98,26 @@ public class BinaryTreeSelfTest extends GridCommonAbstractTest {
      *
      * @throws Exception If failed.
      */
-    public void testTreeMapBinaryComparator() throws Exception {
-        checkTreeMap(true, true);
+    public void testTreeMapAsValueBinaryComparator() throws Exception {
+        checkTreeMapAsValue(true, true);
+    }
+
+    /**
+     * Test {@code TreeMap} data structure when used as key.
+     *
+     * @throws Exception If failed.
+     */
+    public void testTreeMapAsKeyNoComparator() throws Exception {
+        checkTreeMapAsKey(false);
+    }
+
+    /**
+     * Test {@code TreeMap} data structure with comparator when used as key.
+     *
+     * @throws Exception If failed.
+     */
+    public void testTreeMapAsKeyComparator() throws Exception {
+        checkTreeMapAsKey(true);
     }
 
     /**
@@ -110,22 +128,11 @@ public class BinaryTreeSelfTest extends GridCommonAbstractTest {
      * @throws Exception If failed.
      */
     @SuppressWarnings("unchecked")
-    private void checkTreeMap(boolean useBinary, boolean useComparator) throws Exception
{
+    private void checkTreeMapAsValue(boolean useBinary, boolean useComparator) throws Exception
{
         // Populate map.
         TreeMap<TestKey, Integer> map;
 
-        if (useComparator) {
-            map = new TreeMap<>(new TestKeyComparator());
-
-            for (int i = 0; i < SIZE; i++)
-                map.put(key(false, i), i);
-        }
-        else {
-            map = new TreeMap<>();
-
-            for (int i = 0; i < SIZE; i++)
-                map.put(key(true, i), i);
-        }
+        map = testMap(useComparator);
 
         // Put and get value from cache.
         cache().put(KEY, map);
@@ -147,6 +154,71 @@ public class BinaryTreeSelfTest extends GridCommonAbstractTest {
             assertNull(resMap.comparator());
 
         assertEquals(map, resMap);
+
+        cache().clear();
+    }
+
+    /**
+     * Check {@code TreeMap} data structure when used as key.
+     *
+     * @param useComparator Whether comparator should be used.
+     * @throws Exception If failed.
+     */
+    @SuppressWarnings("unchecked")
+    private void checkTreeMapAsKey(boolean useComparator) throws Exception {
+        // Populate map.
+        TreeMap<TestKey, Integer> map;
+
+        map = testMap(useComparator);
+
+        // Put and get value from cache.
+        cache().put(map, KEY);
+
+        TreeMap<TestKey, Integer> resMap = (TreeMap<TestKey, Integer>)((Entry)cache().iterator().next()).getKey();
+
+        // Ensure content is correct.
+        if (useComparator)
+            assert resMap.comparator() instanceof TestKeyComparator;
+        else
+            assertNull(resMap.comparator());
+
+        assertEquals(map, resMap);
+
+        // Ensure value is correct.
+        Integer resSameMap = (Integer)cache().get(map);
+
+        assertEquals((Object)KEY, resSameMap);
+
+        Integer resIdenticalMap = (Integer)cache().get(testMap(useComparator));
+
+        assertEquals((Object)KEY, resIdenticalMap);
+
+        // Ensure wrong comparator is not accepted.
+        Integer resDifferentComp = (Integer)cache().get(testMap(!useComparator));
+
+        assertEquals(null, resDifferentComp);
+
+        cache().clear();
+    }
+
+    /** */
+    private TreeMap<TestKey, Integer> testMap(boolean useComp) {
+        TreeMap<TestKey, Integer> map;
+
+        if (useComp) {
+            map = new TreeMap<>(new TestKeyComparator());
+
+            for (int i = 0; i < SIZE; i++)
+                map.put(key(false, i), i);
+        }
+        else {
+            map = new TreeMap<>();
+
+            for (int i = 0; i < SIZE; i++)
+                map.put(key(true, i), i);
+        }
+
+        return map;
     }
 
     /**
@@ -154,8 +226,8 @@ public class BinaryTreeSelfTest extends GridCommonAbstractTest {
      *
      * @throws Exception If failed.
      */
-    public void testTreeSetRegularNoComparator() throws Exception {
-        checkTreeSet(false, false);
+    public void testTreeSetAsValueRegularNoComparator() throws Exception {
+        checkTreeSetAsValue(false, false);
     }
 
     /**
@@ -163,8 +235,8 @@ public class BinaryTreeSelfTest extends GridCommonAbstractTest {
      *
      * @throws Exception If failed.
      */
-    public void testTreeSetRegularComparator() throws Exception {
-        checkTreeSet(false, true);
+    public void testTreeSetAsValueRegularComparator() throws Exception {
+        checkTreeSetAsValue(false, true);
     }
 
     /**
@@ -172,8 +244,8 @@ public class BinaryTreeSelfTest extends GridCommonAbstractTest {
      *
      * @throws Exception If failed.
      */
-    public void testTreeSetBinaryNoComparator() throws Exception {
-        checkTreeSet(true, false);
+    public void testTreeSetAsValueBinaryNoComparator() throws Exception {
+        checkTreeSetAsValue(true, false);
     }
 
     /**
@@ -181,8 +253,26 @@ public class BinaryTreeSelfTest extends GridCommonAbstractTest {
      *
      * @throws Exception If failed.
      */
-    public void testTreeSetBinaryComparator() throws Exception {
-        checkTreeSet(true, true);
+    public void testTreeSetAsValueBinaryComparator() throws Exception {
+        checkTreeSetAsValue(true, true);
+    }
+
+    /**
+     * Test {@code TreeSet} data structure.
+     *
+     * @throws Exception If failed.
+     */
+    public void testTreeSetAsKeyNoComparator() throws Exception {
+        checkTreeSetAsKey(false);
+    }
+
+    /**
+     * Test {@code TreeSet} data structure with comparator.
+     *
+     * @throws Exception If failed.
+     */
+    public void testTreeSetAsKeyComparator() throws Exception {
+        checkTreeSetAsKey(true);
     }
 
     /**
@@ -193,22 +283,11 @@ public class BinaryTreeSelfTest extends GridCommonAbstractTest {
      * @throws Exception If failed.
      */
     @SuppressWarnings("unchecked")
-    private void checkTreeSet(boolean useBinary, boolean useComparator) throws Exception
{
+    private void checkTreeSetAsValue(boolean useBinary, boolean useComparator) throws Exception
{
         // Populate set.
         TreeSet<TestKey> set;
 
-        if (useComparator) {
-            set = new TreeSet<>(new TestKeyComparator());
-
-            for (int i = 0; i < SIZE; i++)
-                set.add(key(false, i));
-        }
-        else {
-            set = new TreeSet<>();
-
-            for (int i = 0; i < SIZE; i++)
-                set.add(key(true, i));
-        }
+        set = testSet(useComparator);
 
         // Put and get value from cache.
         cache().put(KEY, set);
@@ -230,6 +309,73 @@ public class BinaryTreeSelfTest extends GridCommonAbstractTest {
             assertNull(resSet.comparator());
 
         assertEquals(set, resSet);
+
+        cache().clear();
+    }
+
+    /**
+     * Check {@code TreeSet} data structure when used as key.
+     *
+     * @param useComp Whether comparator should be used.
+     * @throws Exception If failed.
+     */
+    @SuppressWarnings("unchecked")
+    private void checkTreeSetAsKey(boolean useComp) throws Exception {
+        // Populate set.
+        TreeSet<TestKey> set;
+
+        set = testSet(useComp);
+
+        // Put and get value from cache.
+        cache().put(set, KEY);
+
+        TreeSet<TestKey> resSet = (TreeSet<TestKey>)((Entry)cache().iterator().next()).getKey();
+
+        // Ensure content is correct.
+        if (useComp)
+            assert resSet.comparator() instanceof TestKeyComparator;
+        else
+            assertNull(resSet.comparator());
+
+        assertEquals(set, resSet);
+
+        // Ensure value is correct.
+        Integer resSameMap = (Integer)cache().get(set);
+
+        assertEquals((Object)KEY, resSameMap);
+
+        Integer resIdenticalMap = (Integer)cache().get(testSet(useComp));
+
+        assertEquals((Object)KEY, resIdenticalMap);
+
+        // Ensure wrong comparator is not accepted.
+        Integer resDifferentComp = (Integer)cache().get(testSet(!useComp));
+
+        assertEquals(null, resDifferentComp);
+
+        assertEquals(set, resSet);
+
+        cache().clear();
+    }
+
+    /** */
+    private TreeSet<TestKey> testSet(boolean useComp) {
+        TreeSet<TestKey> set;
+
+        if (useComp) {
+            set = new TreeSet<>(new TestKeyComparator());
+
+            for (int i = 0; i < SIZE; i++)
+                set.add(key(false, i));
+        }
+        else {
+            set = new TreeSet<>();
+
+            for (int i = 0; i < SIZE; i++)
+                set.add(key(true, i));
+        }
+
+        return set;
     }
 
     /**
@@ -308,6 +454,23 @@ public class BinaryTreeSelfTest extends GridCommonAbstractTest {
         public int id() {
             return id;
         }
+
+        /** */
+        @Override public boolean equals(Object o) {
+            if (this == o)
+                return true;
+            if (o == null || getClass() != o.getClass())
+                return false;
+
+            TestKey key = (TestKey)o;
+
+            return id == key.id;
+        }
+
+        /** */
+        @Override public int hashCode() {
+            return id;
+        }
     }
 
     /**
@@ -337,5 +500,21 @@ public class BinaryTreeSelfTest extends GridCommonAbstractTest {
         @Override public int compare(TestKey o1, TestKey o2) {
             return o1.id() - o2.id();
         }
+
+        /** */
+        @Override public boolean equals(Object o) {
+            if (this == o)
+                return true;
+
+            if (o == null || getClass() != o.getClass())
+                return false;
+
+            return true;
+        }
+
+        /** */
+        @Override public int hashCode() {
+            return 13;
+        }
     }
 }


Mime
View raw message