/hazelcast-client/src/test/java/com/hazelcast/client/HazelcastClientSetTest.java

https://bitbucket.org/gabral6_gmailcom/hazelcast · Java · 268 lines · 230 code · 20 blank · 18 comment · 25 complexity · 9fe0901a629810880a7e36d668911a86 MD5 · raw file

  1. /*
  2. * Copyright (c) 2008-2013, Hazelcast, Inc. All Rights Reserved.
  3. *
  4. * Licensed under the Apache License, Version 2.0 (the "License");
  5. * you may not use this file except in compliance with the License.
  6. * You may obtain a copy of the License at
  7. *
  8. * http://www.apache.org/licenses/LICENSE-2.0
  9. *
  10. * Unless required by applicable law or agreed to in writing, software
  11. * distributed under the License is distributed on an "AS IS" BASIS,
  12. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13. * See the License for the specific language governing permissions and
  14. * limitations under the License.
  15. */
  16. package com.hazelcast.client;
  17. import com.hazelcast.core.ISet;
  18. import com.hazelcast.core.ItemListener;
  19. import org.junit.AfterClass;
  20. import org.junit.Ignore;
  21. import org.junit.Test;
  22. import java.util.*;
  23. import java.util.concurrent.CountDownLatch;
  24. import java.util.concurrent.ExecutorService;
  25. import java.util.concurrent.Executors;
  26. import java.util.concurrent.TimeUnit;
  27. import static org.junit.Assert.*;
  28. public class HazelcastClientSetTest extends HazelcastClientTestBase {
  29. @Test(expected = NullPointerException.class)
  30. public void testAddNull() throws InterruptedException {
  31. HazelcastClient hClient = getHazelcastClient();
  32. ISet<?> set = hClient.getSet("testAddNull");
  33. set.add(null);
  34. }
  35. @Test
  36. public void getSetName() {
  37. HazelcastClient hClient = getHazelcastClient();
  38. ISet<String> set = hClient.getSet("getSetName");
  39. assertEquals("getSetName", set.getName());
  40. }
  41. @Test
  42. public void addRemoveItemListener() throws InterruptedException {
  43. HazelcastClient hClient = getHazelcastClient();
  44. final ISet<String> set = hClient.getSet("addRemoveItemListenerSet");
  45. final CountDownLatch addLatch = new CountDownLatch(2);
  46. final CountDownLatch removeLatch = new CountDownLatch(2);
  47. ItemListener<String> listener = new CountDownItemListener<String>(addLatch, removeLatch);
  48. set.addItemListener(listener, true);
  49. set.add("hello");
  50. set.add("hello");
  51. set.remove("hello");
  52. set.remove("hello");
  53. for (int i = 0; i < 100; i++) {
  54. if (removeLatch.getCount() != 1 || addLatch.getCount() != 1) {
  55. Thread.sleep(50);
  56. } else {
  57. break;
  58. }
  59. }
  60. assertEquals(1, removeLatch.getCount());
  61. assertEquals(1, addLatch.getCount());
  62. set.removeItemListener(listener);
  63. set.add("hello");
  64. set.add("hello");
  65. set.remove("hello");
  66. set.remove("hello");
  67. Thread.sleep(50);
  68. assertEquals(1, addLatch.getCount());
  69. assertEquals(1, removeLatch.getCount());
  70. }
  71. @Test
  72. @Ignore
  73. public void TenTimesAddRemoveItemListener() throws InterruptedException {
  74. ExecutorService ex = Executors.newFixedThreadPool(1);
  75. final int count = 10;
  76. final CountDownLatch latch = new CountDownLatch(count);
  77. ex.execute(new Runnable() {
  78. public void run() {
  79. for (int i = 0; i < count; i++) {
  80. try {
  81. System.out.println("i: " + i);
  82. addRemoveItemListener();
  83. latch.countDown();
  84. } catch (InterruptedException e) {
  85. return;
  86. }
  87. }
  88. }
  89. });
  90. assertTrue(latch.await(20, TimeUnit.SECONDS));
  91. }
  92. @Test
  93. public void destroy() {
  94. HazelcastClient hClient = getHazelcastClient();
  95. ISet<Integer> set = hClient.getSet("destroy");
  96. for (int i = 0; i < 100; i++) {
  97. assertTrue(set.add(i));
  98. }
  99. ISet<Integer> set2 = hClient.getSet("destroy");
  100. assertTrue(set == set2);
  101. assertTrue(set.getId().equals(set2.getId()));
  102. set.destroy();
  103. set2 = hClient.getSet("destroy");
  104. assertFalse(set == set2);
  105. // for(int i=0;i<100;i++){
  106. // assertNull(list2.get(i));
  107. // }
  108. }
  109. @Test
  110. public void add() {
  111. HazelcastClient hClient = getHazelcastClient();
  112. ISet<Integer> set = hClient.getSet("add");
  113. int count = 100;
  114. for (int i = 0; i < count; i++) {
  115. assertTrue(set.add(i));
  116. }
  117. for (int i = 0; i < count; i++) {
  118. assertFalse(set.add(i));
  119. }
  120. assertEquals(count, set.size());
  121. }
  122. @Test
  123. public void contains() {
  124. HazelcastClient hClient = getHazelcastClient();
  125. ISet<Integer> set = hClient.getSet("contains");
  126. int count = 100;
  127. for (int i = 0; i < count; i++) {
  128. set.add(i);
  129. }
  130. for (int i = 0; i < count; i++) {
  131. assertTrue(set.contains(i));
  132. }
  133. for (int i = count; i < 2 * count; i++) {
  134. assertFalse(set.contains(i));
  135. }
  136. }
  137. @Test
  138. public void addAll() {
  139. HazelcastClient hClient = getHazelcastClient();
  140. ISet<Integer> set = hClient.getSet("addAll");
  141. List<Integer> arr = new ArrayList<Integer>();
  142. int count = 100;
  143. for (int i = 0; i < count; i++) {
  144. arr.add(i);
  145. }
  146. assertTrue(set.addAll(arr));
  147. }
  148. @Test
  149. public void containsAll() {
  150. HazelcastClient hClient = getHazelcastClient();
  151. ISet<Integer> set = hClient.getSet("containsAll");
  152. List<Integer> arrList = new ArrayList<Integer>();
  153. int count = 100;
  154. for (int i = 0; i < count; i++) {
  155. arrList.add(i);
  156. }
  157. assertTrue(set.addAll(arrList));
  158. assertTrue(set.containsAll(arrList));
  159. arrList.set((int) count / 2, count + 1);
  160. assertFalse(set.containsAll(arrList));
  161. }
  162. @Test
  163. public void size() {
  164. HazelcastClient hClient = getHazelcastClient();
  165. ISet<Integer> set = hClient.getSet("size");
  166. int count = 100;
  167. assertTrue(set.isEmpty());
  168. for (int i = 0; i < count; i++) {
  169. assertTrue(set.add(i));
  170. }
  171. assertEquals(count, set.size());
  172. for (int i = 0; i < count / 2; i++) {
  173. assertFalse(set.add(i));
  174. }
  175. assertFalse(set.isEmpty());
  176. assertEquals(count, set.size());
  177. }
  178. @Test
  179. public void remove() {
  180. HazelcastClient hClient = getHazelcastClient();
  181. ISet<Integer> set = hClient.getSet("remove");
  182. int count = 100;
  183. assertTrue(set.isEmpty());
  184. for (int i = 0; i < count; i++) {
  185. assertTrue(set.add(i));
  186. }
  187. assertEquals(count, set.size());
  188. for (int i = 0; i < count; i++) {
  189. assertTrue(set.remove((Object) i));
  190. }
  191. assertTrue(set.isEmpty());
  192. for (int i = count; i < 2 * count; i++) {
  193. assertFalse(set.remove((Object) i));
  194. }
  195. }
  196. @Test
  197. public void clear() {
  198. HazelcastClient hClient = getHazelcastClient();
  199. ISet<Integer> set = hClient.getSet("clear");
  200. int count = 100;
  201. assertTrue(set.isEmpty());
  202. for (int i = 0; i < count; i++) {
  203. assertTrue(set.add(i));
  204. }
  205. assertEquals(count, set.size());
  206. set.clear();
  207. assertTrue(set.isEmpty());
  208. }
  209. @Test
  210. public void removeAll() {
  211. HazelcastClient hClient = getHazelcastClient();
  212. ISet<Integer> set = hClient.getSet("removeAll");
  213. List<Integer> arrList = new ArrayList<Integer>();
  214. int count = 100;
  215. for (int i = 0; i < count; i++) {
  216. arrList.add(i);
  217. }
  218. assertTrue(set.addAll(arrList));
  219. assertTrue(set.removeAll(arrList));
  220. assertFalse(set.removeAll(arrList.subList(0, count / 10)));
  221. }
  222. @Test
  223. public void iterate() {
  224. HazelcastClient hClient = getHazelcastClient();
  225. ISet<Integer> set = hClient.getSet("iterate");
  226. set.add(1);
  227. set.add(2);
  228. set.add(2);
  229. set.add(3);
  230. assertEquals(3, set.size());
  231. Map<Integer, Integer> counter = new HashMap<Integer, Integer>();
  232. counter.put(1, 1);
  233. counter.put(2, 1);
  234. counter.put(3, 1);
  235. for (Iterator<Integer> iterator = set.iterator(); iterator.hasNext(); ) {
  236. Integer integer = iterator.next();
  237. counter.put(integer, counter.get(integer) - 1);
  238. iterator.remove();
  239. }
  240. assertEquals(Integer.valueOf(0), counter.get(1));
  241. assertEquals(Integer.valueOf(0), counter.get(2));
  242. assertEquals(Integer.valueOf(0), counter.get(3));
  243. assertTrue(set.isEmpty());
  244. }
  245. @AfterClass
  246. public static void shutdown() {
  247. }
  248. }