ignite-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From yzhda...@apache.org
Subject [07/50] [abbrv] incubator-ignite git commit: #IGNITE-99: New tests
Date Wed, 28 Jan 2015 13:50:45 GMT
#IGNITE-99: New tests


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

Branch: refs/heads/ignite-113
Commit: 8c4a1e2a7c4ec9c96d5d12200b565bbce65270de
Parents: 1ec0c2d
Author: ivasilinets <ivasilinets@gridgain.com>
Authored: Tue Jan 27 18:50:54 2015 +0300
Committer: ivasilinets <ivasilinets@gridgain.com>
Committed: Tue Jan 27 18:50:54 2015 +0300

----------------------------------------------------------------------
 .../affinity/GridAffinityProcessor.java         |  15 +-
 .../apache/ignite/IgniteCacheAffinityTest.java  | 168 ++++++++++---------
 2 files changed, 100 insertions(+), 83 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/8c4a1e2a/modules/core/src/main/java/org/apache/ignite/internal/processors/affinity/GridAffinityProcessor.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/affinity/GridAffinityProcessor.java
b/modules/core/src/main/java/org/apache/ignite/internal/processors/affinity/GridAffinityProcessor.java
index bad1f59..ecc94df 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/affinity/GridAffinityProcessor.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/affinity/GridAffinityProcessor.java
@@ -498,7 +498,7 @@ public class GridAffinityProcessor extends GridProcessorAdapter {
         /**
          * @return Cache affinity function.
          */
-        private CacheAffinityFunction affFunc() {
+        private CacheAffinityFunction affinityFunction() {
             return affFunc;
         }
 
@@ -509,6 +509,10 @@ public class GridAffinityProcessor extends GridProcessorAdapter {
             return assignment;
         }
 
+        private CacheAffinityKeyMapper keyMapper() {
+            return mapper;
+        }
+
         /** {@inheritDoc} */
         @Override public String toString() {
             return S.toString(AffinityInfo.class, this);
@@ -581,7 +585,7 @@ public class GridAffinityProcessor extends GridProcessorAdapter {
             ctx.gateway().readLock();
 
             try {
-                return cache().affFunc().partitions();
+                return cache().affinityFunction().partitions();
             }
             catch (IgniteCheckedException e) {
                 throw new IgniteException(e);
@@ -596,7 +600,7 @@ public class GridAffinityProcessor extends GridProcessorAdapter {
             ctx.gateway().readLock();
 
             try {
-                return cache().affFunc().partition(key);
+                return cache().affinityFunction().partition(key);
             }
             catch (IgniteCheckedException e) {
                 throw new IgniteException(e);
@@ -707,7 +711,7 @@ public class GridAffinityProcessor extends GridProcessorAdapter {
             ctx.gateway().readLock();
 
             try {
-                return cache().mapper.affinityKey(key);
+                return cache().keyMapper().affinityKey(key);
             }
             catch (IgniteCheckedException e) {
                 throw new IgniteException(e);
@@ -737,7 +741,6 @@ public class GridAffinityProcessor extends GridProcessorAdapter {
             ctx.gateway().readLock();
 
             try {
-                //return affinityCache(cacheName, topologyVersion()).assignment.get()
                 return GridAffinityProcessor.this.mapKeyToNode(cacheName, key);
             }
             catch (IgniteCheckedException e) {
@@ -753,7 +756,7 @@ public class GridAffinityProcessor extends GridProcessorAdapter {
             ctx.gateway().readLock();
 
             try {
-                return cache().assignment.get(partition(key));
+                return cache().assignment().get(partition(key));
             }
             catch (IgniteCheckedException e) {
                 throw new IgniteException(e);

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/8c4a1e2a/modules/core/src/test/java/org/apache/ignite/IgniteCacheAffinityTest.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/IgniteCacheAffinityTest.java b/modules/core/src/test/java/org/apache/ignite/IgniteCacheAffinityTest.java
index 5989245..19ddc75 100644
--- a/modules/core/src/test/java/org/apache/ignite/IgniteCacheAffinityTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/IgniteCacheAffinityTest.java
@@ -9,7 +9,6 @@ import org.apache.ignite.cluster.*;
 import org.apache.ignite.configuration.*;
 import org.apache.ignite.internal.processors.cache.*;
 
-import javax.cache.*;
 import java.util.*;
 
 import static org.apache.ignite.cache.CacheAtomicityMode.*;
@@ -98,109 +97,107 @@ public class IgniteCacheAffinityTest extends IgniteCacheAbstractTest
{
      * Check CacheAffinityProxy methods.
      */
     private void checkAffinity() {
-        checkGridAffinity(grid(0).affinity(null), grid(1).jcache(null), grid(1).cache(null));
-
-        checkGridAffinity(grid(0).affinity(CACHE1), grid(1).jcache(CACHE1), grid(1).cache(CACHE1));
-
-        checkGridAffinity(grid(0).affinity(CACHE2), grid(1).jcache(CACHE2), grid(1).cache(CACHE2));
-
-        checkGridAffinity(grid(0).affinity(CACHE3), grid(1).jcache(CACHE3), grid(1).cache(CACHE3));
+        checkAffinity(grid(0).affinity(null), grid(1).cache(null).affinity());
+        checkAffinity(grid(0).affinity(CACHE1), grid(1).cache(CACHE1).affinity());
+        checkAffinity(grid(0).affinity(CACHE2), grid(1).cache(CACHE2).affinity());
+        checkAffinity(grid(0).affinity(CACHE3), grid(1).cache(CACHE3).affinity());
     }
 
     /**
      * @param testAff Cache affinity to test.
-     * @param jcache Ignite cache.
-     * @param cache Cache.
+     * @param aff Cache affinity.
      */
-    private void checkGridAffinity(CacheAffinity testAff, IgniteCache jcache, GridCache cache)
{
-        checkAffinityKey(testAff, jcache, cache.affinity());
-
-        checkPartitions(testAff, cache.affinity());
-
-        checkIsBackupOrPrimary(testAff, jcache, cache.affinity());
-
-        checkMapKeyToNode(testAff, jcache, cache.affinity());
+    private void checkAffinity(CacheAffinity testAff, CacheAffinity aff) {
+        checkAffinityKey(testAff, aff);
+        checkPartitions(testAff, aff);
+        checkIsBackupOrPrimary(testAff, aff);
+        checkMapKeyToNode(testAff, aff);
+        checkMapKeysToNodes(testAff, aff);
+        checkMapPartitionsToNodes(testAff, aff);
     }
 
     /**
-     * Check mapKeyToNode, mapKeyToPrimaryAndBackups and mapPartitionToNode methods.
+     * Check affinityKey method.
      */
-    private void checkMapKeyToNode(CacheAffinity testAff, IgniteCache jcache, CacheAffinity
aff) {
-        for (int i = 0; i < 10000; i++) {
-
-        }
-        
-        Iterator<Cache.Entry> iter = jcache.iterator();
-
-        while (iter.hasNext()) {
-            Cache.Entry entry = iter.next();
-
-            UUID node1 = testAff.mapKeyToNode(entry.getKey()).id();
-            UUID node2 = aff.mapKeyToNode(entry.getKey()).id();
-
-            assertEquals(node1, node2);
-
-            Collection<ClusterNode> nodes1 = testAff.mapKeyToPrimaryAndBackups(entry.getKey());
-            Collection<ClusterNode> nodes2 = aff.mapKeyToPrimaryAndBackups(entry.getKey());
+    private void checkAffinityKey(CacheAffinity testAff,CacheAffinity aff) {
+        for (int i = 0; i < 10000; i++)
+            assertEquals(testAff.affinityKey(i), aff.affinityKey(i));
+    }
 
-            checkEqualCollection(nodes1, nodes2);
+    /**
+     * Check allPartitions, backupPartitions and primaryPartitions methods.
+     */
+    private void checkPartitions(CacheAffinity testAff, CacheAffinity aff) {
+        for (ClusterNode n : nodes()) {
+            checkEqualIntArray(testAff.allPartitions(n), aff.allPartitions(n));
 
-            int part = aff.partition(entry.getKey());
+            checkEqualIntArray(testAff.backupPartitions(n), aff.backupPartitions(n));
 
-            assertEquals(testAff.mapPartitionToNode(part).id(), aff.mapPartitionToNode(part).id());
+            checkEqualIntArray(testAff.primaryPartitions(n), aff.primaryPartitions(n));
         }
     }
 
     /**
-     * Check affinityKey method.
+     * Check isBackup, isPrimary and isPrimaryOrBackup methods.
      */
-    private void checkAffinityKey(CacheAffinity testAff, IgniteCache jcache, CacheAffinity
aff) {
-        Iterator<Cache.Entry> iter = jcache.iterator();
+    private void checkIsBackupOrPrimary(CacheAffinity testAff, CacheAffinity aff) {
+        for (int i = 0; i < 10000; i++)
+            for (ClusterNode n : nodes()) {
+                assertEquals(testAff.isBackup(n, i), aff.isBackup(n, i));
 
-        while (iter.hasNext()) {
-            Cache.Entry entry = iter.next();
+                assertEquals(testAff.isPrimary(n, i), aff.isPrimary(n, i));
 
-            assertEquals(testAff.affinityKey(entry.getKey()), (aff.affinityKey(entry.getKey())));
-        }
+                assertEquals(testAff.isPrimaryOrBackup(n, i), aff.isPrimaryOrBackup(n, i));
+            }
     }
 
     /**
-     * Check isBackup, isPrimary and isPrimaryOrBackup methods.
+     * Check mapKeyToNode, mapKeyToPrimaryAndBackups, mapPartitionToPrimaryAndBackups and
mapPartitionToNode methods.
      */
-    private void checkIsBackupOrPrimary(CacheAffinity testAff, IgniteCache jcache, CacheAffinity
aff) {
-
-        Iterator<Cache.Entry> iter = jcache.iterator();
+    private void checkMapKeyToNode(CacheAffinity testAff, CacheAffinity aff) {
+        for (int i = 0; i < 10000; i++) {
+            assertEquals(testAff.mapKeyToNode(i).id(), aff.mapKeyToNode(i).id());
 
-        while (iter.hasNext()) {
-            Cache.Entry entry = iter.next();
+            checkEqualCollection(testAff.mapKeyToPrimaryAndBackups(i), aff.mapKeyToPrimaryAndBackups(i));
+        }
 
-            for (ClusterNode n : nodes()) {
-                assertEquals(testAff.isBackup(n, entry.getKey()), aff.isBackup(n, entry.getKey()));
+        assertEquals(aff.partitions(), testAff.partitions());
 
-                assertEquals(testAff.isPrimary(n, entry.getKey()), aff.isPrimary(n, entry.getKey()));
+        for (int part = 0; part < aff.partitions(); ++part) {
+            assertEquals(testAff.mapPartitionToNode(part).id(), aff.mapPartitionToNode(part).id());
 
-                assertEquals(testAff.isPrimaryOrBackup(n, entry.getKey()), aff.isPrimaryOrBackup(n,
entry.getKey()));
-            }
+            checkEqualCollection(testAff.mapPartitionToPrimaryAndBackups(part), aff.mapKeyToPrimaryAndBackups(part));
         }
     }
 
     /**
-     * Check allPartitions, backupPartitions and primaryPartitions methods.
+     * Check mapKeysToNodes methods.
      */
-    private void checkPartitions(CacheAffinity testAff, CacheAffinity aff) {
-        for (ClusterNode n : nodes()) {
-            checkEqualIntArray(testAff.allPartitions(n), aff.allPartitions(n));
+    private void checkMapKeysToNodes(CacheAffinity testAff, CacheAffinity aff) {
+        List<Integer> keys = new ArrayList<>(10000);
 
-            checkEqualIntArray(testAff.backupPartitions(n), aff.backupPartitions(n));
+        for (int i = 0; i < 10000; ++i)
+            keys.add(i);
 
-            checkEqualIntArray(testAff.primaryPartitions(n), aff.primaryPartitions(n));
-        }
+        checkEqualMaps(testAff.mapKeysToNodes(keys), aff.mapKeysToNodes(keys));
+    }
+
+    /**
+     * Check mapPartitionsToNodes methods.
+     */
+    private void checkMapPartitionsToNodes(CacheAffinity testAff, CacheAffinity aff) {
+        List<Integer> parts = new ArrayList<>(aff.partitions());
+
+        for (int i = 0; i < aff.partitions(); ++i)
+            parts.add(i);
+
+        checkEqualPartitionMaps(testAff.mapPartitionsToNodes(parts), aff.mapPartitionsToNodes(parts));
     }
 
     /**
      * Check equal arrays.
      */
-    private void checkEqualIntArray(int[] arr1, int[] arr2) {
+    private static void checkEqualIntArray(int[] arr1, int[] arr2) {
         assertEquals(arr1.length, arr2.length);
 
         Collection<Integer> col1 = new HashSet<>();
@@ -220,26 +217,43 @@ public class IgniteCacheAffinityTest extends IgniteCacheAbstractTest
{
     /**
      * Check equal collections.
      */
-    private void checkEqualCollection(Collection<ClusterNode> col1, Collection<ClusterNode>
col2) {
-        Collection<ClusterNode> colCopy1 = new HashSet<>(col1);
+    private static void checkEqualCollection(Collection<ClusterNode> col1, Collection<ClusterNode>
col2) {
+        assertEquals(col1.size(), col2.size());
+
+        for (ClusterNode node : col1)
+            assertTrue(col2.contains(node));
+    }
+
+    /**
+     * Check equal maps.
+     */
+    private static void checkEqualMaps(Map<ClusterNode, Collection> map1, Map<ClusterNode,
Collection> map2) {
+        assertEquals(map1.size(), map2.size());
 
-        for (ClusterNode node : col2) {
-            assertTrue(colCopy1.contains(node));
-            colCopy1.remove(node);
+        for (ClusterNode node : map1.keySet()) {
+            assertTrue(map2.containsKey(node));
+
+            assertEquals(map1.get(node).size(), map2.get(node).size());
         }
+    }
 
-        assertEquals(0, colCopy1.size());
+    /**
+     * Check equal maps.
+     */
+    private static void checkEqualPartitionMaps(Map<Integer, ClusterNode> map1, Map<Integer,
ClusterNode> map2) {
+        assertEquals(map1.size(), map2.size());
+
+        for (Integer i : map1.keySet()) {
+            assertTrue(map2.containsKey(i));
+
+            assertEquals(map1.get(i), map2.get(i));
+        }
     }
 
     /**
      * @return Cluster nodes.
      */
     private Collection<ClusterNode> nodes() {
-        Set<ClusterNode> nodes = new HashSet<>();
-
-        for (int i = 0; i < gridCount(); ++i)
-            nodes.addAll(grid(i).nodes());
-
-        return nodes;
+        return grid(0).nodes();
     }
 }


Mime
View raw message