*/
package org.opendaylight.yangtools.triemap;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+
import java.util.Map;
import org.junit.Test;
public class TestCNodeFlagCollision {
@Test
public void testCNodeFlagCollision () {
- final Map<Object, Object> map = new TrieMap<> ();
- final Integer z15169 = Integer.valueOf (15169);
- final Integer z28336 = Integer.valueOf (28336);
+ final Map<Integer, Object> map = new TrieMap<>();
+ final Integer z15169 = Integer.valueOf(15169);
+ final Integer z28336 = Integer.valueOf(28336);
- TestHelper.assertTrue (null == map.get (z15169));
- TestHelper.assertTrue (null == map.get (z28336));
+ assertNull(map.get(z15169));
+ assertNull(map.get(z28336));
- map.put (z15169, z15169);
- TestHelper.assertTrue (null != map.get (z15169));
- TestHelper.assertTrue (null == map.get (z28336));
+ map.put(z15169, z15169);
+ assertSame(z15169, map.get(z15169));
+ assertNull(map.get(z28336));
map.put (z28336, z28336);
- TestHelper.assertTrue (null != map.get (z15169));
- TestHelper.assertTrue (null != map.get (z28336));
+ assertSame(z15169, map.get(z15169));
+ assertSame(z28336, map.get(z28336));
map.remove (z15169);
- TestHelper.assertTrue (null == map.get (z15169));
- TestHelper.assertTrue (null != map.get (z28336));
+ assertNull(map.get(z15169));
+ assertSame(z28336, map.get(z28336));
map.remove (z28336);
- TestHelper.assertTrue (null == map.get (z15169));
- TestHelper.assertTrue (null == map.get (z28336));
+ assertNull(map.get(z15169));
+ assertNull(map.get(z28336));
}
}
*/
package org.opendaylight.yangtools.triemap;
+import static org.junit.Assert.assertSame;
+
import java.util.Map;
import org.junit.Test;
@Test
public void testCNodeInsertionIncorrectOrder () {
- final Map<Object, Object> map = new TrieMap<> ();
- final Integer z3884 = Integer.valueOf (3884);
- final Integer z4266 = Integer.valueOf (4266);
- map.put (z3884, z3884);
- TestHelper.assertTrue (null != map.get (z3884));
+ final Map<Integer, Integer> map = new TrieMap<>();
+ final Integer z3884 = Integer.valueOf(3884);
+ final Integer z4266 = Integer.valueOf(4266);
+ map.put(z3884, z3884);
+ assertSame(z3884, map.get(z3884));
- map.put (z4266, z4266);
- TestHelper.assertTrue (null != map.get (z3884));
- TestHelper.assertTrue (null != map.get (z4266));
+ map.put(z4266, z4266);
+ assertSame(z3884, map.get(z3884));
+ assertSame(z4266, map.get(z4266));
}
}
*/
package org.opendaylight.yangtools.triemap;
+import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
@Test
public void testConcurrentMapPutIfAbsent () {
- final ConcurrentMap<Object, Object> map = new TrieMap<> ();
+ final ConcurrentMap<Object, Object> map = new TrieMap<>();
for (int i = 0; i < COUNT; i++) {
- TestHelper.assertTrue (null == map.putIfAbsent (i, i));
- TestHelper.assertTrue (Integer.valueOf (i).equals (map.putIfAbsent (i, i)));
+ assertNull(map.putIfAbsent (i, i));
+ assertEquals(Integer.valueOf(i), map.putIfAbsent(i, i));
}
}
*/
package org.opendaylight.yangtools.triemap;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+
import org.junit.Test;
public class TestHashCollisions {
@Test
public void testHashCollisions () {
- final TrieMap<Object, Object> bt = new TrieMap<> ();
-
- insertStrings (bt);
- insertChars (bt);
- insertInts (bt);
- insertBytes (bt);
-
- removeStrings (bt);
- removeChars (bt);
- removeInts (bt);
- removeBytes (bt);
-
- insertStrings (bt);
- insertInts (bt);
- insertBytes (bt);
- insertChars (bt);
-
- removeBytes (bt);
- removeStrings (bt);
- removeChars (bt);
- removeInts (bt);
-
- insertStrings (bt);
- insertInts (bt);
- insertBytes (bt);
- insertChars (bt);
-
- removeStrings (bt);
- removeChars (bt);
- removeInts (bt);
- removeBytes (bt);
-
- insertStrings (bt);
- insertInts (bt);
- insertBytes (bt);
- insertChars (bt);
-
- removeChars (bt);
- removeInts (bt);
- removeBytes (bt);
- removeStrings (bt);
-
- insertStrings (bt);
- insertInts (bt);
- insertBytes (bt);
- insertChars (bt);
-
- removeInts (bt);
- removeBytes (bt);
- removeStrings (bt);
- removeChars (bt);
-
- System.out.println (bt);
+ final TrieMap<Object, Object> bt = new TrieMap<>();
+
+ insertStrings(bt);
+ insertChars(bt);
+ insertInts(bt);
+ insertBytes(bt);
+
+ removeStrings(bt);
+ removeChars(bt);
+ removeInts(bt);
+ removeBytes(bt);
+
+ insertStrings(bt);
+ insertInts(bt);
+ insertBytes(bt);
+ insertChars(bt);
+
+ removeBytes(bt);
+ removeStrings(bt);
+ removeChars(bt);
+ removeInts(bt);
+
+ insertStrings(bt);
+ insertInts(bt);
+ insertBytes(bt);
+ insertChars(bt);
+
+ removeStrings(bt);
+ removeChars(bt);
+ removeInts(bt);
+ removeBytes(bt);
+
+ insertStrings(bt);
+ insertInts(bt);
+ insertBytes(bt);
+ insertChars(bt);
+
+ removeChars(bt);
+ removeInts(bt);
+ removeBytes(bt);
+ removeStrings(bt);
+
+ insertStrings(bt);
+ insertInts(bt);
+ insertBytes(bt);
+ insertChars(bt);
+
+ removeInts(bt);
+ removeBytes(bt);
+ removeStrings(bt);
+ removeChars(bt);
}
private static void insertChars (final TrieMap<Object, Object> bt) {
- TestHelper.assertEquals (null, bt.put ('a', 'a'));
- TestHelper.assertEquals (null, bt.put ('b', 'b'));
- TestHelper.assertEquals (null, bt.put ('c', 'c'));
- TestHelper.assertEquals (null, bt.put ('d', 'd'));
- TestHelper.assertEquals (null, bt.put ('e', 'e'));
-
- TestHelper.assertEquals ('a', bt.put ('a', 'a'));
- TestHelper.assertEquals ('b', bt.put ('b', 'b'));
- TestHelper.assertEquals ('c', bt.put ('c', 'c'));
- TestHelper.assertEquals ('d', bt.put ('d', 'd'));
- TestHelper.assertEquals ('e', bt.put ('e', 'e'));
+ assertNull(bt.put('a', 'a'));
+ assertNull(bt.put('b', 'b'));
+ assertNull(bt.put('c', 'c'));
+ assertNull(bt.put('d', 'd'));
+ assertNull(bt.put('e', 'e'));
+
+ assertEquals('a', bt.put('a', 'a'));
+ assertEquals('b', bt.put('b', 'b'));
+ assertEquals('c', bt.put('c', 'c'));
+ assertEquals('d', bt.put('d', 'd'));
+ assertEquals('e', bt.put('e', 'e'));
}
private static void insertStrings (final TrieMap<Object, Object> bt) {
- TestHelper.assertEquals (null, bt.put ("a", "a"));
- TestHelper.assertEquals (null, bt.put ("b", "b"));
- TestHelper.assertEquals (null, bt.put ("c", "c"));
- TestHelper.assertEquals (null, bt.put ("d", "d"));
- TestHelper.assertEquals (null, bt.put ("e", "e"));
-
- TestHelper.assertEquals ("a", bt.put ("a", "a"));
- TestHelper.assertEquals ("b", bt.put ("b", "b"));
- TestHelper.assertEquals ("c", bt.put ("c", "c"));
- TestHelper.assertEquals ("d", bt.put ("d", "d"));
- TestHelper.assertEquals ("e", bt.put ("e", "e"));
+ assertNull(bt.put("a", "a"));
+ assertNull(bt.put("b", "b"));
+ assertNull(bt.put("c", "c"));
+ assertNull(bt.put("d", "d"));
+ assertNull(bt.put("e", "e"));
+
+ assertEquals("a", bt.put("a", "a"));
+ assertEquals("b", bt.put("b", "b"));
+ assertEquals("c", bt.put("c", "c"));
+ assertEquals("d", bt.put("d", "d"));
+ assertEquals("e", bt.put("e", "e"));
}
private static void insertBytes (final TrieMap<Object, Object> bt) {
for (byte i = 0; i < 128 && i >= 0; i++) {
- final Byte bigB = Byte.valueOf (i);
- TestHelper.assertEquals (null, bt.put (bigB, bigB));
- TestHelper.assertEquals (bigB, bt.put (bigB, bigB));
+ final Byte bigB = Byte.valueOf(i);
+ assertNull(bt.put(bigB, bigB));
+ assertEquals(bigB, bt.put(bigB, bigB));
}
}
private static void insertInts (final TrieMap<Object, Object> bt) {
for (int i = 0; i < 128; i++) {
- final Integer bigI = Integer.valueOf (i);
- TestHelper.assertEquals (null, bt.put (bigI, bigI));
- TestHelper.assertEquals (bigI, bt.put (bigI, bigI));
+ final Integer bigI = Integer.valueOf(i);
+ assertNull(bt.put(bigI, bigI));
+ assertEquals(bigI, bt.put(bigI, bigI));
}
}
private static void removeChars (final TrieMap<Object, Object> bt) {
- TestHelper.assertTrue (null != bt.lookup ('a'));
- TestHelper.assertTrue (null != bt.lookup ('b'));
- TestHelper.assertTrue (null != bt.lookup ('c'));
- TestHelper.assertTrue (null != bt.lookup ('d'));
- TestHelper.assertTrue (null != bt.lookup ('e'));
-
- TestHelper.assertTrue (null != bt.remove ('a'));
- TestHelper.assertTrue (null != bt.remove ('b'));
- TestHelper.assertTrue (null != bt.remove ('c'));
- TestHelper.assertTrue (null != bt.remove ('d'));
- TestHelper.assertTrue (null != bt.remove ('e'));
-
- TestHelper.assertFalse (null != bt.remove ('a'));
- TestHelper.assertFalse (null != bt.remove ('b'));
- TestHelper.assertFalse (null != bt.remove ('c'));
- TestHelper.assertFalse (null != bt.remove ('d'));
- TestHelper.assertFalse (null != bt.remove ('e'));
-
- TestHelper.assertTrue (null == bt.lookup ('a'));
- TestHelper.assertTrue (null == bt.lookup ('b'));
- TestHelper.assertTrue (null == bt.lookup ('c'));
- TestHelper.assertTrue (null == bt.lookup ('d'));
- TestHelper.assertTrue (null == bt.lookup ('e'));
+ assertNotNull(bt.lookup('a'));
+ assertNotNull(bt.lookup('b'));
+ assertNotNull(bt.lookup('c'));
+ assertNotNull(bt.lookup('d'));
+ assertNotNull(bt.lookup('e'));
+
+ assertNotNull(bt.remove('a'));
+ assertNotNull(bt.remove('b'));
+ assertNotNull(bt.remove('c'));
+ assertNotNull(bt.remove('d'));
+ assertNotNull(bt.remove('e'));
+
+ assertNull(bt.remove('a'));
+ assertNull(bt.remove('b'));
+ assertNull(bt.remove('c'));
+ assertNull(bt.remove('d'));
+ assertNull(bt.remove('e'));
+
+ assertNull(bt.lookup('a'));
+ assertNull(bt.lookup('b'));
+ assertNull(bt.lookup('c'));
+ assertNull(bt.lookup('d'));
+ assertNull(bt.lookup('e'));
}
private static void removeStrings (final TrieMap<Object, Object> bt) {
- TestHelper.assertTrue (null != bt.lookup ("a"));
- TestHelper.assertTrue (null != bt.lookup ("b"));
- TestHelper.assertTrue (null != bt.lookup ("c"));
- TestHelper.assertTrue (null != bt.lookup ("d"));
- TestHelper.assertTrue (null != bt.lookup ("e"));
-
- TestHelper.assertTrue (null != bt.remove ("a"));
- TestHelper.assertTrue (null != bt.remove ("b"));
- TestHelper.assertTrue (null != bt.remove ("c"));
- TestHelper.assertTrue (null != bt.remove ("d"));
- TestHelper.assertTrue (null != bt.remove ("e"));
-
- TestHelper.assertFalse (null != bt.remove ("a"));
- TestHelper.assertFalse (null != bt.remove ("b"));
- TestHelper.assertFalse (null != bt.remove ("c"));
- TestHelper.assertFalse (null != bt.remove ("d"));
- TestHelper.assertFalse (null != bt.remove ("e"));
-
- TestHelper.assertTrue (null == bt.lookup ("a"));
- TestHelper.assertTrue (null == bt.lookup ("b"));
- TestHelper.assertTrue (null == bt.lookup ("c"));
- TestHelper.assertTrue (null == bt.lookup ("d"));
- TestHelper.assertTrue (null == bt.lookup ("e"));
+ assertNotNull(bt.lookup("a"));
+ assertNotNull(bt.lookup("b"));
+ assertNotNull(bt.lookup("c"));
+ assertNotNull(bt.lookup("d"));
+ assertNotNull(bt.lookup("e"));
+
+ assertNotNull(bt.remove("a"));
+ assertNotNull(bt.remove("b"));
+ assertNotNull(bt.remove("c"));
+ assertNotNull(bt.remove("d"));
+ assertNotNull(bt.remove("e"));
+
+ assertNull(bt.remove("a"));
+ assertNull(bt.remove("b"));
+ assertNull(bt.remove("c"));
+ assertNull(bt.remove("d"));
+ assertNull(bt.remove("e"));
+
+ assertNull(bt.lookup("a"));
+ assertNull(bt.lookup("b"));
+ assertNull(bt.lookup("c"));
+ assertNull(bt.lookup("d"));
+ assertNull(bt.lookup("e"));
}
private static void removeInts (final TrieMap<Object, Object> bt) {
for (int i = 0; i < 128; i++) {
final Integer bigI = Integer.valueOf (i);
- TestHelper.assertTrue (null != bt.lookup (bigI));
- TestHelper.assertTrue (null != bt.remove (bigI));
- TestHelper.assertFalse (null != bt.remove (bigI));
- TestHelper.assertTrue (null == bt.lookup (bigI));
+ assertNotNull(bt.lookup(bigI));
+ assertNotNull(bt.remove(bigI));
+ assertNull(bt.remove(bigI));
+ assertNull(bt.lookup(bigI));
}
}
private static void removeBytes (final TrieMap<Object, Object> bt) {
for (byte i = 0; i < 128 && i >= 0; i++) {
final Byte bigB = Byte.valueOf (i);
- TestHelper.assertTrue (null != bt.lookup (bigB));
- TestHelper.assertTrue (null != bt.remove (bigB));
- TestHelper.assertFalse (null != bt.remove (bigB));
- TestHelper.assertTrue (null == bt.lookup (bigB));
+ assertNotNull(bt.lookup(bigB));
+ assertNotNull(bt.remove(bigB));
+ assertNull(bt.remove(bigB));
+ assertNull(bt.lookup(bigB));
}
}
}
*/
package org.opendaylight.yangtools.triemap;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
import java.util.Map;
import org.junit.Test;
public class TestHashCollisionsRemove {
+ private static final int COUNT = 50000;
+
@Test
public void testHashCollisionsRemove() {
- final Map<Object, Object> bt = new TrieMap<> ();
- int count = 50000;
- for (int j = 0; j < count; j++) {
- final Object[] objects = TestMultiThreadMapIterator.getObjects (j);
- for (final Object o : objects) {
- bt.put (o, o);
+ final Map<Object, Object> bt = new TrieMap<>();
+
+ for (int j = 0; j < COUNT; j++) {
+ for (final Object o : TestMultiThreadMapIterator.getObjects(j)) {
+ bt.put(o, o);
}
}
- for (int j = 0; j < count; j++) {
- final Object[] objects = TestMultiThreadMapIterator.getObjects (j);
- for (final Object o : objects) {
- bt.remove (o);
+ for (int j = 0; j < COUNT; j++) {
+ for (final Object o : TestMultiThreadMapIterator.getObjects(j)) {
+ bt.remove(o);
}
}
- TestHelper.assertEquals (0, bt.size ());
- TestHelper.assertTrue (bt.isEmpty ());
+ assertEquals(0, bt.size());
+ assertTrue(bt.isEmpty());
}
}
*/
package org.opendaylight.yangtools.triemap;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import org.junit.Test;
public class TestHashCollisionsRemoveIterator {
+ private static final int COUNT = 50000;
+
@Test
public void testHashCollisionsRemoveIterator () {
- final Map<Object, Object> bt = new TrieMap<> ();
- int count = 50000;
- for (int j = 0; j < count; j++) {
- bt.put (Integer.valueOf (j), Integer.valueOf (j));
+ final Map<Object, Object> bt = new TrieMap<>();
+ for (int j = 0; j < COUNT; j++) {
+ bt.put(Integer.valueOf(j), Integer.valueOf(j));
}
- final Collection<Object> list = new ArrayList <> ();
- for (final Iterator<Map.Entry<Object, Object>> i = bt.entrySet ().iterator (); i.hasNext ();) {
- final Entry<Object, Object> e = i.next ();
- final Object key = e.getKey ();
- list.add (key);
- i.remove ();
+ final Collection<Object> list = new ArrayList<>(COUNT);
+ final Iterator<Entry<Object, Object>> it = bt.entrySet().iterator();
+ while (it.hasNext()) {
+ list.add(it.next().getKey());
+ it.remove();
}
- TestHelper.assertEquals (0, bt.size ());
- TestHelper.assertTrue (bt.isEmpty ());
+ assertEquals(0, bt.size());
+ assertTrue(bt.isEmpty());
+ assertEquals(COUNT, list.size());
}
}
+++ /dev/null
-/*
- * (C) Copyright 2016 Pantheon Technologies, s.r.o. and others.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.opendaylight.yangtools.triemap;
-
-import org.junit.Assert;
-
-public class TestHelper {
-
- public static void assertEquals (final long expected, final long found) {
- Assert.assertEquals (expected, found);
- }
-
- public static void assertEquals (final int expected, final int found) {
- Assert.assertEquals (expected, found);
- }
-
- public static void assertEquals (final Object expected, final Object found) {
- Assert.assertEquals (expected, found);
- }
-
- public static void assertTrue (final boolean found) {
- Assert.assertTrue (found);
- }
-
- public static void assertFalse (final boolean found) {
- Assert.assertFalse (found);
- }
-
-}
*/
package org.opendaylight.yangtools.triemap;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+
import org.junit.Test;
public class TestInsert {
@Test
public void testInsert () {
- final TrieMap<Object, Object> bt = new TrieMap<> ();
- TestHelper.assertEquals (null, bt.put ("a", "a"));
- TestHelper.assertEquals (null, bt.put ("b", "b"));
- TestHelper.assertEquals (null, bt.put ("c", "b"));
- TestHelper.assertEquals (null, bt.put ("d", "b"));
- TestHelper.assertEquals (null, bt.put ("e", "b"));
+ final TrieMap<Object, Object> bt = new TrieMap<>();
+ assertNull(bt.put("a", "a"));
+ assertNull(bt.put("b", "b"));
+ assertNull(bt.put("c", "b"));
+ assertNull(bt.put("d", "b"));
+ assertNull(bt.put("e", "b"));
for (int i = 0; i < 10000; i++) {
- TestHelper.assertEquals (null, bt.put (Integer.valueOf (i), Integer.valueOf (i)));
- final Object lookup = bt.lookup (Integer.valueOf (i));
- TestHelper.assertEquals (Integer.valueOf (i), lookup);
+ assertNull(bt.put(Integer.valueOf (i), Integer.valueOf(i)));
+ final Object lookup = bt.lookup(Integer.valueOf(i));
+ assertEquals(Integer.valueOf(i), lookup);
}
- bt.toString ();
+ bt.toString();
}
}
*/
package org.opendaylight.yangtools.triemap;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
public class TestMapIterator {
@Test
public void testMapIterator () {
- for (int i = 0; i < 60 * 1000; i+= 400 + new Random ().nextInt (400)) {
- System.out.println (i);
- final Map<Integer, Integer> bt = new TrieMap <> ();
+ final Random random = new Random();
+
+ for (int i = 0; i < 60 * 1000; i+= 400 + random.nextInt(400)) {
+ final Map<Integer, Integer> bt = new TrieMap <>();
for (int j = 0; j < i; j++) {
- TestHelper.assertEquals (null, bt.put (Integer.valueOf (j), Integer.valueOf (j)));
+ assertNull(bt.put(Integer.valueOf(j), Integer.valueOf(j)));
}
int count = 0;
- final Set<Integer> set = new HashSet<> ();
- for (final Map.Entry<Integer, Integer> e : bt.entrySet ()) {
- set.add (e.getKey ());
+ final Set<Integer> set = new HashSet<>();
+ for (final Entry<Integer, Integer> e : bt.entrySet()) {
+ set.add(e.getKey());
count++;
}
for (final Integer j : set) {
- TestHelper.assertTrue (bt.containsKey (j));
+ assertTrue(bt.containsKey(j));
}
- for (final Integer j : bt.keySet ()) {
- TestHelper.assertTrue (set.contains (j));
+ for (final Integer j : bt.keySet()) {
+ assertTrue(set.contains(j));
}
- TestHelper.assertEquals (i, count);
- TestHelper.assertEquals (i, bt.size ());
+ assertEquals(i, count);
+ assertEquals(i, bt.size());
- for (Entry<Integer, Integer> e : bt.entrySet ()) {
- TestHelper.assertTrue (e.getValue () == bt.get (e.getKey ()));
- e.setValue (e.getValue () + 1);
- TestHelper.assertTrue (e.getValue () == e.getKey () + 1);
- TestHelper.assertTrue (e.getValue () == bt.get (e.getKey ()));
- e.setValue (e.getValue () - 1);
+ for (Entry<Integer, Integer> e : bt.entrySet()) {
+ assertSame(e.getValue(), bt.get(e.getKey()));
+ e.setValue(e.getValue() + 1);
+ assertEquals((Object)e.getValue(), e.getKey () + 1);
+ assertEquals(e.getValue(), bt.get(e.getKey()));
+ e.setValue(e.getValue() - 1);
}
- for (final Iterator<Integer> iter = bt.keySet ().iterator (); iter.hasNext ();) {
- final Integer k = iter.next ();
- TestHelper.assertTrue (bt.containsKey (k));
- iter.remove ();
- TestHelper.assertFalse (bt.containsKey (k));
+ final Iterator<Integer> it = bt.keySet().iterator();
+ while(it.hasNext()) {
+ final Integer k = it.next ();
+ assertTrue(bt.containsKey(k));
+ it.remove();
+ assertFalse(bt.containsKey(k));
}
- TestHelper.assertEquals (0, bt.size ());
- TestHelper.assertTrue (bt.isEmpty ());
+ assertEquals(0, bt.size ());
+ assertTrue(bt.isEmpty ());
}
}
}
*/
package org.opendaylight.yangtools.triemap;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
import java.util.Map;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class TestMultiThreadAddDelete {
private static final int RETRIES = 1;
private static final int N_THREADS = 7;
- private static final int COUNT = 50 * 1000;
+ private static final int COUNT = 50 * 1000;
@Test
- public void testMultiThreadAddDelete () {
+ public void testMultiThreadAddDelete () throws InterruptedException {
for (int j = 0; j < RETRIES; j++) {
- final Map<Object, Object> bt = new TrieMap <> ();
+ final Map<Object, Object> bt = new TrieMap<>();
{
- final ExecutorService es = Executors.newFixedThreadPool (N_THREADS);
+ final ExecutorService es = Executors.newFixedThreadPool(N_THREADS);
for (int i = 0; i < N_THREADS; i++) {
final int threadNo = i;
- es.execute (new Runnable () {
- @Override
- public void run () {
- for (int j = 0; j < COUNT; j++) {
- if (j % N_THREADS == threadNo) {
- bt.put (Integer.valueOf (j), Integer.valueOf (j));
- }
+ es.execute(() -> {
+ for (int k = 0; k < COUNT; k++) {
+ if (k % N_THREADS == threadNo) {
+ bt.put(Integer.valueOf(k), Integer.valueOf(k));
}
}
});
}
es.shutdown ();
- try {
- es.awaitTermination (3600L, TimeUnit.SECONDS);
- } catch (final InterruptedException e) {
- e.printStackTrace ();
- }
+ es.awaitTermination(5, TimeUnit.MINUTES);
}
- TestHelper.assertEquals (COUNT, bt.size ());
- TestHelper.assertFalse (bt.isEmpty ());
+ assertEquals(COUNT, bt.size());
+ assertFalse(bt.isEmpty());
{
- final ExecutorService es = Executors.newFixedThreadPool (N_THREADS);
+ final ExecutorService es = Executors.newFixedThreadPool(N_THREADS);
for (int i = 0; i < N_THREADS; i++) {
final int threadNo = i;
- es.execute (new Runnable () {
- @Override
- public void run () {
- for (int j = 0; j < COUNT; j++) {
- if (j % N_THREADS == threadNo) {
- bt.remove (Integer.valueOf (j));
- }
+ es.execute (() -> {
+ for (int k = 0; k < COUNT; k++) {
+ if (k % N_THREADS == threadNo) {
+ bt.remove (Integer.valueOf (k));
}
}
});
}
es.shutdown ();
- try {
- es.awaitTermination (3600L, TimeUnit.SECONDS);
- } catch (final InterruptedException e) {
- e.printStackTrace ();
- }
+ es.awaitTermination(5, TimeUnit.MINUTES);
}
- TestHelper.assertEquals (0, bt.size ());
- TestHelper.assertTrue (bt.isEmpty ());
+ assertEquals(0, bt.size ());
+ assertTrue(bt.isEmpty());
{
final ExecutorService es = Executors.newFixedThreadPool (N_THREADS);
});
}
es.shutdown ();
- try {
- es.awaitTermination (3600L, TimeUnit.SECONDS);
- } catch (final InterruptedException e) {
- e.printStackTrace ();
- }
+ es.awaitTermination(5, TimeUnit.MINUTES);
}
- TestHelper.assertEquals (0, bt.size ());
- if (!bt.isEmpty ()) {
- System.out.println ();
- }
- TestHelper.assertTrue (bt.isEmpty ());
+ assertEquals(0, bt.size());
+ assertTrue(bt.isEmpty());
}
}
}
*/
package org.opendaylight.yangtools.triemap;
+import static org.junit.Assert.assertEquals;
+
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
public class TestMultiThreadInserts {
@Test
- public void testMultiThreadInserts () {
+ public void testMultiThreadInserts () throws InterruptedException{
final int nThreads = 2;
- final ExecutorService es = Executors.newFixedThreadPool (nThreads);
- final TrieMap<Object, Object> bt = new TrieMap<> ();
+ final ExecutorService es = Executors.newFixedThreadPool(nThreads);
+ final TrieMap<Object, Object> bt = new TrieMap<>();
for (int i = 0; i < nThreads; i++) {
final int threadNo = i;
- es.execute (new Runnable () {
- @Override
- public void run () {
- for (int j = 0; j < 500 * 1000; j++) {
- if (j % nThreads == threadNo) {
- bt.put (Integer.valueOf (j), Integer.valueOf (j));
- }
+ es.execute (() -> {
+ for (int j = 0; j < 500 * 1000; j++) {
+ if (j % nThreads == threadNo) {
+ bt.put (Integer.valueOf (j), Integer.valueOf (j));
}
}
});
}
es.shutdown ();
- try {
- es.awaitTermination (3600L, TimeUnit.SECONDS);
- } catch (final InterruptedException e) {
- e.printStackTrace ();
- }
+ es.awaitTermination(5, TimeUnit.MINUTES);
for (int j = 0; j < 500 * 1000; j++) {
final Object lookup = bt.lookup (Integer.valueOf (j));
- TestHelper.assertEquals (Integer.valueOf (j), lookup);
+ assertEquals(Integer.valueOf(j), lookup);
}
}
}
*/
package org.opendaylight.yangtools.triemap;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
-import java.util.LinkedList;
import java.util.Map;
import java.util.Map.Entry;
import java.util.concurrent.ConcurrentHashMap;
private static final int NTHREADS = 7;
@Test
- public void testMultiThreadMapIterator () {
- final Map<Object, Object> bt = new TrieMap<> ();
+ public void testMultiThreadMapIterator () throws InterruptedException {
+ final Map<Object, Object> bt = new TrieMap<>();
for (int j = 0; j < 50 * 1000; j++) {
- final Object[] objects = getObjects (j);
- for (final Object o : objects) {
+ for (final Object o : getObjects(j)) {
bt.put (o, o);
}
}
- System.out.println ("Size of initialized map is " + bt.size ());
- int count = 0;
+ // System.out.println ("Size of initialized map is " + bt.size ());
+ int count = 0;
{
- final ExecutorService es = Executors.newFixedThreadPool (NTHREADS);
+ final ExecutorService es = Executors.newFixedThreadPool(NTHREADS);
for (int i = 0; i < NTHREADS; i++) {
final int threadNo = i;
- es.execute (new Runnable () {
- @Override
- public void run () {
- for (Entry<Object, Object> e : bt.entrySet ()) {
- if (accepts (threadNo, NTHREADS, e.getKey ())) {
- String newValue = "TEST:" + threadNo;
- e.setValue (newValue);
- }
+ es.execute(() -> {
+ for (Entry<Object, Object> e : bt.entrySet()) {
+ if (accepts(threadNo, NTHREADS, e.getKey())) {
+ String newValue = "TEST:" + threadNo;
+ e.setValue(newValue);
}
}
});
}
- es.shutdown ();
- try {
- es.awaitTermination (3600L, TimeUnit.SECONDS);
- } catch (final InterruptedException e) {
- e.printStackTrace ();
- }
+ es.shutdown();
+ es.awaitTermination(5, TimeUnit.MINUTES);
}
count = 0;
- for (final Map.Entry<Object, Object> kv : bt.entrySet ()) {
- Object value = kv.getValue ();
- TestHelper.assertTrue (value instanceof String);
+ for (final Map.Entry<Object, Object> kv : bt.entrySet()) {
+ assertTrue(kv.getValue() instanceof String);
count++;
}
- TestHelper.assertEquals (50000 + 2000 + 1000 + 100, count);
-
- final ConcurrentHashMap<Object, Object> removed = new ConcurrentHashMap<> ();
+ assertEquals(50000 + 2000 + 1000 + 100, count);
+ final ConcurrentHashMap<Object, Object> removed = new ConcurrentHashMap<>();
{
- final ExecutorService es = Executors.newFixedThreadPool (NTHREADS);
+ final ExecutorService es = Executors.newFixedThreadPool(NTHREADS);
for (int i = 0; i < NTHREADS; i++) {
final int threadNo = i;
- es.execute (new Runnable () {
- @Override
- public void run () {
- for (final Iterator<Map.Entry<Object, Object>> i = bt.entrySet ().iterator (); i.hasNext ();) {
- final Entry<Object, Object> e = i.next ();
- Object key = e.getKey ();
- if (accepts (threadNo, NTHREADS, key)) {
- if (null == bt.get (key)) {
- System.out.println (key);
- }
- i.remove ();
- if (null != bt.get (key)) {
- System.out.println (key);
- }
- removed.put (key, key);
+ es.execute (() -> {
+ for (final Iterator<Map.Entry<Object, Object>> it = bt.entrySet ().iterator(); it.hasNext();) {
+ final Entry<Object, Object> e = it.next();
+ Object key = e.getKey ();
+ if (accepts (threadNo, NTHREADS, key)) {
+ if (null == bt.get (key)) {
+ // System.out.println (key);
}
+ it.remove();
+ if (null != bt.get (key)) {
+ // System.out.println (key);
+ }
+ removed.put (key, key);
}
}
});
}
- es.shutdown ();
- try {
- es.awaitTermination (3600L, TimeUnit.SECONDS);
- } catch (final InterruptedException e) {
- e.printStackTrace ();
- }
+ es.shutdown();
+ es.awaitTermination(5, TimeUnit.MINUTES);
}
- count = 0;
- for (final Object value : bt.keySet ()) {
- value.toString ();
- count++;
- }
- for (final Object o : bt.keySet ()) {
- if (!removed.contains (bt.get (o))) {
- System.out.println ("Not removed: " + o);
- }
- }
- TestHelper.assertEquals (0, count);
- TestHelper.assertEquals (0, bt.size ());
- TestHelper.assertTrue (bt.isEmpty ());
+ count = 0;
+ for (final Object value : bt.keySet ()) {
+ value.toString ();
+ count++;
+ }
+ for (final Object o : bt.keySet ()) {
+ if (!removed.contains (bt.get (o))) {
+ System.out.println ("Not removed: " + o);
+ }
+ }
+ assertEquals(0, count);
+ assertEquals(0, bt.size ());
+ assertTrue(bt.isEmpty ());
}
protected static boolean accepts (final int threadNo, final int nThreads, final Object key) {
- int val = getKeyValue (key);
- if(val>=0) {
- return val % nThreads == threadNo;
- } else {
- return false;
- }
+ final int val = getKeyValue(key);
+ return val >= 0 ? val % nThreads == threadNo : false;
}
private static int getKeyValue (final Object key) {
- int val = 0;
if (key instanceof Integer) {
- val = ((Integer) key).intValue ();
- }
- else if (key instanceof Character) {
- val = Math.abs (Character.getNumericValue ((Character) key) + 1);
- }
- else if (key instanceof Short) {
- val = ((Short) key).intValue () + 2;
- }
- else if (key instanceof Byte) {
- val = ((Byte) key).intValue () + 3;
+ return ((Integer) key).intValue();
+ } else if (key instanceof Character) {
+ return Math.abs(Character.getNumericValue((Character) key) + 1);
+ } else if (key instanceof Short) {
+ return ((Short) key).intValue() + 2;
+ } else if (key instanceof Byte) {
+ return ((Byte) key).intValue() + 3;
} else {
return -1;
}
- return val;
}
- static Object[] getObjects (final int j) {
- final Collection<Object> results = new LinkedList<> ();
- results.add (Integer.valueOf (j));
+ static Collection<Object> getObjects(final int j) {
+ final Collection<Object> results = new ArrayList<>(4);
+ results.add(Integer.valueOf(j));
if (j < 2000) {
- results.add (Character.valueOf ((char) j));
+ results.add(Character.valueOf((char) j));
}
if (j < 1000) {
- results.add (Short.valueOf ((short) j));
+ results.add(Short.valueOf((short) j));
}
if (j < 100) {
- results.add (Byte.valueOf ((byte) j));
+ results.add(Byte.valueOf((byte) j));
}
- return results.toArray ();
+ return results;
}
}
*/
package org.opendaylight.yangtools.triemap;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+
import java.util.Iterator;
import java.util.Map.Entry;
import org.junit.Before;
*
*/
public class TestReadOnlyAndUpdatableIterators {
- TrieMap<Integer, Integer> bt;
private static final int MAP_SIZE = 200;
+ private TrieMap<Integer, Integer> bt;
+
@Before
public void setUp() {
- bt = new TrieMap <> ();
+ bt = new TrieMap<>();
for (int j = 0; j < MAP_SIZE; j++) {
- TestHelper.assertEquals (null, bt.put (Integer.valueOf (j), Integer.valueOf (j)));
+ assertNull(bt.put(Integer.valueOf(j), Integer.valueOf(j)));
}
}
- @Test
- public void testReadOnlyIterator () {
- Iterator<Entry<Integer, Integer>> it = bt.readOnlyIterator ();
- try {
- it.next().setValue (0);
- // It should have generated an exception, because it is a read-only iterator
- TestHelper.assertFalse (true);
- } catch (Exception e) {
-
- }
- try {
- it.remove ();
- // It should have generated an exception, because it is a read-only iterator
- TestHelper.assertFalse (true);
- } catch (Exception e) {
+ private static void trySet(final Iterator<Entry<Integer, Integer>> it) {
+ it.next().setValue(0);
+ }
- }
+ private static void tryRemove(final Iterator<?> it) {
+ it.next();
+ it.remove();
}
- @Test
- public void testReadOnlySnapshotReadOnlyIterator () {
- TrieMap<Integer, Integer> roSnapshot = bt.readOnlySnapshot ();
- Iterator<Entry<Integer, Integer>> it = roSnapshot.readOnlyIterator ();
- try {
- it.next().setValue (0);
- // It should have generated an exception, because it is a read-only iterator
- TestHelper.assertFalse (true);
- } catch (Exception e) {
+ @Test(expected = UnsupportedOperationException.class)
+ public void testReadOnlyIteratorSet() {
+ trySet(bt.readOnlyIterator());
+ }
- }
- try {
- it.remove ();
- // It should have generated an exception, because it is a read-only iterator
- TestHelper.assertFalse (true);
- } catch (Exception e) {
+ @Test(expected = UnsupportedOperationException.class)
+ public void testReadOnlyIteratorRemove() {
+ tryRemove(bt.readOnlyIterator());
+ }
- }
+ @Test(expected = UnsupportedOperationException.class)
+ public void testReadOnlySnapshotReadOnlyIteratorSet() {
+ trySet(bt.readOnlySnapshot().readOnlyIterator());
}
- @Test
- public void testReadOnlySnapshotIterator () {
- TrieMap<Integer, Integer> roSnapshot = bt.readOnlySnapshot ();
- Iterator<Entry<Integer, Integer>> it = roSnapshot.iterator ();
- try {
- it.next().setValue (0);
- // It should have generated an exception, because it is a read-only iterator
- TestHelper.assertFalse (true);
- } catch (Exception e) {
+ @Test(expected = UnsupportedOperationException.class)
+ public void testReadOnlySnapshotReadOnlyIteratorRemove() {
+ tryRemove(bt.readOnlySnapshot().readOnlyIterator());
+ }
- }
- try {
- it.remove ();
- // It should have generated an exception, because it is a read-only iterator
- TestHelper.assertFalse (true);
- } catch (Exception e) {
+ @Test(expected = UnsupportedOperationException.class)
+ public void testReadOnlySnapshotIteratorSet() {
+ trySet(bt.readOnlySnapshot().iterator());
+ }
- }
+ @Test(expected = UnsupportedOperationException.class)
+ public void testReadOnlySnapshotIteratorRemove() {
+ tryRemove(bt.readOnlySnapshot().iterator());
}
@Test
public void testIterator () {
- Iterator<Entry<Integer, Integer>> it = bt.iterator ();
- try {
- it.next().setValue (0);
- } catch (Exception e) {
- // It should not have generated an exception, because it is a non read-only iterator
- TestHelper.assertFalse (true);
- }
-
- try {
- it.remove ();
- } catch (Exception e) {
- // It should not have generated an exception, because it is a non read-only iterator
- TestHelper.assertFalse (true);
- }
+ Iterator<Entry<Integer, Integer>> it = bt.iterator();
+ it.next().setValue (0);
+ it.remove();
// All changes are done on the original map
- TestHelper.assertEquals (MAP_SIZE - 1, bt.size ());
+ assertEquals(MAP_SIZE - 1, bt.size());
}
@Test
public void testSnapshotIterator () {
- TrieMap<Integer, Integer> snapshot = bt.snapshot ();
- Iterator<Entry<Integer, Integer>> it = snapshot.iterator ();
- try {
- it.next().setValue (0);
- } catch (Exception e) {
- // It should not have generated an exception, because it is a non read-only iterator
- TestHelper.assertFalse (true);
- }
- try {
- it.remove ();
- } catch (Exception e) {
- // It should not have generated an exception, because it is a non read-only iterator
- TestHelper.assertFalse (true);
- }
+ TrieMap<Integer, Integer> snapshot = bt.snapshot();
+ Iterator<Entry<Integer, Integer>> it = snapshot.iterator();
+ it.next().setValue(0);
+ it.remove();
// All changes are done on the snapshot, not on the original map
// Map size should remain unchanged
- TestHelper.assertEquals (MAP_SIZE, bt.size ());
+ assertEquals(MAP_SIZE, bt.size ());
// snapshot size was changed
- TestHelper.assertEquals (MAP_SIZE-1, snapshot.size ());
+ assertEquals(MAP_SIZE-1, snapshot.size ());
}
}
Code Review / yangtools.git / commitdiff