You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@directory.apache.org by el...@apache.org on 2009/11/07 08:57:42 UTC
svn commit: r833647 [11/17] - in /directory:
apacheds/branches/apacheds-schema/avl-partition/src/main/java/org/apache/directory/server/core/partition/avl/
apacheds/branches/apacheds-schema/avl-partition/src/test/java/org/apache/directory/server/core/pa...
Modified: directory/apacheds/branches/apacheds-schema/jdbm-store/src/test/java/org/apache/directory/server/core/partition/impl/btree/jdbm/DupsCursorTest.java
URL: http://svn.apache.org/viewvc/directory/apacheds/branches/apacheds-schema/jdbm-store/src/test/java/org/apache/directory/server/core/partition/impl/btree/jdbm/DupsCursorTest.java?rev=833647&r1=833646&r2=833647&view=diff
==============================================================================
--- directory/apacheds/branches/apacheds-schema/jdbm-store/src/test/java/org/apache/directory/server/core/partition/impl/btree/jdbm/DupsCursorTest.java (original)
+++ directory/apacheds/branches/apacheds-schema/jdbm-store/src/test/java/org/apache/directory/server/core/partition/impl/btree/jdbm/DupsCursorTest.java Sat Nov 7 07:57:34 2009
@@ -19,30 +19,36 @@
package org.apache.directory.server.core.partition.impl.btree.jdbm;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.apache.directory.server.xdbm.Table;
-import org.apache.directory.server.xdbm.Tuple;
-import org.apache.directory.shared.ldap.cursor.Cursor;
-import org.apache.directory.shared.ldap.cursor.InvalidCursorPositionException;
-import org.apache.directory.shared.ldap.schema.registries.OidRegistry;
-import org.apache.directory.shared.ldap.schema.comparators.SerializableComparator;
-import org.junit.Before;
-import org.junit.After;
-import org.junit.Test;
-
import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import java.io.File;
import jdbm.RecordManager;
-import jdbm.helper.IntegerSerializer;
+import jdbm.helper.DefaultSerializer;
import jdbm.recman.BaseRecordManager;
+import org.apache.directory.server.xdbm.Table;
+import org.apache.directory.server.xdbm.Tuple;
+import org.apache.directory.shared.ldap.constants.SchemaConstants;
+import org.apache.directory.shared.ldap.cursor.Cursor;
+import org.apache.directory.shared.ldap.cursor.InvalidCursorPositionException;
+import org.apache.directory.shared.ldap.schema.SchemaManager;
+import org.apache.directory.shared.ldap.schema.comparators.SerializableComparator;
+import org.apache.directory.shared.ldap.schema.ldif.extractor.SchemaLdifExtractor;
+import org.apache.directory.shared.ldap.util.ExceptionUtils;
+import org.apache.directory.shared.schema.DefaultSchemaManager;
+import org.apache.directory.shared.schema.loader.ldif.LdifSchemaLoader;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
/**
* Tests the Cursor functionality of a JdbmTable when duplicate keys are
@@ -57,15 +63,44 @@
private static final String TEST_OUTPUT_PATH = "test.output.path";
private static final int SIZE = 15;
- transient Table<Integer,Integer> table;
+ transient Table<String,String> table;
transient File dbFile;
transient RecordManager recman;
+ private static SchemaManager schemaManager;
+
+
+ @BeforeClass
+ public static void init() throws Exception
+ {
+ String workingDirectory = System.getProperty( "workingDirectory" );
+ if ( workingDirectory == null )
+ {
+ String path = DupsContainerCursorTest.class.getResource( "" ).getPath();
+ int targetPos = path.indexOf( "target" );
+ workingDirectory = path.substring( 0, targetPos + 6 );
+ }
+
+ File schemaRepository = new File( workingDirectory, "schema" );
+ SchemaLdifExtractor extractor = new SchemaLdifExtractor( new File( workingDirectory ) );
+ extractor.extractOrCopy();
+ LdifSchemaLoader loader = new LdifSchemaLoader( schemaRepository );
+ schemaManager = new DefaultSchemaManager( loader );
+ boolean loaded = schemaManager.loadAllEnabled();
+
+ if ( !loaded )
+ {
+ fail( "Schema load failed : " + ExceptionUtils.printErrors( schemaManager.getErrors() ) );
+ }
+ }
+
+
@Before
public void createTable() throws Exception
{
File tmpDir = null;
+
if ( System.getProperty( TEST_OUTPUT_PATH, null ) != null )
{
tmpDir = new File( System.getProperty( TEST_OUTPUT_PATH ) );
@@ -74,15 +109,11 @@
dbFile = File.createTempFile( getClass().getSimpleName(), "db", tmpDir );
recman = new BaseRecordManager( dbFile.getAbsolutePath() );
- // gosh this is a terrible use of a global static variable
- SerializableComparator.setRegistry(
- new MockComparatorRegistry(
- new OidRegistry() ) );
-
- table = new JdbmTable<Integer,Integer>( "test", SIZE, recman,
- new SerializableComparator<Integer>( "" ),
- new SerializableComparator<Integer>( "" ),
- null, new IntegerSerializer() );
+ SerializableComparator<String> comparator = new SerializableComparator<String>( SchemaConstants.INTEGER_ORDERING_MATCH_MR_OID );
+ comparator.setSchemaManager( schemaManager );
+
+ table = new JdbmTable<String,String>( schemaManager, "test", SIZE, recman,
+ comparator, comparator, null, new DefaultSerializer() );
LOG.debug( "Created new table and populated it with data" );
}
@@ -108,7 +139,7 @@
@Test
public void testEmptyTableOperations() throws Exception
{
- Cursor<Tuple<Integer,Integer>> cursor = table.cursor();
+ Cursor<Tuple<String,String>> cursor = table.cursor();
assertFalse( cursor.next() );
cursor.afterLast();
@@ -126,19 +157,22 @@
public void testNextNoDups() throws Exception
{
// first try without duplicates at all
- for ( int ii = 0; ii < SIZE-1; ii++ )
+ for ( int i = 0; i < SIZE-1; i++ )
{
- table.put( ii, ii );
+ String istr = Integer.toString( i );
+ table.put( istr, istr );
}
- Cursor<Tuple<Integer,Integer>> cursor = table.cursor();
- int ii = 0;
+ Cursor<Tuple<String,String>> cursor = table.cursor();
+
+ int i = 0;
+
while ( cursor.next() )
{
- Tuple<Integer,Integer> tuple = cursor.get();
- assertEquals( ii, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
- ii++;
+ Tuple<String,String> tuple = cursor.get();
+ assertEquals( i, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
+ i++;
}
}
@@ -146,19 +180,22 @@
@Test
public void testPreviousNoDups() throws Exception
{
- for ( int ii = 0; ii < SIZE-1; ii++ )
+ for ( int i = 0; i < SIZE-1; i++ )
{
- table.put( ii, ii );
+ String istr = Integer.toString( i );
+ table.put( istr, istr );
}
- Cursor<Tuple<Integer,Integer>> cursor = table.cursor();
- int ii = SIZE-2;
+ Cursor<Tuple<String,String>> cursor = table.cursor();
+
+ int i = SIZE-2;
+
while ( cursor.previous() )
{
- Tuple<Integer,Integer> tuple = cursor.get();
- assertEquals( ii, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
- ii--;
+ Tuple<String,String> tuple = cursor.get();
+ assertEquals( i, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
+ i--;
}
}
@@ -166,34 +203,40 @@
@Test
public void testNextDups() throws Exception
{
- for ( int ii = 0; ii < SIZE*3; ii++ )
+ for ( int i = 0; i < SIZE*3; i++ )
{
- if ( ii > 12 && ii < 17 + SIZE )
+ String istr = Integer.toString( i );
+
+ if ( i > 12 && i < 17 + SIZE )
{
- table.put( 13, ii );
+ table.put( "13", istr );
}
else
{
- table.put( ii, ii );
+ table.put( istr, istr );
}
}
- Cursor<Tuple<Integer,Integer>> cursor = table.cursor();
+
+ Cursor<Tuple<String,String>> cursor = table.cursor();
- int ii = 0;
+ int i = 0;
+
while ( cursor.next() )
{
- Tuple<Integer,Integer> tuple = cursor.get();
- if ( ii > 12 && ii < 17 + SIZE )
+ Tuple<String,String> tuple = cursor.get();
+
+ if ( i > 12 && i < 17 + SIZE )
{
- assertEquals( 13, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( 13, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
else
{
- assertEquals( ii, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( i, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
- ii++;
+
+ i++;
}
}
@@ -201,35 +244,42 @@
@Test
public void testPreviousDups() throws Exception
{
- for ( int ii = 0; ii < SIZE*3; ii++ )
+ for ( int i = 0; i < SIZE*3; i++ )
{
- if ( ii > 12 && ii < 17 + SIZE )
+ String istr = Integer.toString( i );
+
+ if ( i > 12 && i < 17 + SIZE )
{
- table.put( 13, ii );
+ table.put( "13", Integer.toString( i ) );
}
else
{
- table.put( ii, ii );
+
+ table.put( istr, istr );
}
}
- Cursor<Tuple<Integer,Integer>> cursor = table.cursor();
+
+ Cursor<Tuple<String,String>> cursor = table.cursor();
cursor.afterLast();
- int ii = SIZE*3 - 1;
+ int i = SIZE*3 - 1;
+
while ( cursor.previous() )
{
- Tuple<Integer,Integer> tuple = cursor.get();
- if ( ii > 12 && ii < 17 + SIZE )
+ Tuple<String,String> tuple = cursor.get();
+
+ if ( i > 12 && i < 17 + SIZE )
{
- assertEquals( 13, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( 13, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
else
{
- assertEquals( ii, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( i, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
- ii--;
+
+ i--;
}
}
@@ -237,112 +287,129 @@
@Test
public void testFirstLastUnderDupLimit() throws Exception
{
- for ( int ii = 0; ii < SIZE*2 - 1; ii++ )
+ for ( int i = 0; i < SIZE*2 - 1; i++ )
{
- if ( ii > 12 && ii < 17 )
+ String istr = Integer.toString( i );
+
+ if ( i > 12 && i < 17 )
{
- table.put( 13, ii );
+ table.put( "13", istr );
}
else
{
- table.put( ii, ii );
+ table.put( istr, istr );
}
}
- Cursor<Tuple<Integer,Integer>> cursor = table.cursor();
+
+ Cursor<Tuple<String,String>> cursor = table.cursor();
- int ii = 0;
+ int i = 0;
+
while ( cursor.next() )
{
- Tuple<Integer,Integer> tuple = cursor.get();
- if ( ii > 12 && ii < 17 )
+ Tuple<String,String> tuple = cursor.get();
+ if ( i > 12 && i < 17 )
{
- assertEquals( 13, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( 13, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
else
{
- assertEquals( ii, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( i, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
- ii++;
+
+ i++;
}
cursor.first();
- ii = 0;
+ i = 0;
+
do
{
- Tuple<Integer,Integer> tuple = cursor.get();
- if ( ii > 12 && ii < 17 )
+ Tuple<String,String> tuple = cursor.get();
+
+ if ( i > 12 && i < 17 )
{
- assertEquals( 13, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( 13, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
else
{
- assertEquals( ii, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( i, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
- ii++;
+
+ i++;
}
while ( cursor.next() );
// now go backwards
cursor.afterLast();
- ii = SIZE*2-2;
+ i = SIZE*2-2;
+
while ( cursor.previous() )
{
- Tuple<Integer,Integer> tuple = cursor.get();
- if ( ii > 12 && ii < 17 )
+ Tuple<String,String> tuple = cursor.get();
+
+ if ( i > 12 && i < 17 )
{
- assertEquals( 13, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( 13, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
else
{
- assertEquals( ii, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( i, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
- ii--;
+
+ i--;
}
// now advance to last and go backwards again
cursor.last();
- ii = SIZE*2-2;
+ i = SIZE*2-2;
+
do
{
- Tuple<Integer,Integer> tuple = cursor.get();
- if ( ii > 12 && ii < 17 )
+ Tuple<String,String> tuple = cursor.get();
+
+ if ( i > 12 && i < 17 )
{
- assertEquals( 13, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( 13, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
else
{
- assertEquals( ii, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( i, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
- ii--;
+
+ i--;
}
while ( cursor.previous() );
// advance to first then last and go backwards again
cursor.beforeFirst();
cursor.afterLast();
- ii = SIZE*2-2;
+ i = SIZE*2-2;
+
while ( cursor.previous() )
{
- Tuple<Integer,Integer> tuple = cursor.get();
- if ( ii > 12 && ii < 17 )
+ Tuple<String,String> tuple = cursor.get();
+
+ if ( i > 12 && i < 17 )
{
- assertEquals( 13, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( 13, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
else
{
- assertEquals( ii, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( i, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
- ii--;
+
+ i--;
}
}
@@ -350,114 +417,131 @@
@Test
public void testFirstLastOverDupLimit() throws Exception
{
- for ( int ii = 0; ii < SIZE*3-1; ii++ )
+ for ( int i = 0; i < SIZE*3-1; i++ )
{
- if ( ii < 2 + SIZE ) // keys with multiple values
+ String istr = Integer.toString( i );
+
+ if ( i < 2 + SIZE ) // keys with multiple values
{
- table.put( 0, ii );
+ table.put( "0", istr );
}
else // keys with single values
{
- table.put( ii, ii );
+ table.put( istr, istr );
}
}
- Cursor<Tuple<Integer,Integer>> cursor = table.cursor();
+
+ Cursor<Tuple<String,String>> cursor = table.cursor();
- int ii = 0;
+ int i = 0;
+
while ( cursor.next() )
{
- Tuple<Integer,Integer> tuple = cursor.get();
- if ( ii < 2 + SIZE )
+ Tuple<String,String> tuple = cursor.get();
+
+ if ( i < 2 + SIZE )
{
- assertEquals( 0, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( 0, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
else
{
- assertEquals( ii, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( i, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
- ii++;
+
+ i++;
}
// now go back to first and traverse all over again
cursor.first();
- ii = 0;
+ i = 0;
+
do
{
- Tuple<Integer,Integer> tuple = cursor.get();
- if ( ii < 2 + SIZE )
+ Tuple<String,String> tuple = cursor.get();
+
+ if ( i < 2 + SIZE )
{
- assertEquals( 0, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( 0, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
else
{
- assertEquals( ii, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( i, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
- ii++;
+
+ i++;
}
while ( cursor.next() );
// now go backwards
cursor.afterLast();
- ii = SIZE*3-2;
+ i = SIZE*3-2;
+
while ( cursor.previous() )
{
- Tuple<Integer,Integer> tuple = cursor.get();
+ Tuple<String,String> tuple = cursor.get();
- if ( ii < 2 + SIZE )
+ if ( i < 2 + SIZE )
{
- assertEquals( 0, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( 0, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
else
{
- assertEquals( ii, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( i, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
- ii--;
+
+ i--;
}
// now advance to last and go backwards again
cursor.last();
- ii = SIZE*3-2;
+ i = SIZE*3-2;
+
do
{
- Tuple<Integer,Integer> tuple = cursor.get();
- if ( ii < 2 + SIZE )
+ Tuple<String,String> tuple = cursor.get();
+
+ if ( i < 2 + SIZE )
{
- assertEquals( 0, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( 0, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
else
{
- assertEquals( ii, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( i, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
- ii--;
+
+ i--;
}
while ( cursor.previous() );
// advance to first then last and go backwards again
cursor.beforeFirst();
cursor.afterLast();
- ii = SIZE*3-2;
+ i = SIZE*3-2;
+
while ( cursor.previous() )
{
- Tuple<Integer,Integer> tuple = cursor.get();
- if ( ii < 2 + SIZE )
+ Tuple<String,String> tuple = cursor.get();
+
+ if ( i < 2 + SIZE )
{
- assertEquals( 0, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( 0, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
else
{
- assertEquals( ii, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( i, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
- ii--;
+
+ i--;
}
}
@@ -465,231 +549,260 @@
@Test
public void testFirstOverDupLimit() throws Exception
{
- for ( int ii = 0; ii < SIZE*3-1; ii++ )
+ for ( int i = 0; i < SIZE*3-1; i++ )
{
- if ( ii < 2 + SIZE ) // keys with multiple values
+ String istr = Integer.toString( i );
+
+ if ( i < 2 + SIZE ) // keys with multiple values
{
- table.put( 0, ii );
+ table.put( "0", istr );
}
else // keys with single values
{
- table.put( ii, ii );
+ table.put( istr, istr );
}
}
- Cursor<Tuple<Integer,Integer>> cursor = table.cursor();
+
+ Cursor<Tuple<String,String>> cursor = table.cursor();
- int ii = 0;
+ int i = 0;
+
while ( cursor.next() )
{
- Tuple<Integer,Integer> tuple = cursor.get();
- if ( ii < 2 + SIZE )
+ Tuple<String,String> tuple = cursor.get();
+
+ if ( i < 2 + SIZE )
{
- assertEquals( 0, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( 0, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
else
{
- assertEquals( ii, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( i, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
- ii++;
+
+ i++;
}
// now go back to first and traverse all over again
cursor.first();
- ii = 0;
+ i = 0;
do
{
- Tuple<Integer,Integer> tuple = cursor.get();
- if ( ii < 2 + SIZE )
+ Tuple<String,String> tuple = cursor.get();
+
+ if ( i < 2 + SIZE )
{
- assertEquals( 0, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( 0, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
else
{
- assertEquals( ii, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( i, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
- ii++;
+
+ i++;
}
while ( cursor.next() );
// now go backwards
cursor.afterLast();
- ii = SIZE*3-2;
+ i = SIZE*3-2;
+
while ( cursor.previous() )
{
- Tuple<Integer,Integer> tuple = cursor.get();
+ Tuple<String,String> tuple = cursor.get();
- if ( ii < 2 + SIZE )
+ if ( i < 2 + SIZE )
{
- assertEquals( 0, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( 0, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
else
{
- assertEquals( ii, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( i, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
- ii--;
+ i--;
}
// now advance to last and go backwards again
cursor.last();
- ii = SIZE*3-2;
+ i = SIZE*3-2;
+
do
{
- Tuple<Integer,Integer> tuple = cursor.get();
- if ( ii < 2 + SIZE )
+ Tuple<String,String> tuple = cursor.get();
+ if ( i < 2 + SIZE )
{
- assertEquals( 0, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( 0, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
else
{
- assertEquals( ii, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( i, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
- ii--;
+
+ i--;
}
while ( cursor.previous() );
// advance to first then last and go backwards again
cursor.beforeFirst();
cursor.afterLast();
- ii = SIZE*3-2;
+ i = SIZE*3-2;
+
while ( cursor.previous() )
{
- Tuple<Integer,Integer> tuple = cursor.get();
- if ( ii < 2 + SIZE )
+ Tuple<String,String> tuple = cursor.get();
+
+ if ( i < 2 + SIZE )
{
- assertEquals( 0, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( 0, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
else
{
- assertEquals( ii, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( i, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
- ii--;
+
+ i--;
}
}
-
-
@Test
public void testLastOverDupLimit() throws Exception
{
- for ( int ii = 0; ii < SIZE*3-1; ii++ )
+ for ( int i = 0; i < SIZE*3-1; i++ )
{
- if ( ii > 2 + SIZE ) // keys with multiple values
+ String istr = Integer.toString( i );
+
+ if ( i > 2 + SIZE ) // keys with multiple values
{
- table.put( 3 + SIZE, ii );
+ table.put( Integer.toString( 3 + SIZE ), istr );
}
else // keys with single values
{
- table.put( ii, ii );
+ table.put( istr, istr );
}
}
- Cursor<Tuple<Integer,Integer>> cursor = table.cursor();
+
+ Cursor<Tuple<String,String>> cursor = table.cursor();
- int ii = 0;
+ int i = 0;
+
while ( cursor.next() )
{
- Tuple<Integer,Integer> tuple = cursor.get();
- if ( ii > 2 + SIZE )
+ Tuple<String,String> tuple = cursor.get();
+
+ if ( i > 2 + SIZE )
{
- assertEquals( 3 + SIZE, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( 3 + SIZE, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
else
{
- assertEquals( ii, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( i, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
- ii++;
+
+ i++;
}
// now go back to first and traverse all over again
cursor.first();
- ii = 0;
+ i = 0;
+
do
{
- Tuple<Integer,Integer> tuple = cursor.get();
- if ( ii > 2 + SIZE )
+ Tuple<String,String> tuple = cursor.get();
+
+ if ( i > 2 + SIZE )
{
- assertEquals( 3 + SIZE, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( 3 + SIZE, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
else
{
- assertEquals( ii, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( i, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
- ii++;
+
+ i++;
}
while ( cursor.next() );
// now go backwards
cursor.afterLast();
- ii = SIZE*3-2;
+ i = SIZE*3-2;
+
while ( cursor.previous() )
{
- Tuple<Integer,Integer> tuple = cursor.get();
+ Tuple<String,String> tuple = cursor.get();
- if ( ii > 2 + SIZE )
+ if ( i > 2 + SIZE )
{
- assertEquals( 3 + SIZE, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( 3 + SIZE, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
else
{
- assertEquals( ii, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( i, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
- ii--;
+
+ i--;
}
// now advance to last and go backwards again
cursor.last();
- ii = SIZE*3-2;
+ i = SIZE*3-2;
+
do
{
- Tuple<Integer,Integer> tuple = cursor.get();
- if ( ii > 2 + SIZE )
+ Tuple<String,String> tuple = cursor.get();
+
+ if ( i > 2 + SIZE )
{
- assertEquals( 3 + SIZE, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( 3 + SIZE, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
else
{
- assertEquals( ii, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( i, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
- ii--;
+
+ i--;
}
while ( cursor.previous() );
// advance to first then last and go backwards again
cursor.beforeFirst();
cursor.afterLast();
- ii = SIZE*3-2;
+ i = SIZE*3-2;
+
while ( cursor.previous() )
{
- Tuple<Integer,Integer> tuple = cursor.get();
- if ( ii > 2 + SIZE )
+ Tuple<String,String> tuple = cursor.get();
+
+ if ( i > 2 + SIZE )
{
- assertEquals( 3 + SIZE, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( 3 + SIZE, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
else
{
- assertEquals( ii, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( i, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
- ii--;
+
+ i--;
}
}
@@ -697,11 +810,11 @@
@Test
public void testOnEmptyTable() throws Exception
{
- Cursor<Tuple<Integer,Integer>> cursor = table.cursor();
+ Cursor<Tuple<String,String>> cursor = table.cursor();
assertNotNull( cursor );
assertFalse( cursor.isClosed() );
- cursor.before( new Tuple<Integer, Integer>( 1, 2 ) );
+ cursor.before( new Tuple<String, String>( "1", "2" ) );
assertFalse( cursor.available() );
}
@@ -709,20 +822,22 @@
@Test
public void testOverDupLimit() throws Exception
{
- table.put( 5, 5 );
- table.put( 6, 6 );
- for ( int ii = 0; ii < 20; ii++ )
+ table.put( "5", "5" );
+ table.put( "6", "6" );
+
+ for ( int i = 0; i < 20; i++ )
{
- table.put( 7, ii );
+ table.put( "7", Integer.toString( i ) );
}
- table.put( 8, 8 );
- table.put( 9, 9 );
- Cursor<Tuple<Integer,Integer>> cursor = table.cursor();
+ table.put( "8", "8" );
+ table.put( "9", "9" );
+
+ Cursor<Tuple<String,String>> cursor = table.cursor();
assertNotNull( cursor );
assertFalse( cursor.isClosed() );
- cursor.before( new Tuple<Integer, Integer>( 7, 2 ) );
+ cursor.before( new Tuple<String, String>( "7", "2" ) );
assertFalse( cursor.available() );
}
@@ -730,20 +845,22 @@
@Test
public void testUnderDupLimit() throws Exception
{
- table.put( 5, 5 );
- table.put( 6, 6 );
- for ( int ii = 0; ii < 10; ii++ )
+ table.put( "5", "5" );
+ table.put( "6", "6" );
+
+ for ( int i = 0; i < 10; i++ )
{
- table.put( 7, ii );
+ table.put( "7", Integer.toString( i ) );
}
- table.put( 8, 8 );
- table.put( 9, 9 );
- Cursor<Tuple<Integer,Integer>> cursor = table.cursor();
+ table.put( "8", "8" );
+ table.put( "9", "9" );
+
+ Cursor<Tuple<String,String>> cursor = table.cursor();
assertNotNull( cursor );
assertFalse( cursor.isClosed() );
- cursor.before( new Tuple<Integer, Integer>( 7, 2 ) );
+ cursor.before( new Tuple<String, String>( "7", "2" ) );
assertFalse( cursor.available() );
}
@@ -751,261 +868,279 @@
@Test
public void testBeforeAfterBelowDupLimit() throws Exception
{
- for ( int ii = 0; ii < SIZE*2 - 1; ii++ )
+ for ( int i = 0; i < SIZE*2 - 1; i++ )
{
- if ( ii > 12 && ii < 17 ) // keys with multiple values
+ String istr = Integer.toString( i );
+
+ if ( i > 12 && i < 17 ) // keys with multiple values
{
- table.put( 13, ii );
+ table.put( "13", Integer.toString( i ) );
}
- else if ( ii > 17 && ii < 21 ) // adds hole with no keys for ii
+ else if ( i > 17 && i < 21 ) // adds hole with no keys for i
{
}
else // keys with single values
{
- table.put( ii, ii );
+ table.put( istr, istr );
}
}
// test before to advance just before a key with a single value
- int ii = 5;
- Cursor<Tuple<Integer,Integer>> cursor = table.cursor();
- cursor.before( new Tuple<Integer,Integer>( 5, 5 ) );
+ int i = 5;
+ Cursor<Tuple<String,String>> cursor = table.cursor();
+ cursor.before( new Tuple<String,String>( "5", "5" ) );
+
while ( cursor.next() )
{
- if ( ii > 17 && ii < 21 )
+ if ( i > 17 && i < 21 )
{
- assertFalse( table.has( ii ) );
+ assertFalse( table.has( Integer.toString( i ) ) );
continue;
}
- Tuple<Integer,Integer> tuple = cursor.get();
- if ( ii > 12 && ii < 17 )
+ Tuple<String,String> tuple = cursor.get();
+
+ if ( i > 12 && i < 17 )
{
- assertEquals( 13, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( 13, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
else
{
- assertEquals( ii, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( i, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
- ii++;
+
+ i++;
}
// test before to advance just before a key with a single value but
// with a null tuple value which should not advance the dupsCursor
- ii = 5;
+ i = 5;
cursor = table.cursor();
- cursor.before( new Tuple<Integer,Integer>( 5, null ) );
+ cursor.before( new Tuple<String,String>( "5", null ) );
+
while ( cursor.next() )
{
- if ( ii > 17 && ii < 21 )
+ if ( i > 17 && i < 21 )
{
- assertFalse( table.has( ii ) );
+ assertFalse( table.has( Integer.toString( i ) ) );
continue;
}
- Tuple<Integer,Integer> tuple = cursor.get();
- if ( ii > 12 && ii < 17 )
+ Tuple<String,String> tuple = cursor.get();
+ if ( i > 12 && i < 17 )
{
- assertEquals( 13, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( 13, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
else
{
- assertEquals( ii, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( i, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
- ii++;
+ i++;
}
// test before to advance just before a key value pair where the key
// does not exist - using value so we hit check for key equality
- ii = 21;
+ i = 21;
cursor = table.cursor();
- cursor.before( new Tuple<Integer,Integer>( 18, 18 ) );
+ cursor.before( new Tuple<String,String>( "18", "18" ) );
+
while ( cursor.next() )
{
- if ( ii > 17 && ii < 21 )
+ if ( i > 17 && i < 21 )
{
- assertFalse( table.has( ii ) );
+ assertFalse( table.has( Integer.toString( i ) ) );
continue;
}
- Tuple<Integer,Integer> tuple = cursor.get();
- if ( ii > 12 && ii < 17 )
+ Tuple<String,String> tuple = cursor.get();
+
+ if ( i > 12 && i < 17 )
{
- assertEquals( 13, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( 13, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
else
{
- assertEquals( ii, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( i, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
- ii++;
+
+ i++;
}
// test after to advance just after the end
cursor = table.cursor();
- cursor.after( new Tuple<Integer,Integer>( 111, null ) );
+ cursor.after( new Tuple<String,String>( "111", null ) );
assertFalse( cursor.next() );
// test after to advance just before a key with a single value
- ii = 6;
+ i = 6;
cursor = table.cursor();
- cursor.after( new Tuple<Integer,Integer>( 5, null ) );
+ cursor.after( new Tuple<String,String>( "5", null ) );
+
while ( cursor.next() )
{
- if ( ii > 17 && ii < 21 )
+ if ( i > 17 && i < 21 )
{
- assertFalse( table.has( ii ) );
+ assertFalse( table.has( Integer.toString( i ) ) );
continue;
}
- Tuple<Integer,Integer> tuple = cursor.get();
- if ( ii > 12 && ii < 17 )
+ Tuple<String,String> tuple = cursor.get();
+
+ if ( i > 12 && i < 17 )
{
- assertEquals( 13, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( 13, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
else
{
- assertEquals( ii, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( i, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
- ii++;
+
+ i++;
}
// test before to advance just before a key & value with multiple
// values for the key - we should advance just before the value
cursor = table.cursor();
- cursor.before( new Tuple<Integer,Integer>( 13, 14 ) );
+ cursor.before( new Tuple<String,String>( "13", "14" ) );
cursor.next();
- Tuple<Integer,Integer> tuple = cursor.get();
- assertEquals( 13, ( int ) tuple.getKey() );
- assertEquals( 14, ( int ) tuple.getValue() );
- ii = 15;
+ Tuple<String,String> tuple = cursor.get();
+ assertEquals( 13, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( 14, Integer.parseInt( tuple.getValue() ) );
+ i = 15;
while ( cursor.next() )
{
- if ( ii > 17 && ii < 21 )
+ if ( i > 17 && i < 21 )
{
- assertFalse( table.has( ii ) );
+ assertFalse( table.has( Integer.toString( i ) ) );
continue;
}
tuple = cursor.get();
- if ( ii > 12 && ii < 17 )
+ if ( i > 12 && i < 17 )
{
- assertEquals( 13, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( 13, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
else
{
- assertEquals( ii, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( i, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
- ii++;
+ i++;
}
// test after to advance just before a key & value with multiple
// values for the key - we should advance just before the value
cursor = table.cursor();
- cursor.after( new Tuple<Integer,Integer>( 13, 14 ) );
+ cursor.after( new Tuple<String,String>( "13", "14" ) );
cursor.next();
tuple = cursor.get();
- assertEquals( 13, ( int ) tuple.getKey() );
- assertEquals( 15, ( int ) tuple.getValue() );
- ii=16;
+ assertEquals( 13, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( 15, Integer.parseInt( tuple.getValue() ) );
+ i=16;
while ( cursor.next() )
{
- if ( ii > 17 && ii < 21 )
+ if ( i > 17 && i < 21 )
{
- assertFalse( table.has( ii ) );
+ assertFalse( table.has( Integer.toString( i ) ) );
continue;
}
tuple = cursor.get();
- if ( ii > 12 && ii < 17 )
+
+ if ( i > 12 && i < 17 )
{
- assertEquals( 13, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( 13, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
else
{
- assertEquals( ii, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( i, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
- ii++;
+
+ i++;
}
// test after to advance just before a key that does not exist
cursor = table.cursor();
- cursor.after( new Tuple<Integer,Integer>( 18, null ) );
+ cursor.after( new Tuple<String,String>( "18", null ) );
cursor.next();
tuple = cursor.get();
- assertEquals( 21, ( int ) tuple.getKey() );
- assertEquals( 21, ( int ) tuple.getValue() );
- ii=22;
+ assertEquals( 21, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( 21, Integer.parseInt( tuple.getValue() ) );
+ i=22;
while ( cursor.next() )
{
- if ( ii > 17 && ii < 21 )
+ if ( i > 17 && i < 21 )
{
- assertFalse( table.has( ii ) );
+ assertFalse( table.has( Integer.toString( i ) ) );
continue;
}
tuple = cursor.get();
- if ( ii > 12 && ii < 17 )
+
+ if ( i > 12 && i < 17 )
{
- assertEquals( 13, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( 13, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
else
{
- assertEquals( ii, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( i, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
- ii++;
+
+ i++;
}
// test after to advance just before a key and value where the key
// does not exist - used to force key comparison in after()
cursor = table.cursor();
- cursor.after( new Tuple<Integer,Integer>( 18, 18 ) );
+ cursor.after( new Tuple<String,String>( "18", "18" ) );
cursor.next();
tuple = cursor.get();
- assertEquals( 21, ( int ) tuple.getKey() );
- assertEquals( 21, ( int ) tuple.getValue() );
- ii=22;
+ assertEquals( 21, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( 21, Integer.parseInt( tuple.getValue() ) );
+ i=22;
while ( cursor.next() )
{
- if ( ii > 17 && ii < 21 )
+ if ( i > 17 && i < 21 )
{
- assertFalse( table.has( ii ) );
+ assertFalse( table.has( Integer.toString( i ) ) );
continue;
}
tuple = cursor.get();
- if ( ii > 12 && ii < 17 )
+
+ if ( i > 12 && i < 17 )
{
- assertEquals( 13, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( 13, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
else
{
- assertEquals( ii, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( i, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
- ii++;
+
+ i++;
}
}
@@ -1013,261 +1148,282 @@
@Test
public void testBeforeAfterOverDupLimit() throws Exception
{
- for ( int ii = 0; ii < SIZE*3 - 1; ii++ )
+ for ( int i = 0; i < SIZE*3 - 1; i++ )
{
- if ( ii > 12 && ii < 17 + SIZE ) // keys with multiple values
+ String istr = Integer.toString( i );
+
+ if ( i > 12 && i < 17 + SIZE ) // keys with multiple values
{
- table.put( 13, ii );
+ table.put( "13", Integer.toString( i ) );
}
- else if ( ii > 17 + SIZE && ii < 21 + SIZE ) // adds hole with no keys for ii
+ else if ( i > 17 + SIZE && i < 21 + SIZE ) // adds hole with no keys for i
{
}
else // keys with single values
{
- table.put( ii, ii );
+ table.put( istr, istr );
}
}
// test before to advance just before a key with a single value
- int ii = 5;
- Cursor<Tuple<Integer,Integer>> cursor = table.cursor();
- cursor.before( new Tuple<Integer,Integer>( 5, 5 ) );
+ int i = 5;
+ Cursor<Tuple<String,String>> cursor = table.cursor();
+ cursor.before( new Tuple<String,String>( "5", "5" ) );
+
while ( cursor.next() )
{
- if ( ii > 17 + SIZE && ii < 21 + SIZE )
+ if ( i > 17 + SIZE && i < 21 + SIZE )
{
- assertFalse( table.has( ii ) );
+ assertFalse( table.has( Integer.toString( i ) ) );
continue;
}
- Tuple<Integer,Integer> tuple = cursor.get();
- if ( ii > 12 && ii < 17 + SIZE )
+ Tuple<String,String> tuple = cursor.get();
+
+ if ( i > 12 && i < 17 + SIZE )
{
- assertEquals( 13, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( 13, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
else
{
- assertEquals( ii, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( i, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
- ii++;
+
+ i++;
}
// test before to advance just before a key with a single value but
// with a null tuple value which should not advance the dupsCursor
- ii = 5;
+ i = 5;
cursor = table.cursor();
- cursor.before( new Tuple<Integer,Integer>( 5, null ) );
+ cursor.before( new Tuple<String,String>( "5", null ) );
+
while ( cursor.next() )
{
- if ( ii > 17 + SIZE && ii < 21 + SIZE )
+ if ( i > 17 + SIZE && i < 21 + SIZE )
{
- assertFalse( table.has( ii ) );
+ assertFalse( table.has( Integer.toString( i ) ) );
continue;
}
- Tuple<Integer,Integer> tuple = cursor.get();
- if ( ii > 12 && ii < 17 + SIZE )
+ Tuple<String,String> tuple = cursor.get();
+
+ if ( i > 12 && i < 17 + SIZE )
{
- assertEquals( 13, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( 13, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
else
{
- assertEquals( ii, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( i, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
- ii++;
+ i++;
}
// test before to advance just before a key value pair where the key
// does not exist - using value so we hit check for key equality
- ii = 21 + SIZE;
+ i = 21 + SIZE;
cursor = table.cursor();
- cursor.before( new Tuple<Integer,Integer>( 18 + SIZE, 18 + SIZE ) );
+ String istr = Integer.toString( 18 + SIZE );
+
+ cursor.before( new Tuple<String,String>( istr, istr ) );
+
while ( cursor.next() )
{
- if ( ii > 17 + SIZE && ii < 21 + SIZE )
+ if ( i > 17 + SIZE && i < 21 + SIZE )
{
- assertFalse( table.has( ii ) );
+ assertFalse( table.has( Integer.toString( i ) ) );
continue;
}
- Tuple<Integer,Integer> tuple = cursor.get();
- if ( ii > 12 && ii < 17 + SIZE )
+ Tuple<String,String> tuple = cursor.get();
+
+ if ( i > 12 && i < 17 + SIZE )
{
- assertEquals( 13, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( 13, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
else
{
- assertEquals( ii, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( i, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
- ii++;
+
+ i++;
}
// test after to advance just after the end
cursor = table.cursor();
- cursor.after( new Tuple<Integer,Integer>( 111, null ) );
+ cursor.after( new Tuple<String,String>( "111", null ) );
assertFalse( cursor.next() );
// test after to advance just before a key with a single value
- ii = 6;
+ i = 6;
cursor = table.cursor();
- cursor.after( new Tuple<Integer,Integer>( 5, null ) );
+ cursor.after( new Tuple<String,String>( "5", null ) );
+
while ( cursor.next() )
{
- if ( ii > 17 + SIZE && ii < 21 + SIZE )
+ if ( i > 17 + SIZE && i < 21 + SIZE )
{
- assertFalse( table.has( ii ) );
+ assertFalse( table.has( Integer.toString( i ) ) );
continue;
}
- Tuple<Integer,Integer> tuple = cursor.get();
- if ( ii > 12 && ii < 17 + SIZE )
+ Tuple<String,String> tuple = cursor.get();
+
+ if ( i > 12 && i < 17 + SIZE )
{
- assertEquals( 13, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( 13, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
else
{
- assertEquals( ii, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( i, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
- ii++;
+
+ i++;
}
// test before to advance just before a key & value with multiple
// values for the key - we should advance just before the value
cursor = table.cursor();
- cursor.before( new Tuple<Integer,Integer>( 13, 14 ) );
+ cursor.before( new Tuple<String,String>( "13", "14" ) );
cursor.next();
- Tuple<Integer,Integer> tuple = cursor.get();
- assertEquals( 13, ( int ) tuple.getKey() );
- assertEquals( 14, ( int ) tuple.getValue() );
- ii = 15;
+ Tuple<String,String> tuple = cursor.get();
+ assertEquals( 13, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( 14, Integer.parseInt( tuple.getValue() ) );
+ i = 15;
while ( cursor.next() )
{
- if ( ii > 17 + SIZE && ii < 21 + SIZE )
+ if ( i > 17 + SIZE && i < 21 + SIZE )
{
- assertFalse( table.has( ii ) );
+ assertFalse( table.has( Integer.toString( i ) ) );
continue;
}
tuple = cursor.get();
- if ( ii > 12 && ii < 17 + SIZE )
+
+ if ( i > 12 && i < 17 + SIZE )
{
- assertEquals( 13, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( 13, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
else
{
- assertEquals( ii, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( i, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
- ii++;
+
+ i++;
}
// test after to advance just before a key & value with multiple
// values for the key - we should advance just before the value
cursor = table.cursor();
- cursor.after( new Tuple<Integer,Integer>( 13, 14 ) );
+ cursor.after( new Tuple<String,String>( "13", "14" ) );
cursor.next();
tuple = cursor.get();
- assertEquals( 13, ( int ) tuple.getKey() );
- assertEquals( 15, ( int ) tuple.getValue() );
- ii=16;
+ assertEquals( 13, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( 15, Integer.parseInt( tuple.getValue() ) );
+ i=16;
while ( cursor.next() )
{
- if ( ii > 17 + SIZE && ii < 21 + SIZE )
+ if ( i > 17 + SIZE && i < 21 + SIZE )
{
- assertFalse( table.has( ii ) );
+ assertFalse( table.has( Integer.toString( i ) ) );
continue;
}
tuple = cursor.get();
- if ( ii > 12 && ii < 17 + SIZE )
+
+ if ( i > 12 && i < 17 + SIZE )
{
- assertEquals( 13, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( 13, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
else
{
- assertEquals( ii, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( i, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
- ii++;
+
+ i++;
}
// test after to advance just before a key that does not exist
cursor = table.cursor();
- cursor.after( new Tuple<Integer,Integer>( 18 + SIZE, null ) );
+ cursor.after( new Tuple<String,String>( Integer.toString( 18 + SIZE ), null ) );
cursor.next();
tuple = cursor.get();
- assertEquals( 21 + SIZE, ( int ) tuple.getKey() );
- assertEquals( 21 + SIZE, ( int ) tuple.getValue() );
- ii=22 + SIZE;
+ assertEquals( 21 + SIZE, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( 21 + SIZE, Integer.parseInt( tuple.getValue() ) );
+ i=22 + SIZE;
while ( cursor.next() )
{
- if ( ii > 17 + SIZE && ii < 21 + SIZE )
+ if ( i > 17 + SIZE && i < 21 + SIZE )
{
- assertFalse( table.has( ii ) );
+ assertFalse( table.has( Integer.toString( i ) ) );
continue;
}
tuple = cursor.get();
- if ( ii > 12 && ii < 17 + SIZE )
+ if ( i > 12 && i < 17 + SIZE )
{
- assertEquals( 13, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( 13, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
else
{
- assertEquals( ii, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( i, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
- ii++;
+ i++;
}
// test after to advance just before a key and value where the key
// does not exist - used to force key comparison in after()
cursor = table.cursor();
- cursor.after( new Tuple<Integer,Integer>( 18 + SIZE , 18 + SIZE ) );
+ cursor.after( new Tuple<String,String>( istr, istr ) );
cursor.next();
tuple = cursor.get();
- assertEquals( 21 + SIZE, ( int ) tuple.getKey() );
- assertEquals( 21 + SIZE, ( int ) tuple.getValue() );
- ii=22+ SIZE;
+ assertEquals( 21 + SIZE, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( 21 + SIZE, Integer.parseInt( tuple.getValue() ) );
+ i=22+ SIZE;
while ( cursor.next() )
{
- if ( ii > 17 + SIZE && ii < 21 + SIZE )
+ if ( i > 17 + SIZE && i < 21 + SIZE )
{
- assertFalse( table.has( ii ) );
+ assertFalse( table.has( Integer.toString( i ) ) );
continue;
}
tuple = cursor.get();
- if ( ii > 12 && ii < 17 + SIZE )
+
+ if ( i > 12 && i < 17 + SIZE )
{
- assertEquals( 13, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( 13, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
else
{
- assertEquals( ii, ( int ) tuple.getKey() );
- assertEquals( ii, ( int ) tuple.getValue() );
+ assertEquals( i, Integer.parseInt( tuple.getKey() ) );
+ assertEquals( i, Integer.parseInt( tuple.getValue() ) );
}
- ii++;
+
+ i++;
}
}
@@ -1275,7 +1431,7 @@
@Test
public void testMiscellaneous() throws Exception
{
- Cursor<Tuple<Integer,Integer>> cursor = table.cursor();
+ Cursor<Tuple<String,String>> cursor = table.cursor();
assertNotNull( cursor );
assertTrue( cursor.isElementReused() );
Modified: directory/apacheds/branches/apacheds-schema/jdbm-store/src/test/java/org/apache/directory/server/core/partition/impl/btree/jdbm/JdbmIndexTest.java
URL: http://svn.apache.org/viewvc/directory/apacheds/branches/apacheds-schema/jdbm-store/src/test/java/org/apache/directory/server/core/partition/impl/btree/jdbm/JdbmIndexTest.java?rev=833647&r1=833646&r2=833647&view=diff
==============================================================================
--- directory/apacheds/branches/apacheds-schema/jdbm-store/src/test/java/org/apache/directory/server/core/partition/impl/btree/jdbm/JdbmIndexTest.java (original)
+++ directory/apacheds/branches/apacheds-schema/jdbm-store/src/test/java/org/apache/directory/server/core/partition/impl/btree/jdbm/JdbmIndexTest.java Sat Nov 7 07:57:34 2009
@@ -37,9 +37,7 @@
import org.apache.directory.shared.ldap.cursor.Cursor;
import org.apache.directory.shared.ldap.schema.AttributeType;
import org.apache.directory.shared.ldap.schema.SchemaManager;
-import org.apache.directory.shared.ldap.schema.comparators.SerializableComparator;
import org.apache.directory.shared.ldap.schema.ldif.extractor.SchemaLdifExtractor;
-import org.apache.directory.shared.ldap.schema.registries.AttributeTypeRegistry;
import org.apache.directory.shared.ldap.util.ExceptionUtils;
import org.apache.directory.shared.schema.DefaultSchemaManager;
import org.apache.directory.shared.schema.loader.ldif.LdifSchemaLoader;
@@ -57,9 +55,9 @@
*/
public class JdbmIndexTest
{
- private static AttributeTypeRegistry registry;
private static File dbFileDir;
Index<String,ServerEntry> idx;
+ private static SchemaManager schemaManager;
@BeforeClass
@@ -78,18 +76,14 @@
SchemaLdifExtractor extractor = new SchemaLdifExtractor( new File( workingDirectory ) );
extractor.extractOrCopy();
LdifSchemaLoader loader = new LdifSchemaLoader( schemaRepository );
- SchemaManager sm = new DefaultSchemaManager( loader );
+ schemaManager = new DefaultSchemaManager( loader );
- boolean loaded = sm.loadAllEnabled();
+ boolean loaded = schemaManager.loadAllEnabled();
if ( !loaded )
{
- fail( "Schema load failed : " + ExceptionUtils.printErrors( sm.getErrors() ) );
+ fail( "Schema load failed : " + ExceptionUtils.printErrors( schemaManager.getErrors() ) );
}
-
- SerializableComparator.setRegistry( sm.getRegistries().getComparatorRegistry() );
-
- registry = sm.getRegistries().getAttributeTypeRegistry();
}
@@ -151,7 +145,7 @@
jdbmIdx = new JdbmIndex<String,ServerEntry>();
}
- jdbmIdx.init( registry.lookup( SchemaConstants.OU_AT ), dbFileDir );
+ jdbmIdx.init( schemaManager, schemaManager.lookupAttributeTypeRegistry( SchemaConstants.OU_AT ), dbFileDir );
this.idx = jdbmIdx;
}
@@ -273,7 +267,7 @@
assertNull( jdbmIndex.getAttribute() );
initIndex();
- assertEquals( registry.lookup( "ou" ), idx.getAttribute() );
+ assertEquals( schemaManager.lookupAttributeTypeRegistry( "ou" ), idx.getAttribute() );
}
@@ -574,7 +568,7 @@
{
AttributeType noEqMatchAttribute = new AttributeType( "1.1" );
- jdbmIndex.init( noEqMatchAttribute, dbFileDir );
+ jdbmIndex.init( schemaManager, noEqMatchAttribute, dbFileDir );
fail( "should not get here" );
}
catch( IOException e )
@@ -592,7 +586,7 @@
public void testSingleValuedAttribute() throws Exception
{
JdbmIndex jdbmIndex = new JdbmIndex();
- jdbmIndex.init( registry.lookup( SchemaConstants.CREATORS_NAME_AT ), dbFileDir );
+ jdbmIndex.init( schemaManager, schemaManager.lookupAttributeTypeRegistry( SchemaConstants.CREATORS_NAME_AT ), dbFileDir );
jdbmIndex.close();
}
}
Modified: directory/apacheds/branches/apacheds-schema/jdbm-store/src/test/java/org/apache/directory/server/core/partition/impl/btree/jdbm/JdbmMasterTableTest.java
URL: http://svn.apache.org/viewvc/directory/apacheds/branches/apacheds-schema/jdbm-store/src/test/java/org/apache/directory/server/core/partition/impl/btree/jdbm/JdbmMasterTableTest.java?rev=833647&r1=833646&r2=833647&view=diff
==============================================================================
--- directory/apacheds/branches/apacheds-schema/jdbm-store/src/test/java/org/apache/directory/server/core/partition/impl/btree/jdbm/JdbmMasterTableTest.java (original)
+++ directory/apacheds/branches/apacheds-schema/jdbm-store/src/test/java/org/apache/directory/server/core/partition/impl/btree/jdbm/JdbmMasterTableTest.java Sat Nov 7 07:57:34 2009
@@ -31,8 +31,6 @@
import org.apache.directory.shared.ldap.schema.SchemaManager;
import org.apache.directory.shared.ldap.schema.ldif.extractor.SchemaLdifExtractor;
-import org.apache.directory.shared.ldap.schema.registries.AttributeTypeRegistry;
-import org.apache.directory.shared.ldap.schema.registries.Registries;
import org.apache.directory.shared.ldap.util.ExceptionUtils;
import org.apache.directory.shared.schema.DefaultSchemaManager;
import org.apache.directory.shared.schema.loader.ldif.LdifSchemaLoader;
@@ -57,8 +55,7 @@
transient JdbmMasterTable<Integer> table;
transient File dbFile;
transient RecordManager recman;
- transient Registries registries = null;
- transient AttributeTypeRegistry attributeRegistry;
+ transient SchemaManager schemaManager = null;
public JdbmMasterTableTest() throws Exception
@@ -76,18 +73,15 @@
SchemaLdifExtractor extractor = new SchemaLdifExtractor( new File( workingDirectory ) );
extractor.extractOrCopy();
LdifSchemaLoader loader = new LdifSchemaLoader( schemaRepository );
- Registries registries = new Registries();
- SchemaManager sm = new DefaultSchemaManager( loader );
+ schemaManager = new DefaultSchemaManager( loader );
- boolean loaded = sm.loadAllEnabled();
+ boolean loaded = schemaManager.loadAllEnabled();
if ( !loaded )
{
- fail( "Schema load failed : " + ExceptionUtils.printErrors( sm.getErrors() ) );
+ fail( "Schema load failed : " + ExceptionUtils.printErrors( schemaManager.getErrors() ) );
}
-
- attributeRegistry = sm.getRegistries().getAttributeTypeRegistry();
}
@@ -104,10 +98,10 @@
dbFile = File.createTempFile( getClass().getSimpleName(), "db", tmpDir );
recman = new BaseRecordManager( dbFile.getAbsolutePath() );
- table = new JdbmMasterTable<Integer>( recman, registries );
+ table = new JdbmMasterTable<Integer>( recman, schemaManager );
LOG.debug( "Created new table and populated it with data" );
- JdbmMasterTable<Integer> t2 = new JdbmMasterTable<Integer>( recman, registries );
+ JdbmMasterTable<Integer> t2 = new JdbmMasterTable<Integer>( recman, schemaManager );
t2.close();
}
Modified: directory/apacheds/branches/apacheds-schema/jdbm-store/src/test/java/org/apache/directory/server/core/partition/impl/btree/jdbm/JdbmStoreTest.java
URL: http://svn.apache.org/viewvc/directory/apacheds/branches/apacheds-schema/jdbm-store/src/test/java/org/apache/directory/server/core/partition/impl/btree/jdbm/JdbmStoreTest.java?rev=833647&r1=833646&r2=833647&view=diff
==============================================================================
--- directory/apacheds/branches/apacheds-schema/jdbm-store/src/test/java/org/apache/directory/server/core/partition/impl/btree/jdbm/JdbmStoreTest.java (original)
+++ directory/apacheds/branches/apacheds-schema/jdbm-store/src/test/java/org/apache/directory/server/core/partition/impl/btree/jdbm/JdbmStoreTest.java Sat Nov 7 07:57:34 2009
@@ -62,10 +62,7 @@
import org.apache.directory.shared.ldap.schema.AttributeType;
import org.apache.directory.shared.ldap.schema.SchemaManager;
import org.apache.directory.shared.ldap.schema.SchemaUtils;
-import org.apache.directory.shared.ldap.schema.comparators.SerializableComparator;
import org.apache.directory.shared.ldap.schema.ldif.extractor.SchemaLdifExtractor;
-import org.apache.directory.shared.ldap.schema.registries.AttributeTypeRegistry;
-import org.apache.directory.shared.ldap.schema.registries.Registries;
import org.apache.directory.shared.ldap.util.ExceptionUtils;
import org.apache.directory.shared.schema.DefaultSchemaManager;
import org.apache.directory.shared.schema.loader.ldif.LdifSchemaLoader;
@@ -90,8 +87,7 @@
File wkdir;
JdbmStore<ServerEntry> store;
- private static Registries registries = null;
- private static AttributeTypeRegistry attributeRegistry;
+ private static SchemaManager schemaManager = null;
private static LdifSchemaLoader loader;
@@ -111,18 +107,14 @@
SchemaLdifExtractor extractor = new SchemaLdifExtractor( new File( workingDirectory ) );
extractor.extractOrCopy();
loader = new LdifSchemaLoader( schemaRepository );
- SchemaManager sm = new DefaultSchemaManager( loader );
+ schemaManager = new DefaultSchemaManager( loader );
- boolean loaded = sm.loadAllEnabled();
+ boolean loaded = schemaManager.loadAllEnabled();
if ( !loaded )
{
- fail( "Schema load failed : " + ExceptionUtils.printErrors( sm.getErrors() ) );
+ fail( "Schema load failed : " + ExceptionUtils.printErrors( schemaManager.getErrors() ) );
}
-
- registries = sm.getRegistries();
- attributeRegistry = registries.getAttributeTypeRegistry();
- SerializableComparator.setRegistry( registries.getComparatorRegistry() );
}
@@ -143,10 +135,10 @@
store.setCacheSize( 10 );
store.setWorkingDirectory( wkdir );
store.setSyncOnWrite( false );
-
store.addIndex( new JdbmIndex( SchemaConstants.OU_AT_OID ) );
store.addIndex( new JdbmIndex( SchemaConstants.UID_AT_OID ) );
- StoreUtils.loadExampleData( store, registries );
+
+ StoreUtils.loadExampleData( store, schemaManager );
LOG.debug( "Created new store" );
}
@@ -347,7 +339,7 @@
public void testFreshStore() throws Exception
{
LdapDN dn = new LdapDN( "o=Good Times Co." );
- dn.normalize( attributeRegistry.getNormalizerMapping() );
+ dn.normalize( schemaManager.getNormalizerMapping() );
assertEquals( 1L, ( long ) store.getEntryId( dn.toNormName() ) );
assertEquals( 11, store.count() );
assertEquals( "o=Good Times Co.", store.getEntryUpdn( dn.toNormName() ) );
@@ -382,8 +374,8 @@
// add an alias and delete to test dropAliasIndices method
LdapDN dn = new LdapDN( "commonName=Jack Daniels,ou=Apache,ou=Board of Directors,o=Good Times Co." );
- dn.normalize( attributeRegistry.getNormalizerMapping() );
- DefaultServerEntry entry = new DefaultServerEntry( registries, dn );
+ dn.normalize( schemaManager.getNormalizerMapping() );
+ DefaultServerEntry entry = new DefaultServerEntry( schemaManager, dn );
entry.add( "objectClass", "top", "alias", "extensibleObject" );
entry.add( "ou", "Apache" );
entry.add( "commonName", "Jack Daniels");
@@ -431,8 +423,8 @@
// dn id 12
LdapDN martinDn = new LdapDN( "cn=Marting King,ou=Sales,o=Good Times Co." );
- martinDn.normalize( attributeRegistry.getNormalizerMapping() );
- DefaultServerEntry entry = new DefaultServerEntry( registries, martinDn );
+ martinDn.normalize( schemaManager.getNormalizerMapping() );
+ DefaultServerEntry entry = new DefaultServerEntry( schemaManager, martinDn );
entry.add( "objectClass", "top", "person", "organizationalPerson" );
entry.add( "ou", "Sales" );
entry.add( "cn", "Martin King");
@@ -446,7 +438,7 @@
assertEquals( 12, ( long ) cursor.get().getId() );
LdapDN newParentDn = new LdapDN( "ou=Board of Directors,o=Good Times Co." );
- newParentDn.normalize( attributeRegistry.getNormalizerMapping() );
+ newParentDn.normalize( schemaManager.getNormalizerMapping() );
store.move( martinDn, newParentDn );
cursor = idx.forwardCursor( 3L);
@@ -456,8 +448,8 @@
// dn id 13
LdapDN marketingDn = new LdapDN( "ou=Marketing,ou=Sales,o=Good Times Co." );
- marketingDn.normalize( attributeRegistry.getNormalizerMapping() );
- entry = new DefaultServerEntry( registries, marketingDn );
+ marketingDn.normalize( schemaManager.getNormalizerMapping() );
+ entry = new DefaultServerEntry( schemaManager, marketingDn );
entry.add( "objectClass", "top", "organizationalUnit" );
entry.add( "ou", "Marketing" );
entry.add( "entryCSN", new CsnFactory( 1 ).newInstance().toString() );
@@ -466,8 +458,8 @@
// dn id 14
LdapDN jimmyDn = new LdapDN( "cn=Jimmy Wales,ou=Marketing, ou=Sales,o=Good Times Co." );
- jimmyDn.normalize( attributeRegistry.getNormalizerMapping() );
- entry = new DefaultServerEntry( registries, jimmyDn );
+ jimmyDn.normalize( schemaManager.getNormalizerMapping() );
+ entry = new DefaultServerEntry( schemaManager, jimmyDn );
entry.add( "objectClass", "top", "person", "organizationalPerson" );
entry.add( "ou", "Marketing" );
entry.add( "cn", "Jimmy Wales");
@@ -705,8 +697,8 @@
public void testAddWithoutParentId() throws Exception
{
LdapDN dn = new LdapDN( "cn=Marting King,ou=Not Present,o=Good Times Co." );
- dn.normalize( attributeRegistry.getNormalizerMapping() );
- DefaultServerEntry entry = new DefaultServerEntry( registries, dn );
+ dn.normalize( schemaManager.getNormalizerMapping() );
+ DefaultServerEntry entry = new DefaultServerEntry( schemaManager, dn );
entry.add( "objectClass", "top", "person", "organizationalPerson" );
entry.add( "ou", "Not Present" );
entry.add( "cn", "Martin King");
@@ -718,8 +710,8 @@
public void testAddWithoutObjectClass() throws Exception
{
LdapDN dn = new LdapDN( "cn=Martin King,ou=Sales,o=Good Times Co." );
- dn.normalize( attributeRegistry.getNormalizerMapping() );
- DefaultServerEntry entry = new DefaultServerEntry( registries, dn );
+ dn.normalize( schemaManager.getNormalizerMapping() );
+ DefaultServerEntry entry = new DefaultServerEntry( schemaManager, dn );
entry.add( "ou", "Sales" );
entry.add( "cn", "Martin King");
store.add( entry );
@@ -730,11 +722,11 @@
public void testModifyAddOUAttrib() throws Exception
{
LdapDN dn = new LdapDN( "cn=JOhnny WAlkeR,ou=Sales,o=Good Times Co." );
- dn.normalize( attributeRegistry.getNormalizerMapping() );
+ dn.normalize( schemaManager.getNormalizerMapping() );
List<Modification> mods = new ArrayList<Modification>();
ServerAttribute attrib = new DefaultServerAttribute( SchemaConstants.OU_AT,
- attributeRegistry.lookup( SchemaConstants.OU_AT_OID ) );
+ schemaManager.lookupAttributeTypeRegistry( SchemaConstants.OU_AT_OID ) );
attrib.add( "Engineering" );
Modification add = new ServerModification( ModificationOperation.ADD_ATTRIBUTE, attrib );
@@ -749,8 +741,8 @@
public void testRename() throws Exception
{
LdapDN dn = new LdapDN( "cn=Pivate Ryan,ou=Engineering,o=Good Times Co." );
- dn.normalize( attributeRegistry.getNormalizerMapping() );
- DefaultServerEntry entry = new DefaultServerEntry( registries, dn );
+ dn.normalize( schemaManager.getNormalizerMapping() );
+ DefaultServerEntry entry = new DefaultServerEntry( schemaManager, dn );
entry.add( "objectClass", "top", "person", "organizationalPerson" );
entry.add( "ou", "Engineering" );
entry.add( "cn", "Private Ryan");
@@ -769,8 +761,8 @@
public void testMove() throws Exception
{
LdapDN childDn = new LdapDN( "cn=Pivate Ryan,ou=Engineering,o=Good Times Co." );
- childDn.normalize( attributeRegistry.getNormalizerMapping() );
- DefaultServerEntry childEntry = new DefaultServerEntry( registries, childDn );
+ childDn.normalize( schemaManager.getNormalizerMapping() );
+ DefaultServerEntry childEntry = new DefaultServerEntry( schemaManager, childDn );
childEntry.add( "objectClass", "top", "person", "organizationalPerson" );
childEntry.add( "ou", "Engineering" );
childEntry.add( "cn", "Private Ryan");
@@ -780,7 +772,7 @@
store.add( childEntry );
LdapDN parentDn = new LdapDN( "ou=Sales,o=Good Times Co." );
- parentDn.normalize( attributeRegistry.getNormalizerMapping() );
+ parentDn.normalize( schemaManager.getNormalizerMapping() );
Rdn rdn = new Rdn("cn=Ryan");
@@ -788,10 +780,10 @@
// to drop the alias indices
childDn = new LdapDN( "commonName=Jim Bean,ou=Apache,ou=Board of Directors,o=Good Times Co." );
- childDn.normalize( attributeRegistry.getNormalizerMapping() );
+ childDn.normalize( schemaManager.getNormalizerMapping() );
parentDn = new LdapDN( "ou=Engineering,o=Good Times Co." );
- parentDn.normalize( attributeRegistry.getNormalizerMapping() );
+ parentDn.normalize( schemaManager.getNormalizerMapping() );
assertEquals( 3, store.getSubAliasIndex().count() );
@@ -805,11 +797,11 @@
public void testModifyAdd() throws Exception
{
LdapDN dn = new LdapDN( "cn=JOhnny WAlkeR,ou=Sales,o=Good Times Co." );
- dn.normalize( attributeRegistry.getNormalizerMapping() );
+ dn.normalize( schemaManager.getNormalizerMapping() );
List<Modification> mods = new ArrayList<Modification>();
ServerAttribute attrib = new DefaultServerAttribute( SchemaConstants.SURNAME_AT,
- attributeRegistry.lookup( SchemaConstants.SURNAME_AT ) );
+ schemaManager.lookupAttributeTypeRegistry( SchemaConstants.SURNAME_AT ) );
String attribVal = "Walker";
attrib.add( attribVal );
@@ -823,7 +815,7 @@
assertTrue( lookedup.get( "sn" ).contains( attribVal ) );
// testing the store.modify( dn, mod, entry ) API
- ServerEntry entry = new DefaultServerEntry( registries, dn );
+ ServerEntry entry = new DefaultServerEntry( schemaManager, dn );
attribVal = "+1974045779";
entry.add( "telephoneNumber", attribVal );
@@ -837,11 +829,11 @@
public void testModifyReplace() throws Exception
{
LdapDN dn = new LdapDN( "cn=JOhnny WAlkeR,ou=Sales,o=Good Times Co." );
- dn.normalize( attributeRegistry.getNormalizerMapping() );
+ dn.normalize( schemaManager.getNormalizerMapping() );
List<Modification> mods = new ArrayList<Modification>();
ServerAttribute attrib = new DefaultServerAttribute( SchemaConstants.SN_AT,
- attributeRegistry.lookup( SchemaConstants.SN_AT_OID ) );
+ schemaManager.lookupAttributeTypeRegistry( SchemaConstants.SN_AT_OID ) );
String attribVal = "Johnny";
attrib.add( attribVal );
@@ -857,7 +849,7 @@
assertEquals( attribVal, lookedup.get( "sn" ).get().getString() );
// testing the store.modify( dn, mod, entry ) API
- ServerEntry entry = new DefaultServerEntry( registries, dn );
+ ServerEntry entry = new DefaultServerEntry( schemaManager, dn );
attribVal = "JWalker";
entry.add( "sn", attribVal );
@@ -870,11 +862,11 @@
public void testModifyRemove() throws Exception
{
LdapDN dn = new LdapDN( "cn=JOhnny WAlkeR,ou=Sales,o=Good Times Co." );
- dn.normalize( attributeRegistry.getNormalizerMapping() );
+ dn.normalize( schemaManager.getNormalizerMapping() );
List<Modification> mods = new ArrayList<Modification>();
ServerAttribute attrib = new DefaultServerAttribute( SchemaConstants.SN_AT,
- attributeRegistry.lookup( SchemaConstants.SN_AT_OID ) );
+ schemaManager.lookupAttributeTypeRegistry( SchemaConstants.SN_AT_OID ) );
Modification add = new ServerModification( ModificationOperation.REMOVE_ATTRIBUTE, attrib );
mods.add( add );
@@ -887,7 +879,7 @@
assertNull( lookedup.get( "sn" ) );
// testing the store.modify( dn, mod, entry ) API
- ServerEntry entry = new DefaultServerEntry( registries, dn );
+ ServerEntry entry = new DefaultServerEntry( schemaManager, dn );
// add an entry for the sake of testing the remove operation
entry.add( "sn", "JWalker" );
@@ -903,8 +895,8 @@
public void testModifyReplaceNonExistingIndexAttribute() throws Exception
{
LdapDN dn = new LdapDN( "cn=Tim B,ou=Sales,o=Good Times Co." );
- dn.normalize( attributeRegistry.getNormalizerMapping() );
- DefaultServerEntry entry = new DefaultServerEntry( registries, dn );
+ dn.normalize( schemaManager.getNormalizerMapping() );
+ DefaultServerEntry entry = new DefaultServerEntry( schemaManager, dn );
entry.add( "objectClass", "top", "person", "organizationalPerson" );
entry.add( "cn", "Tim B");
entry.add( "entryCSN", new CsnFactory( 1 ).newInstance().toString() );
@@ -914,7 +906,7 @@
List<Modification> mods = new ArrayList<Modification>();
ServerAttribute attrib = new DefaultServerAttribute( SchemaConstants.OU_AT,
- attributeRegistry.lookup( SchemaConstants.OU_AT_OID ) );
+ schemaManager.lookupAttributeTypeRegistry( SchemaConstants.OU_AT_OID ) );
String attribVal = "Marketing";
attrib.add( attribVal );