<packaging>pom</packaging>
<modules>
+ <module>triemap</module>
<module>xsd-regex</module>
</modules>
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- vi: set et smarttab sw=4 tabstop=4: -->
+<!--
+ (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.
+-->
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
- <modelVersion>4.0.0</modelVersion>
- <parent>
- <groupId>org.sonatype.oss</groupId>
- <artifactId>oss-parent</artifactId>
- <version>7</version>
- </parent>
- <groupId>com.github.romix</groupId>
- <artifactId>java-concurrent-hash-trie-map</artifactId>
- <version>0.2.23-ODL</version>
- <name>TrieMap</name>
- <description>Java implementation of a concurrent trie hash map from Scala collections library</description>
- <packaging>bundle</packaging>
- <url>https://github.com/romix/java-concurrent-hash-trie-map</url>
- <licenses>
- <license>
- <name>The Apache Software License, Version 2.0</name>
- <url>http://www.apache.org/licenses/LICENSE-2.0.txt</url>
- <distribution>repo</distribution>
- </license>
- </licenses>
- <scm>
- <url>https://github.com/romix/java-concurrent-hash-trie-map</url>
- <connection>scm:git:https://github.com/romix/java-concurrent-hash-trie-map.git</connection>
- <developerConnection>scm:git:https://github.com/romix/java-concurrent-hash-trie-map.git</developerConnection>
- <tag>java-concurrent-hash-trie-map-0.2.23</tag>
- </scm>
- <developers>
- <developer>
- <id>romix</id>
- <name>Roman Levenstein</name>
- <email>romixlev@gmail.com</email>
- </developer>
- </developers>
- <build>
- <plugins>
- <plugin>
- <groupId>org.apache.maven.plugins</groupId>
- <artifactId>maven-compiler-plugin</artifactId>
- <version>2.3.2</version>
- <configuration>
- <source>1.6</source>
- <target>1.6</target>
- <encoding>iso8859-1</encoding>
- </configuration>
- </plugin>
- <plugin>
- <groupId>org.apache.maven.plugins</groupId>
- <artifactId>maven-release-plugin</artifactId>
- <version>2.5</version>
- <configuration>
- <checkModificationExcludes>
- <checkModificationExclude>pom.xml</checkModificationExclude>
- </checkModificationExcludes>
- </configuration>
- </plugin>
- <plugin>
- <groupId>org.apache.felix</groupId>
- <artifactId>maven-bundle-plugin</artifactId>
- <version>2.4.0</version>
- <extensions>true</extensions>
- <configuration>
- <instructions>
- <Bundle-Name>${project.groupId}.${project.artifactId}</Bundle-Name>
- </instructions>
- </configuration>
- </plugin>
- </plugins>
- </build>
- <dependencies>
- <dependency>
- <groupId>junit</groupId>
- <artifactId>junit</artifactId>
- <version>4.9</version>
- <scope>test</scope>
- </dependency>
- </dependencies>
- <distributionManagement>
- <repository>
- <id>sonatype-nexus-staging</id>
- <name>Nexus Staging Repository</name>
- <url>https://oss.sonatype.org/service/local/staging/deploy/maven2/</url>
- </repository>
- <snapshotRepository>
- <id>sonatype-nexus-snapshots</id>
- <name>Nexus Snapshots Repository</name>
- <url>https://oss.sonatype.org/content/repositories/snapshots/</url>
- </snapshotRepository>
- </distributionManagement>
+
+ <parent>
+ <groupId>org.opendaylight.odlparent</groupId>
+ <artifactId>bundle-parent</artifactId>
+ <version>1.8.0-SNAPSHOT</version>
+ <relativePath/>
+ </parent>
+
+ <modelVersion>4.0.0</modelVersion>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>triemap</artifactId>
+ <version>0.9.0-SNAPSHOT</version>
+ <packaging>bundle</packaging>
+
+ <description>Java implementation of a concurrent trie hash map from Scala collections library</description>
+
+ <dependencies>
+ <dependency>
+ <groupId>junit</groupId>
+ <artifactId>junit</artifactId>
+ </dependency>
+ </dependencies>
+
+ <build>
+ <plugins>
+ <plugin>
+ <!-- This project has a different license -->
+ <artifactId>maven-checkstyle-plugin</artifactId>
+ <configuration>
+ <skip>true</skip>
+ </configuration>
+ </plugin>
+ </plugins>
+ </build>
+
+ <licenses>
+ <license>
+ <name>The Apache Software License, Version 2.0</name>
+ <url>http://www.apache.org/licenses/LICENSE-2.0.txt</url>
+ <distribution>repo</distribution>
+ </license>
+ </licenses>
+
+ <!--
+ Maven Site Configuration
+
+ The following configuration is necessary for maven-site-plugin to
+ correctly identify the correct deployment path for OpenDaylight Maven
+ sites.
+ -->
+ <url>${odl.site.url}/${project.groupId}/${stream}/${project.artifactId}/</url>
+
+ <distributionManagement>
+ <site>
+ <id>opendaylight-site</id>
+ <url>${nexus.site.url}/${project.artifactId}/</url>
+ </site>
+ </distributionManagement>
</project>
** |/ **
\* */
-package com.romix.scala.collection.concurrent;
+package org.opendaylight.yangtools.triemap;
** |/ **
\* */
-package com.romix.scala.collection.concurrent;
+package org.opendaylight.yangtools.triemap;
** |/ **
\* */
-package com.romix.scala.collection.concurrent;
+package org.opendaylight.yangtools.triemap;
** |/ **
\* */
-package com.romix.scala.collection.concurrent;
+package org.opendaylight.yangtools.triemap;
-package com.romix.scala.collection.concurrent;
+package org.opendaylight.yangtools.triemap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
-import com.romix.scala.Option;
-
/**
* Mimic immutable ListMap in Scala
*
** |/ **
\* */
-package com.romix.scala.collection.concurrent;
+package org.opendaylight.yangtools.triemap;
import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
-package com.romix.scala;
+package org.opendaylight.yangtools.triemap;
/**
* Mimic None in Scala
*
* @param <V>
*/
-public class None<V> extends Option<V>{
+class None<V> extends Option<V>{
}
-package com.romix.scala;
+package org.opendaylight.yangtools.triemap;
/**
* Mimic Option in Scala
* @param <V>
*/
@SuppressWarnings({"rawtypes", "unchecked"})
-public class Option<V> {
+class Option<V> {
static None none = new None();
public static <V> Option<V> makeOption(V o){
if(o!=null)
-package com.romix.scala.collection.concurrent;
+package org.opendaylight.yangtools.triemap;
import java.util.Map;
* @param <K>
* @param <V>
*/
-public class Pair<K, V> implements Map.Entry<K, V> {
+class Pair<K, V> implements Map.Entry<K, V> {
final K k;
final V v;
-package com.romix.scala;
+package org.opendaylight.yangtools.triemap;
/**
* Mimic Some in Scala
*
* @param <V>
*/
-public class Some<V> extends Option<V>{
+class Some<V> extends Option<V>{
final V value;
public Some(V v) {
value = v;
-package com.romix.scala.collection.concurrent;
+package org.opendaylight.yangtools.triemap;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.Set;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
-import com.romix.scala.None;
-import com.romix.scala.Option;
-import com.romix.scala.Some;
/***
* This is a port of Scala's TrieMap class from the Scala Collections library.
*
- * @author Roman Levenstein <romixlev@gmail.com>
+ * @author Roman Levenstein <romixlev@gmail.com>
*
* @param <K>
* @param <V>
-package com.romix.scala.collection.concurrent;\r
-\r
-import java.util.Map;\r
-\r
-import org.junit.Test;\r
-\r
-public class TestCNodeFlagCollision {\r
- @Test\r
- public void testCNodeFlagCollision () {\r
- final Map<Object, Object> map = new TrieMap<Object, Object> ();\r
- final Integer z15169 = Integer.valueOf (15169);\r
- final Integer z28336 = Integer.valueOf (28336);\r
- \r
- TestHelper.assertTrue (null == map.get (z15169));\r
- TestHelper.assertTrue (null == map.get (z28336));\r
- \r
- map.put (z15169, z15169);\r
- TestHelper.assertTrue (null != map.get (z15169));\r
- TestHelper.assertTrue (null == map.get (z28336));\r
- \r
- map.put (z28336, z28336);\r
- TestHelper.assertTrue (null != map.get (z15169));\r
- TestHelper.assertTrue (null != map.get (z28336));\r
- \r
- map.remove (z15169);\r
- \r
- TestHelper.assertTrue (null == map.get (z15169));\r
- TestHelper.assertTrue (null != map.get (z28336));\r
- \r
- map.remove (z28336);\r
- \r
- TestHelper.assertTrue (null == map.get (z15169));\r
- TestHelper.assertTrue (null == map.get (z28336));\r
- }\r
-}\r
+package org.opendaylight.yangtools.triemap;
+
+import java.util.Map;
+
+import org.junit.Test;
+
+public class TestCNodeFlagCollision {
+ @Test
+ public void testCNodeFlagCollision () {
+ final Map<Object, Object> map = new TrieMap<Object, Object> ();
+ final Integer z15169 = Integer.valueOf (15169);
+ final Integer z28336 = Integer.valueOf (28336);
+
+ TestHelper.assertTrue (null == map.get (z15169));
+ TestHelper.assertTrue (null == map.get (z28336));
+
+ map.put (z15169, z15169);
+ TestHelper.assertTrue (null != map.get (z15169));
+ TestHelper.assertTrue (null == map.get (z28336));
+
+ map.put (z28336, z28336);
+ TestHelper.assertTrue (null != map.get (z15169));
+ TestHelper.assertTrue (null != map.get (z28336));
+
+ map.remove (z15169);
+
+ TestHelper.assertTrue (null == map.get (z15169));
+ TestHelper.assertTrue (null != map.get (z28336));
+
+ map.remove (z28336);
+
+ TestHelper.assertTrue (null == map.get (z15169));
+ TestHelper.assertTrue (null == map.get (z28336));
+ }
+}
-package com.romix.scala.collection.concurrent;\r
-\r
-import java.util.Map;\r
-\r
-import org.junit.Test;\r
-\r
-public class TestCNodeInsertionIncorrectOrder {\r
-\r
- @Test\r
- public void testCNodeInsertionIncorrectOrder () {\r
- final Map<Object, Object> map = new TrieMap<Object, Object> ();\r
- final Integer z3884 = Integer.valueOf (3884);\r
- final Integer z4266 = Integer.valueOf (4266);\r
- map.put (z3884, z3884);\r
- TestHelper.assertTrue (null != map.get (z3884));\r
- \r
- map.put (z4266, z4266);\r
- TestHelper.assertTrue (null != map.get (z3884));\r
- TestHelper.assertTrue (null != map.get (z4266));\r
- }\r
-}\r
+package org.opendaylight.yangtools.triemap;
+
+import java.util.Map;
+
+import org.junit.Test;
+
+public class TestCNodeInsertionIncorrectOrder {
+
+ @Test
+ public void testCNodeInsertionIncorrectOrder () {
+ final Map<Object, Object> map = new TrieMap<Object, Object> ();
+ final Integer z3884 = Integer.valueOf (3884);
+ final Integer z4266 = Integer.valueOf (4266);
+ map.put (z3884, z3884);
+ TestHelper.assertTrue (null != map.get (z3884));
+
+ map.put (z4266, z4266);
+ TestHelper.assertTrue (null != map.get (z3884));
+ TestHelper.assertTrue (null != map.get (z4266));
+ }
+}
-package com.romix.scala.collection.concurrent;\r
-\r
-import java.util.concurrent.ConcurrentMap;\r
-\r
-import org.junit.Test;\r
-\r
-public class TestConcurrentMapPutIfAbsent {\r
- private static final int COUNT = 50*1000;\r
-\r
- @Test\r
- public void testConcurrentMapPutIfAbsent () {\r
- final ConcurrentMap<Object, Object> map = new TrieMap<Object, Object> ();\r
- \r
- for (int i = 0; i < COUNT; i++) {\r
- TestHelper.assertTrue (null == map.putIfAbsent (i, i));\r
- TestHelper.assertTrue (Integer.valueOf (i).equals (map.putIfAbsent (i, i)));\r
- }\r
- }\r
-}\r
+package org.opendaylight.yangtools.triemap;
+
+import java.util.concurrent.ConcurrentMap;
+
+import org.junit.Test;
+
+public class TestConcurrentMapPutIfAbsent {
+ private static final int COUNT = 50*1000;
+
+ @Test
+ public void testConcurrentMapPutIfAbsent () {
+ final ConcurrentMap<Object, Object> map = new TrieMap<Object, Object> ();
+
+ for (int i = 0; i < COUNT; i++) {
+ TestHelper.assertTrue (null == map.putIfAbsent (i, i));
+ TestHelper.assertTrue (Integer.valueOf (i).equals (map.putIfAbsent (i, i)));
+ }
+ }
+}
-package com.romix.scala.collection.concurrent;\r
-\r
-import java.util.concurrent.ConcurrentMap;\r
-\r
-import org.junit.Test;\r
-\r
-public class TestConcurrentMapRemove {\r
- private static final int COUNT = 50*1000;\r
-\r
- @Test\r
- public void testConcurrentMapRemove () {\r
- final ConcurrentMap<Object, Object> map = new TrieMap<Object, Object> ();\r
- \r
- for (int i = 128; i < COUNT; i++) {\r
- TestHelper.assertFalse (map.remove (i, i));\r
- TestHelper.assertTrue (null == map.put (i, i));\r
- TestHelper.assertFalse (map.remove (i, "lol"));\r
- TestHelper.assertTrue (map.containsKey (i));\r
- TestHelper.assertTrue (map.remove (i, i));\r
- TestHelper.assertFalse (map.containsKey (i));\r
- TestHelper.assertTrue (null == map.put (i, i));\r
- }\r
- }\r
-}\r
+package org.opendaylight.yangtools.triemap;
+
+import java.util.concurrent.ConcurrentMap;
+
+import org.junit.Test;
+
+public class TestConcurrentMapRemove {
+ private static final int COUNT = 50*1000;
+
+ @Test
+ public void testConcurrentMapRemove () {
+ final ConcurrentMap<Object, Object> map = new TrieMap<Object, Object> ();
+
+ for (int i = 128; i < COUNT; i++) {
+ TestHelper.assertFalse (map.remove (i, i));
+ TestHelper.assertTrue (null == map.put (i, i));
+ TestHelper.assertFalse (map.remove (i, "lol"));
+ TestHelper.assertTrue (map.containsKey (i));
+ TestHelper.assertTrue (map.remove (i, i));
+ TestHelper.assertFalse (map.containsKey (i));
+ TestHelper.assertTrue (null == map.put (i, i));
+ }
+ }
+}
-package com.romix.scala.collection.concurrent;\r
-\r
-import java.util.concurrent.ConcurrentMap;\r
-\r
-import org.junit.Test;\r
-\r
-public class TestConcurrentMapReplace {\r
- private static final int COUNT = 50*1000;\r
-\r
- @Test\r
- public void testConcurrentMapReplace () {\r
- final ConcurrentMap<Object, Object> map = new TrieMap<Object, Object> ();\r
- \r
- for (int i = 0; i < COUNT; i++) {\r
- TestHelper.assertTrue (null == map.replace (i, "lol"));\r
- TestHelper.assertFalse (map.replace (i, i, "lol2"));\r
- TestHelper.assertTrue (null == map.put (i, i));\r
- TestHelper.assertTrue (Integer.valueOf (i).equals (map.replace (i, "lol")));\r
- TestHelper.assertFalse (map.replace (i, i, "lol2"));\r
- TestHelper.assertTrue (map.replace (i, "lol", i));\r
- }\r
- }\r
-}\r
+package org.opendaylight.yangtools.triemap;
+
+import java.util.concurrent.ConcurrentMap;
+
+import org.junit.Test;
+
+public class TestConcurrentMapReplace {
+ private static final int COUNT = 50*1000;
+
+ @Test
+ public void testConcurrentMapReplace () {
+ final ConcurrentMap<Object, Object> map = new TrieMap<Object, Object> ();
+
+ for (int i = 0; i < COUNT; i++) {
+ TestHelper.assertTrue (null == map.replace (i, "lol"));
+ TestHelper.assertFalse (map.replace (i, i, "lol2"));
+ TestHelper.assertTrue (null == map.put (i, i));
+ TestHelper.assertTrue (Integer.valueOf (i).equals (map.replace (i, "lol")));
+ TestHelper.assertFalse (map.replace (i, i, "lol2"));
+ TestHelper.assertTrue (map.replace (i, "lol", i));
+ }
+ }
+}
-package com.romix.scala.collection.concurrent;\r
-\r
-import org.junit.Test;\r
-\r
-\r
-public class TestDelete {\r
- @Test\r
- public void testDelete () {\r
- final TrieMap<Object, Object> bt = new TrieMap<Object, Object> ();\r
-\r
- for (int i = 0; i < 10000; i++) {\r
- TestHelper.assertEquals (null, bt.put (Integer.valueOf (i), Integer.valueOf (i)));\r
- final Object lookup = bt.lookup (Integer.valueOf (i));\r
- TestHelper.assertEquals (Integer.valueOf (i), lookup);\r
- }\r
- \r
- checkAddInsert (bt, 536);\r
- checkAddInsert (bt, 4341);\r
- checkAddInsert (bt, 8437);\r
- \r
- for (int i = 0; i < 10000; i++) {\r
- boolean removed = null != bt.remove(Integer.valueOf (i));\r
- TestHelper.assertEquals (Boolean.TRUE, Boolean.valueOf (removed));\r
- final Object lookup = bt.lookup (Integer.valueOf (i));\r
- TestHelper.assertEquals (null, lookup);\r
- }\r
-\r
- bt.toString ();\r
- }\r
-\r
- private static void checkAddInsert (final TrieMap<Object, Object> bt, int k) {\r
- final Integer v = Integer.valueOf (k);\r
- bt.remove (v);\r
- Object foundV = bt.lookup (v);\r
- TestHelper.assertEquals (null, foundV);\r
- TestHelper.assertEquals (null, bt.put (v, v));\r
- foundV = bt.lookup (v);\r
- TestHelper.assertEquals (v, foundV);\r
- \r
- TestHelper.assertEquals (v, bt.put (v, Integer.valueOf (-1)));\r
- TestHelper.assertEquals (Integer.valueOf (-1), bt.put (v, v));\r
- }\r
-}\r
+package org.opendaylight.yangtools.triemap;
+
+import org.junit.Test;
+
+public class TestDelete {
+ @Test
+ public void testDelete () {
+ final TrieMap<Object, Object> bt = new TrieMap<Object, Object> ();
+
+ 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);
+ }
+
+ checkAddInsert (bt, 536);
+ checkAddInsert (bt, 4341);
+ checkAddInsert (bt, 8437);
+
+ for (int i = 0; i < 10000; i++) {
+ boolean removed = null != bt.remove(Integer.valueOf (i));
+ TestHelper.assertEquals (Boolean.TRUE, Boolean.valueOf (removed));
+ final Object lookup = bt.lookup (Integer.valueOf (i));
+ TestHelper.assertEquals (null, lookup);
+ }
+
+ bt.toString ();
+ }
+
+ private static void checkAddInsert (final TrieMap<Object, Object> bt, int k) {
+ final Integer v = Integer.valueOf (k);
+ bt.remove (v);
+ Object foundV = bt.lookup (v);
+ TestHelper.assertEquals (null, foundV);
+ TestHelper.assertEquals (null, bt.put (v, v));
+ foundV = bt.lookup (v);
+ TestHelper.assertEquals (v, foundV);
+
+ TestHelper.assertEquals (v, bt.put (v, Integer.valueOf (-1)));
+ TestHelper.assertEquals (Integer.valueOf (-1), bt.put (v, v));
+ }
+}
-package com.romix.scala.collection.concurrent;\r
-\r
-\r
-import org.junit.Test;\r
-\r
-public class TestHashCollisions {\r
- @Test\r
- public void testHashCollisions () {\r
- final TrieMap<Object, Object> bt = new TrieMap<Object, Object> ();\r
-\r
- insertStrings (bt);\r
- insertChars (bt);\r
- insertInts (bt);\r
- insertBytes (bt);\r
- \r
- removeStrings (bt);\r
- removeChars (bt);\r
- removeInts (bt);\r
- removeBytes (bt);\r
-\r
- insertStrings (bt);\r
- insertInts (bt);\r
- insertBytes (bt);\r
- insertChars (bt);\r
-\r
- removeBytes (bt);\r
- removeStrings (bt);\r
- removeChars (bt);\r
- removeInts (bt);\r
-\r
- insertStrings (bt);\r
- insertInts (bt);\r
- insertBytes (bt);\r
- insertChars (bt);\r
-\r
- removeStrings (bt);\r
- removeChars (bt);\r
- removeInts (bt);\r
- removeBytes (bt);\r
-\r
- insertStrings (bt);\r
- insertInts (bt);\r
- insertBytes (bt);\r
- insertChars (bt);\r
-\r
- removeChars (bt);\r
- removeInts (bt);\r
- removeBytes (bt);\r
- removeStrings (bt);\r
-\r
- insertStrings (bt);\r
- insertInts (bt);\r
- insertBytes (bt);\r
- insertChars (bt);\r
-\r
- removeInts (bt);\r
- removeBytes (bt);\r
- removeStrings (bt);\r
- removeChars (bt);\r
-\r
- System.out.println (bt);\r
- }\r
-\r
- private static void insertChars (final TrieMap<Object, Object> bt) {\r
- TestHelper.assertEquals (null, bt.put ('a', 'a'));\r
- TestHelper.assertEquals (null, bt.put ('b', 'b'));\r
- TestHelper.assertEquals (null, bt.put ('c', 'c'));\r
- TestHelper.assertEquals (null, bt.put ('d', 'd'));\r
- TestHelper.assertEquals (null, bt.put ('e', 'e'));\r
-\r
- TestHelper.assertEquals ('a', bt.put ('a', 'a'));\r
- TestHelper.assertEquals ('b', bt.put ('b', 'b'));\r
- TestHelper.assertEquals ('c', bt.put ('c', 'c'));\r
- TestHelper.assertEquals ('d', bt.put ('d', 'd'));\r
- TestHelper.assertEquals ('e', bt.put ('e', 'e'));\r
- }\r
-\r
- private static void insertStrings (final TrieMap<Object, Object> bt) {\r
- TestHelper.assertEquals (null, bt.put ("a", "a"));\r
- TestHelper.assertEquals (null, bt.put ("b", "b"));\r
- TestHelper.assertEquals (null, bt.put ("c", "c"));\r
- TestHelper.assertEquals (null, bt.put ("d", "d"));\r
- TestHelper.assertEquals (null, bt.put ("e", "e"));\r
-\r
- TestHelper.assertEquals ("a", bt.put ("a", "a"));\r
- TestHelper.assertEquals ("b", bt.put ("b", "b"));\r
- TestHelper.assertEquals ("c", bt.put ("c", "c"));\r
- TestHelper.assertEquals ("d", bt.put ("d", "d"));\r
- TestHelper.assertEquals ("e", bt.put ("e", "e"));\r
- }\r
-\r
- private static void insertBytes (final TrieMap<Object, Object> bt) {\r
- for (byte i = 0; i < 128 && i >= 0; i++) {\r
- final Byte bigB = Byte.valueOf (i);\r
- TestHelper.assertEquals (null, bt.put (bigB, bigB));\r
- TestHelper.assertEquals (bigB, bt.put (bigB, bigB));\r
- }\r
- }\r
-\r
- private static void insertInts (final TrieMap<Object, Object> bt) {\r
- for (int i = 0; i < 128; i++) {\r
- final Integer bigI = Integer.valueOf (i);\r
- TestHelper.assertEquals (null, bt.put (bigI, bigI));\r
- TestHelper.assertEquals (bigI, bt.put (bigI, bigI));\r
- }\r
- }\r
-\r
- private static void removeChars (final TrieMap<Object, Object> bt) {\r
- TestHelper.assertTrue (null != bt.lookup ('a'));\r
- TestHelper.assertTrue (null != bt.lookup ('b'));\r
- TestHelper.assertTrue (null != bt.lookup ('c'));\r
- TestHelper.assertTrue (null != bt.lookup ('d'));\r
- TestHelper.assertTrue (null != bt.lookup ('e'));\r
-\r
- TestHelper.assertTrue (null != bt.remove ('a'));\r
- TestHelper.assertTrue (null != bt.remove ('b'));\r
- TestHelper.assertTrue (null != bt.remove ('c'));\r
- TestHelper.assertTrue (null != bt.remove ('d'));\r
- TestHelper.assertTrue (null != bt.remove ('e'));\r
-\r
- TestHelper.assertFalse (null != bt.remove ('a'));\r
- TestHelper.assertFalse (null != bt.remove ('b'));\r
- TestHelper.assertFalse (null != bt.remove ('c'));\r
- TestHelper.assertFalse (null != bt.remove ('d'));\r
- TestHelper.assertFalse (null != bt.remove ('e'));\r
-\r
- TestHelper.assertTrue (null == bt.lookup ('a'));\r
- TestHelper.assertTrue (null == bt.lookup ('b'));\r
- TestHelper.assertTrue (null == bt.lookup ('c'));\r
- TestHelper.assertTrue (null == bt.lookup ('d'));\r
- TestHelper.assertTrue (null == bt.lookup ('e'));\r
- }\r
-\r
- private static void removeStrings (final TrieMap<Object, Object> bt) {\r
- TestHelper.assertTrue (null != bt.lookup ("a"));\r
- TestHelper.assertTrue (null != bt.lookup ("b"));\r
- TestHelper.assertTrue (null != bt.lookup ("c"));\r
- TestHelper.assertTrue (null != bt.lookup ("d"));\r
- TestHelper.assertTrue (null != bt.lookup ("e"));\r
-\r
- TestHelper.assertTrue (null != bt.remove ("a"));\r
- TestHelper.assertTrue (null != bt.remove ("b"));\r
- TestHelper.assertTrue (null != bt.remove ("c"));\r
- TestHelper.assertTrue (null != bt.remove ("d"));\r
- TestHelper.assertTrue (null != bt.remove ("e"));\r
-\r
- TestHelper.assertFalse (null != bt.remove ("a"));\r
- TestHelper.assertFalse (null != bt.remove ("b"));\r
- TestHelper.assertFalse (null != bt.remove ("c"));\r
- TestHelper.assertFalse (null != bt.remove ("d"));\r
- TestHelper.assertFalse (null != bt.remove ("e"));\r
-\r
- TestHelper.assertTrue (null == bt.lookup ("a"));\r
- TestHelper.assertTrue (null == bt.lookup ("b"));\r
- TestHelper.assertTrue (null == bt.lookup ("c"));\r
- TestHelper.assertTrue (null == bt.lookup ("d"));\r
- TestHelper.assertTrue (null == bt.lookup ("e"));\r
- }\r
-\r
- private static void removeInts (final TrieMap<Object, Object> bt) {\r
- for (int i = 0; i < 128; i++) {\r
- final Integer bigI = Integer.valueOf (i);\r
- TestHelper.assertTrue (null != bt.lookup (bigI));\r
- TestHelper.assertTrue (null != bt.remove (bigI));\r
- TestHelper.assertFalse (null != bt.remove (bigI));\r
- TestHelper.assertTrue (null == bt.lookup (bigI));\r
- }\r
- }\r
-\r
- private static void removeBytes (final TrieMap<Object, Object> bt) {\r
- for (byte i = 0; i < 128 && i >= 0; i++) {\r
- final Byte bigB = Byte.valueOf (i);\r
- TestHelper.assertTrue (null != bt.lookup (bigB));\r
- TestHelper.assertTrue (null != bt.remove (bigB));\r
- TestHelper.assertFalse (null != bt.remove (bigB));\r
- TestHelper.assertTrue (null == bt.lookup (bigB));\r
- }\r
- }\r
-}\r
+package org.opendaylight.yangtools.triemap;
+
+
+import org.junit.Test;
+
+public class TestHashCollisions {
+ @Test
+ public void testHashCollisions () {
+ final TrieMap<Object, Object> bt = new TrieMap<Object, Object> ();
+
+ 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);
+ }
+
+ 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'));
+ }
+
+ 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"));
+ }
+
+ 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));
+ }
+ }
+
+ 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));
+ }
+ }
+
+ 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'));
+ }
+
+ 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"));
+ }
+
+ 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));
+ }
+ }
+
+ 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));
+ }
+ }
+}
-package com.romix.scala.collection.concurrent;\r
-\r
-import java.util.Map;\r
-\r
-import org.junit.Test;\r
-\r
-public class TestHashCollisionsRemove {\r
- @Test\r
- public void testHashCollisionsRemove() {\r
- final Map<Object, Object> bt = new TrieMap<Object, Object> ();\r
- int count = 50000;\r
- for (int j = 0; j < count; j++) {\r
- final Object[] objects = TestMultiThreadMapIterator.getObjects (j);\r
- for (final Object o : objects) {\r
- bt.put (o, o);\r
- }\r
- }\r
- \r
- for (int j = 0; j < count; j++) {\r
- final Object[] objects = TestMultiThreadMapIterator.getObjects (j);\r
- for (final Object o : objects) {\r
- bt.remove (o);\r
- }\r
- }\r
-\r
- TestHelper.assertEquals (0, bt.size ());\r
- TestHelper.assertTrue (bt.isEmpty ());\r
- }\r
-}\r
+package org.opendaylight.yangtools.triemap;
+
+import java.util.Map;
+
+import org.junit.Test;
+
+public class TestHashCollisionsRemove {
+ @Test
+ public void testHashCollisionsRemove() {
+ final Map<Object, Object> bt = new TrieMap<Object, Object> ();
+ 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);
+ }
+ }
+
+ for (int j = 0; j < count; j++) {
+ final Object[] objects = TestMultiThreadMapIterator.getObjects (j);
+ for (final Object o : objects) {
+ bt.remove (o);
+ }
+ }
+
+ TestHelper.assertEquals (0, bt.size ());
+ TestHelper.assertTrue (bt.isEmpty ());
+ }
+}
-package com.romix.scala.collection.concurrent;\r
-\r
-import java.util.ArrayList;\r
-import java.util.Collection;\r
-import java.util.Iterator;\r
-import java.util.Map;\r
-import java.util.Map.Entry;\r
-\r
-import org.junit.Test;\r
-\r
-public class TestHashCollisionsRemoveIterator {\r
- @Test\r
- public void testHashCollisionsRemoveIterator () {\r
- final Map<Object, Object> bt = new TrieMap<Object, Object> ();\r
- int count = 50000;\r
- for (int j = 0; j < count; j++) {\r
- bt.put (Integer.valueOf (j), Integer.valueOf (j));\r
- }\r
- \r
- final Collection<Object> list = new ArrayList <Object> ();\r
- for (final Iterator<Map.Entry<Object, Object>> i = bt.entrySet ().iterator (); i.hasNext ();) {\r
- final Entry<Object, Object> e = i.next ();\r
- final Object key = e.getKey ();\r
- list.add (key);\r
- i.remove ();\r
- }\r
-\r
- TestHelper.assertEquals (0, bt.size ());\r
- TestHelper.assertTrue (bt.isEmpty ());\r
- }\r
-}\r
+package org.opendaylight.yangtools.triemap;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import org.junit.Test;
+
+public class TestHashCollisionsRemoveIterator {
+ @Test
+ public void testHashCollisionsRemoveIterator () {
+ final Map<Object, Object> bt = new TrieMap<Object, Object> ();
+ int count = 50000;
+ for (int j = 0; j < count; j++) {
+ bt.put (Integer.valueOf (j), Integer.valueOf (j));
+ }
+
+ final Collection<Object> list = new ArrayList <Object> ();
+ 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 ();
+ }
+
+ TestHelper.assertEquals (0, bt.size ());
+ TestHelper.assertTrue (bt.isEmpty ());
+ }
+}
-package com.romix.scala.collection.concurrent;\r
-\r
-import org.junit.Assert;\r
-\r
-public class TestHelper {\r
-\r
- public static void assertEquals (long expected, long found) {\r
- Assert.assertEquals (expected, found);\r
- }\r
-\r
- public static void assertEquals (int expected, int found) {\r
- Assert.assertEquals (expected, found);\r
- }\r
-\r
- public static void assertEquals (Object expected, Object found) {\r
- Assert.assertEquals (expected, found);\r
- }\r
-\r
- public static void assertTrue (boolean found) {\r
- Assert.assertTrue (found);\r
- }\r
-\r
- public static void assertFalse (boolean found) {\r
- Assert.assertFalse (found);\r
- }\r
-\r
-}\r
+package org.opendaylight.yangtools.triemap;
+
+import org.junit.Assert;
+
+public class TestHelper {
+
+ public static void assertEquals (long expected, long found) {
+ Assert.assertEquals (expected, found);
+ }
+
+ public static void assertEquals (int expected, int found) {
+ Assert.assertEquals (expected, found);
+ }
+
+ public static void assertEquals (Object expected, Object found) {
+ Assert.assertEquals (expected, found);
+ }
+
+ public static void assertTrue (boolean found) {
+ Assert.assertTrue (found);
+ }
+
+ public static void assertFalse (boolean found) {
+ Assert.assertFalse (found);
+ }
+
+}
-package com.romix.scala.collection.concurrent;\r
-\r
-import org.junit.Test;\r
-\r
-public class TestInsert {\r
- @Test\r
- public void testInsert () {\r
- final TrieMap<Object, Object> bt = new TrieMap<Object, Object> ();\r
- TestHelper.assertEquals (null, bt.put ("a", "a"));\r
- TestHelper.assertEquals (null, bt.put ("b", "b"));\r
- TestHelper.assertEquals (null, bt.put ("c", "b"));\r
- TestHelper.assertEquals (null, bt.put ("d", "b"));\r
- TestHelper.assertEquals (null, bt.put ("e", "b"));\r
-\r
- for (int i = 0; i < 10000; i++) {\r
- TestHelper.assertEquals (null, bt.put (Integer.valueOf (i), Integer.valueOf (i)));\r
- final Object lookup = bt.lookup (Integer.valueOf (i));\r
- TestHelper.assertEquals (Integer.valueOf (i), lookup);\r
- }\r
-\r
- bt.toString ();\r
- }\r
-}\r
+package org.opendaylight.yangtools.triemap;
+
+import org.junit.Test;
+
+public class TestInsert {
+ @Test
+ public void testInsert () {
+ final TrieMap<Object, Object> bt = new TrieMap<Object, Object> ();
+ 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"));
+
+ 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);
+ }
+
+ bt.toString ();
+ }
+}
-package com.romix.scala.collection.concurrent;
+package org.opendaylight.yangtools.triemap;
import org.junit.Test;
-package com.romix.scala.collection.concurrent;\r
-\r
-import java.util.HashSet;\r
-import java.util.Iterator;\r
-import java.util.Map;\r
-import java.util.Map.Entry;\r
-import java.util.Random;\r
-import java.util.Set;\r
-\r
-import org.junit.Test;\r
-\r
-public class TestMapIterator {\r
- @Test\r
- public void testMapIterator () {\r
- for (int i = 0; i < 60 * 1000; i+= 400 + new Random ().nextInt (400)) {\r
- System.out.println (i);\r
- final Map<Integer, Integer> bt = new TrieMap <Integer, Integer> ();\r
- for (int j = 0; j < i; j++) {\r
- TestHelper.assertEquals (null, bt.put (Integer.valueOf (j), Integer.valueOf (j)));\r
- }\r
- int count = 0;\r
- final Set<Integer> set = new HashSet<Integer> ();\r
- for (final Map.Entry<Integer, Integer> e : bt.entrySet ()) {\r
- set.add (e.getKey ());\r
- count++;\r
- }\r
- for (final Integer j : set) {\r
- TestHelper.assertTrue (bt.containsKey (j));\r
- }\r
- for (final Integer j : bt.keySet ()) {\r
- TestHelper.assertTrue (set.contains (j));\r
- }\r
-\r
- TestHelper.assertEquals (i, count);\r
- TestHelper.assertEquals (i, bt.size ());\r
- \r
- for (final Iterator<Map.Entry<Integer, Integer>> iter = bt.entrySet ().iterator (); iter.hasNext ();) {\r
- final Entry<Integer, Integer> e = iter.next ();\r
- TestHelper.assertTrue (e.getValue () == bt.get (e.getKey ()));\r
- e.setValue (e.getValue () + 1);\r
- TestHelper.assertTrue (e.getValue () == e.getKey () + 1);\r
- TestHelper.assertTrue (e.getValue () == bt.get (e.getKey ()));\r
- e.setValue (e.getValue () - 1);\r
- }\r
-\r
- for (final Iterator<Integer> iter = bt.keySet ().iterator (); iter.hasNext ();) {\r
- final Integer k = iter.next ();\r
- TestHelper.assertTrue (bt.containsKey (k));\r
- iter.remove ();\r
- TestHelper.assertFalse (bt.containsKey (k));\r
- }\r
- \r
- TestHelper.assertEquals (0, bt.size ());\r
- TestHelper.assertTrue (bt.isEmpty ());\r
- }\r
- }\r
-}\r
+package org.opendaylight.yangtools.triemap;
+
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Random;
+import java.util.Set;
+
+import org.junit.Test;
+
+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 <Integer, Integer> ();
+ for (int j = 0; j < i; j++) {
+ TestHelper.assertEquals (null, bt.put (Integer.valueOf (j), Integer.valueOf (j)));
+ }
+ int count = 0;
+ final Set<Integer> set = new HashSet<Integer> ();
+ for (final Map.Entry<Integer, Integer> e : bt.entrySet ()) {
+ set.add (e.getKey ());
+ count++;
+ }
+ for (final Integer j : set) {
+ TestHelper.assertTrue (bt.containsKey (j));
+ }
+ for (final Integer j : bt.keySet ()) {
+ TestHelper.assertTrue (set.contains (j));
+ }
+
+ TestHelper.assertEquals (i, count);
+ TestHelper.assertEquals (i, bt.size ());
+
+ for (final Iterator<Map.Entry<Integer, Integer>> iter = bt.entrySet ().iterator (); iter.hasNext ();) {
+ final Entry<Integer, Integer> e = iter.next ();
+ 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 (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));
+ }
+
+ TestHelper.assertEquals (0, bt.size ());
+ TestHelper.assertTrue (bt.isEmpty ());
+ }
+ }
+}
-package com.romix.scala.collection.concurrent;\r
-\r
-import java.util.Map;\r
-import java.util.concurrent.ExecutorService;\r
-import java.util.concurrent.Executors;\r
-import java.util.concurrent.TimeUnit;\r
-\r
-import org.junit.Test;\r
-\r
-public class TestMultiThreadAddDelete {\r
- private static final int RETRIES = 1;\r
- private static final int N_THREADS = 7;\r
- private static final int COUNT = 50 * 1000;\r
-\r
- @Test\r
- public void testMultiThreadAddDelete () {\r
- for (int j = 0; j < RETRIES; j++) {\r
- final Map<Object, Object> bt = new TrieMap <Object, Object> ();\r
- \r
- {\r
- final ExecutorService es = Executors.newFixedThreadPool (N_THREADS);\r
- for (int i = 0; i < N_THREADS; i++) {\r
- final int threadNo = i;\r
- es.execute (new Runnable () {\r
- @Override\r
- public void run () {\r
- for (int j = 0; j < COUNT; j++) {\r
- if (j % N_THREADS == threadNo) {\r
- bt.put (Integer.valueOf (j), Integer.valueOf (j));\r
- }\r
- }\r
- }\r
- });\r
- }\r
- es.shutdown ();\r
- try {\r
- es.awaitTermination (3600L, TimeUnit.SECONDS);\r
- } catch (final InterruptedException e) {\r
- e.printStackTrace ();\r
- }\r
- }\r
- \r
- TestHelper.assertEquals (COUNT, bt.size ());\r
- TestHelper.assertFalse (bt.isEmpty ());\r
- \r
- {\r
- final ExecutorService es = Executors.newFixedThreadPool (N_THREADS);\r
- for (int i = 0; i < N_THREADS; i++) {\r
- final int threadNo = i;\r
- es.execute (new Runnable () {\r
- @Override\r
- public void run () {\r
- for (int j = 0; j < COUNT; j++) {\r
- if (j % N_THREADS == threadNo) {\r
- bt.remove (Integer.valueOf (j));\r
- }\r
- }\r
- }\r
- });\r
- }\r
- es.shutdown ();\r
- try {\r
- es.awaitTermination (3600L, TimeUnit.SECONDS);\r
- } catch (final InterruptedException e) {\r
- e.printStackTrace ();\r
- }\r
- }\r
- \r
- \r
- TestHelper.assertEquals (0, bt.size ());\r
- TestHelper.assertTrue (bt.isEmpty ());\r
- \r
- {\r
- final ExecutorService es = Executors.newFixedThreadPool (N_THREADS);\r
- for (int i = 0; i < N_THREADS; i++) {\r
- final int threadNo = i;\r
- es.execute (new Runnable () {\r
- @Override\r
- public void run () {\r
- for (int j = 0; j < COUNT; j++) {\r
- if (j % N_THREADS == threadNo) {\r
- try {\r
- bt.put (Integer.valueOf (j), Integer.valueOf (j));\r
- if (!bt.containsKey (Integer.valueOf (j))) {\r
- System.out.println (j);\r
- }\r
- bt.remove (Integer.valueOf (j));\r
- if (bt.containsKey (Integer.valueOf (j))) {\r
- System.out.println (-j);\r
- }\r
- } catch (Throwable t) {\r
- t.printStackTrace ();\r
- }\r
- }\r
- }\r
- }\r
- });\r
- }\r
- es.shutdown ();\r
- try {\r
- es.awaitTermination (3600L, TimeUnit.SECONDS);\r
- } catch (final InterruptedException e) {\r
- e.printStackTrace ();\r
- }\r
- }\r
- \r
- TestHelper.assertEquals (0, bt.size ());\r
- if (!bt.isEmpty ()) {\r
- System.out.println ();\r
- }\r
- TestHelper.assertTrue (bt.isEmpty ());\r
- }\r
- }\r
-}\r
+package org.opendaylight.yangtools.triemap;
+
+import java.util.Map;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+
+import org.junit.Test;
+
+public class TestMultiThreadAddDelete {
+ private static final int RETRIES = 1;
+ private static final int N_THREADS = 7;
+ private static final int COUNT = 50 * 1000;
+
+ @Test
+ public void testMultiThreadAddDelete () {
+ for (int j = 0; j < RETRIES; j++) {
+ final Map<Object, Object> bt = new TrieMap <Object, Object> ();
+
+ {
+ 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.shutdown ();
+ try {
+ es.awaitTermination (3600L, TimeUnit.SECONDS);
+ } catch (final InterruptedException e) {
+ e.printStackTrace ();
+ }
+ }
+
+ TestHelper.assertEquals (COUNT, bt.size ());
+ TestHelper.assertFalse (bt.isEmpty ());
+
+ {
+ 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.shutdown ();
+ try {
+ es.awaitTermination (3600L, TimeUnit.SECONDS);
+ } catch (final InterruptedException e) {
+ e.printStackTrace ();
+ }
+ }
+
+
+ TestHelper.assertEquals (0, bt.size ());
+ TestHelper.assertTrue (bt.isEmpty ());
+
+ {
+ 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) {
+ try {
+ bt.put (Integer.valueOf (j), Integer.valueOf (j));
+ if (!bt.containsKey (Integer.valueOf (j))) {
+ System.out.println (j);
+ }
+ bt.remove (Integer.valueOf (j));
+ if (bt.containsKey (Integer.valueOf (j))) {
+ System.out.println (-j);
+ }
+ } catch (Throwable t) {
+ t.printStackTrace ();
+ }
+ }
+ }
+ }
+ });
+ }
+ es.shutdown ();
+ try {
+ es.awaitTermination (3600L, TimeUnit.SECONDS);
+ } catch (final InterruptedException e) {
+ e.printStackTrace ();
+ }
+ }
+
+ TestHelper.assertEquals (0, bt.size ());
+ if (!bt.isEmpty ()) {
+ System.out.println ();
+ }
+ TestHelper.assertTrue (bt.isEmpty ());
+ }
+ }
+}
-package com.romix.scala.collection.concurrent;\r
-\r
-import java.util.concurrent.ExecutorService;\r
-import java.util.concurrent.Executors;\r
-import java.util.concurrent.TimeUnit;\r
-\r
-import org.junit.Test;\r
-\r
-public class TestMultiThreadInserts {\r
- @Test\r
- public void testMultiThreadInserts () {\r
- final int nThreads = 2;\r
- final ExecutorService es = Executors.newFixedThreadPool (nThreads);\r
- final TrieMap<Object, Object> bt = new TrieMap<Object, Object> ();\r
- for (int i = 0; i < nThreads; i++) {\r
- final int threadNo = i;\r
- es.execute (new Runnable () {\r
- @Override\r
- public void run () {\r
- for (int j = 0; j < 500 * 1000; j++) {\r
- if (j % nThreads == threadNo) {\r
- bt.put (Integer.valueOf (j), Integer.valueOf (j));\r
- }\r
- }\r
- }\r
- });\r
- }\r
-\r
- es.shutdown ();\r
- try {\r
- es.awaitTermination (3600L, TimeUnit.SECONDS);\r
- } catch (final InterruptedException e) {\r
- e.printStackTrace ();\r
- }\r
- \r
- for (int j = 0; j < 500 * 1000; j++) {\r
- final Object lookup = bt.lookup (Integer.valueOf (j));\r
- TestHelper.assertEquals (Integer.valueOf (j), lookup);\r
- }\r
- }\r
-}\r
+package org.opendaylight.yangtools.triemap;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+
+import org.junit.Test;
+
+public class TestMultiThreadInserts {
+ @Test
+ public void testMultiThreadInserts () {
+ final int nThreads = 2;
+ final ExecutorService es = Executors.newFixedThreadPool (nThreads);
+ final TrieMap<Object, Object> bt = new TrieMap<Object, Object> ();
+ 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.shutdown ();
+ try {
+ es.awaitTermination (3600L, TimeUnit.SECONDS);
+ } catch (final InterruptedException e) {
+ e.printStackTrace ();
+ }
+
+ for (int j = 0; j < 500 * 1000; j++) {
+ final Object lookup = bt.lookup (Integer.valueOf (j));
+ TestHelper.assertEquals (Integer.valueOf (j), lookup);
+ }
+ }
+}
-package com.romix.scala.collection.concurrent;\r
-\r
-import java.util.Collection;\r
-import java.util.Iterator;\r
-import java.util.LinkedList;\r
-import java.util.Map;\r
-import java.util.Map.Entry;\r
-import java.util.concurrent.ConcurrentHashMap;\r
-import java.util.concurrent.ExecutorService;\r
-import java.util.concurrent.Executors;\r
-import java.util.concurrent.TimeUnit;\r
-\r
-import org.junit.Test;\r
-\r
-public class TestMultiThreadMapIterator {\r
- private static final int NTHREADS = 7;\r
-\r
- @Test\r
- public void testMultiThreadMapIterator () {\r
- final Map<Object, Object> bt = new TrieMap<Object, Object> ();\r
- for (int j = 0; j < 50 * 1000; j++) {\r
- final Object[] objects = getObjects (j);\r
- for (final Object o : objects) {\r
- bt.put (o, o);\r
- }\r
- }\r
-\r
- System.out.println ("Size of initialized map is " + bt.size ()); \r
- int count = 0;\r
- {\r
- final ExecutorService es = Executors.newFixedThreadPool (NTHREADS);\r
- for (int i = 0; i < NTHREADS; i++) {\r
- final int threadNo = i;\r
- es.execute (new Runnable () {\r
- @Override\r
- public void run () {\r
- for (final Iterator<Map.Entry<Object, Object>> i = bt.entrySet ().iterator (); i.hasNext ();) {\r
- final Entry<Object, Object> e = i.next ();\r
- if (accepts (threadNo, NTHREADS, e.getKey ())) {\r
- String newValue = "TEST:" + threadNo; \r
- e.setValue (newValue);\r
- }\r
- }\r
- }\r
- });\r
- }\r
-\r
- es.shutdown ();\r
- try {\r
- es.awaitTermination (3600L, TimeUnit.SECONDS);\r
- } catch (final InterruptedException e) {\r
- e.printStackTrace ();\r
- }\r
- }\r
-\r
- count = 0;\r
- for (final Map.Entry<Object, Object> kv : bt.entrySet ()) {\r
- Object value = kv.getValue (); \r
- TestHelper.assertTrue (value instanceof String);\r
- count++;\r
- }\r
- TestHelper.assertEquals (50000 + 2000 + 1000 + 100, count);\r
- \r
- final ConcurrentHashMap<Object, Object> removed = new ConcurrentHashMap<Object, Object> ();\r
-\r
- {\r
- final ExecutorService es = Executors.newFixedThreadPool (NTHREADS);\r
- for (int i = 0; i < NTHREADS; i++) {\r
- final int threadNo = i;\r
- es.execute (new Runnable () {\r
- @Override\r
- public void run () {\r
- for (final Iterator<Map.Entry<Object, Object>> i = bt.entrySet ().iterator (); i.hasNext ();) {\r
- final Entry<Object, Object> e = i.next ();\r
- Object key = e.getKey ();\r
- if (accepts (threadNo, NTHREADS, key)) {\r
- if (null == bt.get (key)) {\r
- System.out.println (key);\r
- }\r
- i.remove ();\r
- if (null != bt.get (key)) {\r
- System.out.println (key);\r
- }\r
- removed.put (key, key);\r
- }\r
- }\r
- }\r
- });\r
- }\r
-\r
- es.shutdown ();\r
- try {\r
- es.awaitTermination (3600L, TimeUnit.SECONDS);\r
- } catch (final InterruptedException e) {\r
- e.printStackTrace ();\r
- }\r
- }\r
-\r
- count = 0;\r
- for (final Object value : bt.keySet ()) {\r
- value.toString ();\r
- count++;\r
- }\r
- for (final Object o : bt.keySet ()) {\r
- if (!removed.contains (bt.get (o))) {\r
- System.out.println ("Not removed: " + o);\r
- }\r
- }\r
- TestHelper.assertEquals (0, count);\r
- TestHelper.assertEquals (0, bt.size ());\r
- TestHelper.assertTrue (bt.isEmpty ());\r
- }\r
-\r
- protected static boolean accepts (final int threadNo, final int nThreads, final Object key) {\r
- int val = getKeyValue (key); \r
- if(val>=0)\r
- return val % nThreads == threadNo;\r
- else\r
- return false;\r
- }\r
-\r
- private static int getKeyValue (final Object key) {\r
- int val = 0;\r
- if (key instanceof Integer) {\r
- val = ((Integer) key).intValue ();\r
- }\r
- else if (key instanceof Character) {\r
- val = Math.abs (Character.getNumericValue ((Character) key) + 1);\r
- }\r
- else if (key instanceof Short) {\r
- val = ((Short) key).intValue () + 2;\r
- }\r
- else if (key instanceof Byte) {\r
- val = ((Byte) key).intValue () + 3;\r
- } else \r
- return -1;\r
- return val;\r
- }\r
-\r
- static Object[] getObjects (final int j) {\r
- final Collection<Object> results = new LinkedList<Object> ();\r
- results.add (Integer.valueOf (j));\r
- if (j < 2000) {\r
- results.add (Character.valueOf ((char) j));\r
- }\r
- if (j < 1000) {\r
- results.add (Short.valueOf ((short) j));\r
- }\r
- if (j < 100) {\r
- results.add (Byte.valueOf ((byte) j));\r
- }\r
-\r
- return results.toArray ();\r
- }\r
-}\r
+package org.opendaylight.yangtools.triemap;
+
+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;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+
+import org.junit.Test;
+
+public class TestMultiThreadMapIterator {
+ private static final int NTHREADS = 7;
+
+ @Test
+ public void testMultiThreadMapIterator () {
+ final Map<Object, Object> bt = new TrieMap<Object, Object> ();
+ for (int j = 0; j < 50 * 1000; j++) {
+ final Object[] objects = getObjects (j);
+ for (final Object o : objects) {
+ bt.put (o, o);
+ }
+ }
+
+ System.out.println ("Size of initialized map is " + bt.size ());
+ int count = 0;
+ {
+ 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 ();
+ 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 ();
+ }
+ }
+
+ count = 0;
+ for (final Map.Entry<Object, Object> kv : bt.entrySet ()) {
+ Object value = kv.getValue ();
+ TestHelper.assertTrue (value instanceof String);
+ count++;
+ }
+ TestHelper.assertEquals (50000 + 2000 + 1000 + 100, count);
+
+ final ConcurrentHashMap<Object, Object> removed = new ConcurrentHashMap<Object, Object> ();
+
+ {
+ 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.shutdown ();
+ try {
+ es.awaitTermination (3600L, TimeUnit.SECONDS);
+ } catch (final InterruptedException e) {
+ e.printStackTrace ();
+ }
+ }
+
+ 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 ());
+ }
+
+ 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;
+ }
+
+ 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;
+ } else
+ return -1;
+ return val;
+ }
+
+ static Object[] getObjects (final int j) {
+ final Collection<Object> results = new LinkedList<Object> ();
+ results.add (Integer.valueOf (j));
+ if (j < 2000) {
+ results.add (Character.valueOf ((char) j));
+ }
+ if (j < 1000) {
+ results.add (Short.valueOf ((short) j));
+ }
+ if (j < 100) {
+ results.add (Byte.valueOf ((byte) j));
+ }
+
+ return results.toArray ();
+ }
+}
-package com.romix.scala.collection.concurrent;\r
-\r
-import java.util.Iterator;\r
-import java.util.Map.Entry;\r
-\r
-import org.junit.Before;\r
-import org.junit.Test;\r
-\r
-/***\r
- * \r
- * Test that read-only iterators do not allow for any updates.\r
- * Test that non read-only iterators allow for updates. \r
- *\r
- */\r
-public class TestReadOnlyAndUpdatableIterators {\r
- TrieMap<Integer, Integer> bt;\r
- private static final int MAP_SIZE = 200;\r
- \r
- @Before\r
- public void setUp() {\r
- bt = new TrieMap <Integer, Integer> ();\r
- for (int j = 0; j < MAP_SIZE; j++) {\r
- TestHelper.assertEquals (null, bt.put (Integer.valueOf (j), Integer.valueOf (j)));\r
- } \r
- }\r
- \r
- @Test\r
- public void testReadOnlyIterator () {\r
- Iterator<Entry<Integer, Integer>> it = bt.readOnlyIterator ();\r
- try {\r
- it.next().setValue (0);\r
- // It should have generated an exception, because it is a read-only iterator\r
- TestHelper.assertFalse (true);\r
- } catch (Exception e) {\r
- \r
- }\r
- try {\r
- it.remove ();\r
- // It should have generated an exception, because it is a read-only iterator\r
- TestHelper.assertFalse (true);\r
- } catch (Exception e) {\r
- \r
- }\r
- }\r
-\r
- @Test\r
- public void testReadOnlySnapshotReadOnlyIterator () {\r
- TrieMap<Integer, Integer> roSnapshot = bt.readOnlySnapshot ();\r
- Iterator<Entry<Integer, Integer>> it = roSnapshot.readOnlyIterator ();\r
- try {\r
- it.next().setValue (0);\r
- // It should have generated an exception, because it is a read-only iterator\r
- TestHelper.assertFalse (true);\r
- } catch (Exception e) {\r
- \r
- }\r
- try {\r
- it.remove ();\r
- // It should have generated an exception, because it is a read-only iterator\r
- TestHelper.assertFalse (true);\r
- } catch (Exception e) {\r
- \r
- }\r
- }\r
-\r
- @Test\r
- public void testReadOnlySnapshotIterator () {\r
- TrieMap<Integer, Integer> roSnapshot = bt.readOnlySnapshot ();\r
- Iterator<Entry<Integer, Integer>> it = roSnapshot.iterator ();\r
- try {\r
- it.next().setValue (0);\r
- // It should have generated an exception, because it is a read-only iterator\r
- TestHelper.assertFalse (true);\r
- } catch (Exception e) {\r
- \r
- }\r
- try {\r
- it.remove ();\r
- // It should have generated an exception, because it is a read-only iterator\r
- TestHelper.assertFalse (true);\r
- } catch (Exception e) {\r
- \r
- }\r
- }\r
-\r
- @Test\r
- public void testIterator () {\r
- Iterator<Entry<Integer, Integer>> it = bt.iterator ();\r
- try {\r
- it.next().setValue (0);\r
- } catch (Exception e) {\r
- // It should not have generated an exception, because it is a non read-only iterator\r
- TestHelper.assertFalse (true); \r
- }\r
- \r
- try {\r
- it.remove ();\r
- } catch (Exception e) {\r
- // It should not have generated an exception, because it is a non read-only iterator\r
- TestHelper.assertFalse (true); \r
- }\r
- \r
- // All changes are done on the original map\r
- TestHelper.assertEquals (MAP_SIZE - 1, bt.size ()); \r
- }\r
-\r
- @Test\r
- public void testSnapshotIterator () {\r
- TrieMap<Integer, Integer> snapshot = bt.snapshot ();\r
- Iterator<Entry<Integer, Integer>> it = snapshot.iterator ();\r
- try {\r
- it.next().setValue (0);\r
- } catch (Exception e) {\r
- // It should not have generated an exception, because it is a non read-only iterator\r
- TestHelper.assertFalse (true); \r
- }\r
- try {\r
- it.remove ();\r
- } catch (Exception e) {\r
- // It should not have generated an exception, because it is a non read-only iterator\r
- TestHelper.assertFalse (true); \r
- }\r
-\r
- // All changes are done on the snapshot, not on the original map\r
- // Map size should remain unchanged\r
- TestHelper.assertEquals (MAP_SIZE, bt.size ());\r
- // snapshot size was changed\r
- TestHelper.assertEquals (MAP_SIZE-1, snapshot.size ()); \r
- }\r
-}\r
+package org.opendaylight.yangtools.triemap;
+
+import java.util.Iterator;
+import java.util.Map.Entry;
+
+import org.junit.Before;
+import org.junit.Test;
+
+/***
+ *
+ * Test that read-only iterators do not allow for any updates.
+ * Test that non read-only iterators allow for updates.
+ *
+ */
+public class TestReadOnlyAndUpdatableIterators {
+ TrieMap<Integer, Integer> bt;
+ private static final int MAP_SIZE = 200;
+
+ @Before
+ public void setUp() {
+ bt = new TrieMap <Integer, Integer> ();
+ for (int j = 0; j < MAP_SIZE; j++) {
+ TestHelper.assertEquals (null, 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) {
+
+ }
+ }
+
+ @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) {
+
+ }
+ try {
+ it.remove ();
+ // It should have generated an exception, because it is a read-only iterator
+ TestHelper.assertFalse (true);
+ } catch (Exception e) {
+
+ }
+ }
+
+ @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) {
+
+ }
+ try {
+ it.remove ();
+ // It should have generated an exception, because it is a read-only iterator
+ TestHelper.assertFalse (true);
+ } catch (Exception e) {
+
+ }
+ }
+
+ @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);
+ }
+
+ // All changes are done on the original map
+ TestHelper.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);
+ }
+
+ // All changes are done on the snapshot, not on the original map
+ // Map size should remain unchanged
+ TestHelper.assertEquals (MAP_SIZE, bt.size ());
+ // snapshot size was changed
+ TestHelper.assertEquals (MAP_SIZE-1, snapshot.size ());
+ }
+}
-package com.romix.scala.collection.concurrent;
+package org.opendaylight.yangtools.triemap;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
Code Review / yangtools.git / commitdiff