directory-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From elecha...@apache.org
Subject svn commit: r896599 [20/30] - in /directory/apacheds/trunk: ./ avl-partition/ avl-partition/src/ avl-partition/src/main/ avl-partition/src/main/java/ avl-partition/src/main/java/org/ avl-partition/src/main/java/org/apache/ avl-partition/src/main/java/o...
Date Wed, 06 Jan 2010 18:27:19 GMT
Modified: directory/apacheds/trunk/jdbm-store/src/test/java/org/apache/directory/server/core/partition/impl/btree/jdbm/DupsContainerCursorTest.java
URL: http://svn.apache.org/viewvc/directory/apacheds/trunk/jdbm-store/src/test/java/org/apache/directory/server/core/partition/impl/btree/jdbm/DupsContainerCursorTest.java?rev=896599&r1=896598&r2=896599&view=diff
==============================================================================
--- directory/apacheds/trunk/jdbm-store/src/test/java/org/apache/directory/server/core/partition/impl/btree/jdbm/DupsContainerCursorTest.java (original)
+++ directory/apacheds/trunk/jdbm-store/src/test/java/org/apache/directory/server/core/partition/impl/btree/jdbm/DupsContainerCursorTest.java Wed Jan  6 18:26:43 2010
@@ -19,29 +19,35 @@
 package org.apache.directory.server.core.partition.impl.btree.jdbm;
 
 
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.apache.directory.server.xdbm.Tuple;
-import org.apache.directory.server.schema.SerializableComparator;
-import org.apache.directory.server.schema.registries.ComparatorRegistry;
-import org.apache.directory.shared.ldap.cursor.Cursor;
-import org.apache.directory.shared.ldap.cursor.InvalidCursorPositionException;
-import org.apache.directory.shared.ldap.schema.parsers.ComparatorDescription;
-import org.junit.Before;
-import org.junit.After;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+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 java.util.Comparator;
-import java.util.Iterator;
 
 import jdbm.RecordManager;
-import jdbm.helper.IntegerSerializer;
+import jdbm.helper.DefaultSerializer;
 import jdbm.recman.BaseRecordManager;
 
-import javax.naming.NamingException;
+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.schema.ldif.extractor.impl.DefaultSchemaLdifExtractor;
+import org.apache.directory.shared.ldap.schema.loader.ldif.LdifSchemaLoader;
+import org.apache.directory.shared.ldap.schema.manager.impl.DefaultSchemaManager;
+import org.apache.directory.shared.ldap.util.ExceptionUtils;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 
 /**
@@ -55,12 +61,40 @@
     private static final Logger LOG = LoggerFactory.getLogger( NoDupsCursorTest.class.getSimpleName() );
     private static final String TEST_OUTPUT_PATH = "test.output.path";
 
-    transient JdbmTable<Integer,Integer> table;
+    transient JdbmTable<String,String> table;
     transient File dbFile;
+    private static SchemaManager schemaManager;
     transient RecordManager recman;
     private static final int SIZE = 15;
 
 
+    @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 DefaultSchemaLdifExtractor( new File( workingDirectory ) );
+        extractor.extractOrCopy( true );
+        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
     {
@@ -75,16 +109,12 @@
         dbFile = File.createTempFile( getClass().getSimpleName(), "db", tmpDir );
         dbFile.deleteOnExit();
         recman = new BaseRecordManager( dbFile.getAbsolutePath() );
-
-        // gosh this is a terrible use of a global static variable
-        SerializableComparator.setRegistry( new MockComparatorRegistry() );
-
-        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" );
-
     }
 
 
@@ -109,11 +139,15 @@
         recman = new BaseRecordManager( dbFile.getAbsolutePath() );
 
         // gosh this is a terrible use of a global static variable
-        SerializableComparator.setRegistry( new MockComparatorRegistry() );
-        table = new JdbmTable<Integer,Integer>( "test", recman, new SerializableComparator<Integer>( "" ), null, null );
+        //SerializableComparator.setRegistry( 
+        //    new MockComparatorRegistry(
+        //        new OidRegistry() ) );
+        SerializableComparator<String> comparator = new SerializableComparator<String>( SchemaConstants.INTEGER_ORDERING_MATCH_MR_OID );
+        comparator.setSchemaManager( schemaManager );
+        table = new JdbmTable<String,String>( schemaManager, "test", recman, comparator, null, null );
 
-        Cursor<Tuple<Integer,DupsContainer<Integer>>> cursor =
-            new DupsContainerCursor<Integer,Integer>( table );
+        Cursor<Tuple<String,DupsContainer<String>>> cursor =
+            new DupsContainerCursor<String,String>( table );
         assertNotNull( cursor );
     }
 
@@ -121,21 +155,21 @@
     @Test( expected=InvalidCursorPositionException.class )
     public void testEmptyTable() throws Exception
     {
-        Cursor<Tuple<Integer,DupsContainer<Integer>>> cursor =
-            new DupsContainerCursor<Integer,Integer>( table );
+        Cursor<Tuple<String,DupsContainer<String>>> cursor =
+            new DupsContainerCursor<String,String>( table );
         assertNotNull( cursor );
 
         assertFalse( cursor.available() );
         assertFalse( cursor.isClosed() );
         assertTrue( cursor.isElementReused() );
 
-        cursor = new DupsContainerCursor<Integer,Integer>( table );
+        cursor = new DupsContainerCursor<String,String>( table );
         assertFalse( cursor.previous() );
 
-        cursor = new DupsContainerCursor<Integer,Integer>( table );
+        cursor = new DupsContainerCursor<String,String>( table );
         assertFalse( cursor.next() );
 
-        cursor.after( new Tuple<Integer,DupsContainer<Integer>>( 7, null ) );
+        cursor.after( new Tuple<String,DupsContainer<String>>( "7", null ) );
         cursor.get();
     }
 
@@ -143,14 +177,14 @@
     @Test
     public void testOnTableWithSingleEntry() throws Exception
     {
-        table.put( 1, 1 );
-        Cursor<Tuple<Integer,DupsContainer<Integer>>> cursor =
-            new DupsContainerCursor<Integer,Integer>( table );
+        table.put( "1", "1" );
+        Cursor<Tuple<String,DupsContainer<String>>> cursor =
+            new DupsContainerCursor<String,String>( table );
         assertTrue( cursor.first() );
 
-        Tuple<Integer,DupsContainer<Integer>> tuple = cursor.get();
-        assertTrue( tuple.getKey().equals( 1 ) );
-        assertEquals( 1, ( int ) tuple.getValue().getArrayTree().getFirst() );
+        Tuple<String,DupsContainer<String>> tuple = cursor.get();
+        assertEquals( "1", tuple.getKey() );
+        assertEquals( "1", tuple.getValue().getArrayTree().getFirst() );
 
         cursor.beforeFirst();
         assertFalse( cursor.previous() );
@@ -163,24 +197,25 @@
     {
         for( int i=1; i < 10; i++ )
         {
-            table.put( i, i );
+            String istr = Integer.toString( i );
+            table.put( istr, istr );
         }
 
-        Cursor<Tuple<Integer,DupsContainer<Integer>>> cursor =
-            new DupsContainerCursor<Integer,Integer>( table );
+        Cursor<Tuple<String,DupsContainer<String>>> cursor =
+            new DupsContainerCursor<String,String>( table );
 
-        cursor.after( new Tuple<Integer,DupsContainer<Integer>>( 2, null ) );
+        cursor.after( new Tuple<String,DupsContainer<String>>( "2", null ) );
         assertTrue( cursor.next() );
 
-        Tuple<Integer,DupsContainer<Integer>> tuple = cursor.get();
-        assertTrue( tuple.getKey().equals( 3 ) );
-        assertEquals( 3, ( int ) tuple.getValue().getArrayTree().getFirst() );
+        Tuple<String,DupsContainer<String>> tuple = cursor.get();
+        assertEquals( "3", tuple.getKey() );
+        assertEquals( "3", tuple.getValue().getArrayTree().getFirst() );
 
-        cursor.before( new Tuple<Integer,DupsContainer<Integer>>( 7, null ) );
+        cursor.before( new Tuple<String,DupsContainer<String>>( "7", null ) );
         cursor.next();
         tuple = cursor.get();
-        assertTrue( tuple.getKey().equals( 7 ) );
-        assertEquals( 7, ( int ) tuple.getValue().getArrayTree().getFirst() );
+        assertEquals( "7", tuple.getKey() );
+        assertEquals( "7", tuple.getValue().getArrayTree().getFirst() );
 
         cursor.last();
         cursor.next();
@@ -192,8 +227,8 @@
         cursor.beforeFirst();
         cursor.next();
         tuple = cursor.get();
-        assertTrue( tuple.getKey().equals( 1 ) );
-        assertEquals( 1, ( int ) tuple.getValue().getArrayTree().getFirst() );
+        assertEquals( "1", tuple.getKey() );
+        assertEquals( "1", tuple.getValue().getArrayTree().getFirst() );
 
         cursor.afterLast();
         assertFalse( cursor.next() );
@@ -203,13 +238,13 @@
 
         // just to clear the jdbmTuple value so that line 127 inside after(tuple) method
         // can be executed as part of the below after(tuple) call
-        cursor.before(new Tuple<Integer,DupsContainer<Integer>>( 1, null ) );
-        cursor.after( new Tuple<Integer,DupsContainer<Integer>>( 0, null ) ); // this positions on tuple with key 1
+        cursor.before(new Tuple<String,DupsContainer<String>>( "1", null ) );
+        cursor.after( new Tuple<String,DupsContainer<String>>( "0", null ) ); // this positions on tuple with key 1
 
         cursor.next(); // this moves onto tuple with key 2
         tuple = cursor.get();
-        assertTrue( tuple.getKey().equals( 2 ) );
-        assertEquals( 2, ( int ) tuple.getValue().getArrayTree().getFirst() );
+        assertEquals( "2", tuple.getKey() );
+        assertEquals( "2", tuple.getValue().getArrayTree().getFirst() );
     }
 
 
@@ -217,65 +252,4 @@
     public void testMiscellaneous() throws Exception
     {
     }
-
-
-    private class MockComparatorRegistry implements ComparatorRegistry
-    {
-        private Comparator<Integer> comparator = new Comparator<Integer>()
-        {
-            public int compare( Integer i1, Integer i2 )
-            {
-                return i1.compareTo( i2 );
-            }
-        };
-
-        public String getSchemaName( String oid ) throws NamingException
-        {
-            return null;
-        }
-
-
-        public void register( ComparatorDescription description, Comparator comparator ) throws NamingException
-        {
-        }
-
-
-        public Comparator lookup( String oid ) throws NamingException
-        {
-            return comparator;
-        }
-
-
-        public boolean hasComparator( String oid )
-        {
-            return true;
-        }
-
-
-        public Iterator<String> iterator()
-        {
-            return null;
-        }
-
-
-        public Iterator<ComparatorDescription> comparatorDescriptionIterator()
-        {
-            return null;
-        }
-
-
-        public void unregister( String oid ) throws NamingException
-        {
-        }
-
-
-        public void unregisterSchemaElements( String schemaName )
-        {
-        }
-
-
-        public void renameSchema( String originalSchemaName, String newSchemaName )
-        {
-        }
-    }
 }
\ No newline at end of file

Modified: directory/apacheds/trunk/jdbm-store/src/test/java/org/apache/directory/server/core/partition/impl/btree/jdbm/DupsCursorTest.java
URL: http://svn.apache.org/viewvc/directory/apacheds/trunk/jdbm-store/src/test/java/org/apache/directory/server/core/partition/impl/btree/jdbm/DupsCursorTest.java?rev=896599&r1=896598&r2=896599&view=diff
==============================================================================
--- directory/apacheds/trunk/jdbm-store/src/test/java/org/apache/directory/server/core/partition/impl/btree/jdbm/DupsCursorTest.java (original)
+++ directory/apacheds/trunk/jdbm-store/src/test/java/org/apache/directory/server/core/partition/impl/btree/jdbm/DupsCursorTest.java Wed Jan  6 18:26:43 2010
@@ -19,24 +19,36 @@
 package org.apache.directory.server.core.partition.impl.btree.jdbm;
 
 
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
+import static org.junit.Assert.assertEquals;
+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.DefaultSerializer;
+import jdbm.recman.BaseRecordManager;
+
 import org.apache.directory.server.xdbm.Table;
 import org.apache.directory.server.xdbm.Tuple;
-import org.apache.directory.server.schema.SerializableComparator;
+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.junit.Before;
+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.ldif.extractor.impl.DefaultSchemaLdifExtractor;
+import org.apache.directory.shared.ldap.schema.loader.ldif.LdifSchemaLoader;
+import org.apache.directory.shared.ldap.schema.manager.impl.DefaultSchemaManager;
+import org.apache.directory.shared.ldap.util.ExceptionUtils;
 import org.junit.After;
+import org.junit.Before;
+import org.junit.BeforeClass;
 import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-import java.io.File;
-
-import jdbm.RecordManager;
-import jdbm.helper.IntegerSerializer;
-import jdbm.recman.BaseRecordManager;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 
 /**
@@ -52,15 +64,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 DefaultSchemaLdifExtractor( new File( workingDirectory ) );
+        extractor.extractOrCopy( true );
+        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 ) );
@@ -69,13 +110,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() );
+        SerializableComparator<String> comparator = new SerializableComparator<String>( SchemaConstants.INTEGER_ORDERING_MATCH_MR_OID );
+        comparator.setSchemaManager( schemaManager );
 
-        table = new JdbmTable<Integer,Integer>( "test", SIZE, recman,
-                new SerializableComparator<Integer>( "" ),
-                new SerializableComparator<Integer>( "" ),
-                null, new IntegerSerializer() );
+        table = new JdbmTable<String,String>( schemaManager, "test", SIZE, recman,
+                comparator, comparator, null, new DefaultSerializer() );
         LOG.debug( "Created new table and populated it with data" );
     }
 
@@ -101,7 +140,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();
@@ -119,19 +158,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++;
         }
     }
 
@@ -139,19 +181,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--;
         }
     }
 
@@ -159,34 +204,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++;
         }
     }
 
@@ -194,35 +245,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--;
         }
     }
 
@@ -230,112 +288,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--;
         }
     }
 
@@ -343,114 +418,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--;
         }
     }
 
@@ -458,231 +550,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--;
         }
     }
 
@@ -690,11 +811,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() );
     }
 
@@ -702,20 +823,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() );
     }
 
@@ -723,20 +846,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() );
     }
 
@@ -744,261 +869,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++;
         }
     }
 
@@ -1006,261 +1149,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++;
         }
     }
 
@@ -1268,7 +1432,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/trunk/jdbm-store/src/test/java/org/apache/directory/server/core/partition/impl/btree/jdbm/JdbmBrowserBugTest.java
URL: http://svn.apache.org/viewvc/directory/apacheds/trunk/jdbm-store/src/test/java/org/apache/directory/server/core/partition/impl/btree/jdbm/JdbmBrowserBugTest.java?rev=896599&r1=896598&r2=896599&view=diff
==============================================================================
--- directory/apacheds/trunk/jdbm-store/src/test/java/org/apache/directory/server/core/partition/impl/btree/jdbm/JdbmBrowserBugTest.java (original)
+++ directory/apacheds/trunk/jdbm-store/src/test/java/org/apache/directory/server/core/partition/impl/btree/jdbm/JdbmBrowserBugTest.java Wed Jan  6 18:26:43 2010
@@ -68,6 +68,7 @@
         };
 
         File tmpDir = null;
+        
         if ( System.getProperty( TEST_OUTPUT_PATH, null ) != null )
         {
             tmpDir = new File( System.getProperty( TEST_OUTPUT_PATH ) );

Modified: directory/apacheds/trunk/jdbm-store/src/test/java/org/apache/directory/server/core/partition/impl/btree/jdbm/JdbmIndexTest.java
URL: http://svn.apache.org/viewvc/directory/apacheds/trunk/jdbm-store/src/test/java/org/apache/directory/server/core/partition/impl/btree/jdbm/JdbmIndexTest.java?rev=896599&r1=896598&r2=896599&view=diff
==============================================================================
--- directory/apacheds/trunk/jdbm-store/src/test/java/org/apache/directory/server/core/partition/impl/btree/jdbm/JdbmIndexTest.java (original)
+++ directory/apacheds/trunk/jdbm-store/src/test/java/org/apache/directory/server/core/partition/impl/btree/jdbm/JdbmIndexTest.java Wed Jan  6 18:26:43 2010
@@ -20,29 +20,32 @@
 package org.apache.directory.server.core.partition.impl.btree.jdbm;
 
 
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.After;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
+import java.io.File;
+import java.io.IOException;
+
 import org.apache.commons.io.FileUtils;
-import org.apache.directory.server.schema.bootstrap.*;
-import org.apache.directory.server.schema.registries.*;
-import org.apache.directory.server.schema.SerializableComparator;
+import org.apache.directory.server.core.entry.ServerEntry;
 import org.apache.directory.server.xdbm.Index;
 import org.apache.directory.server.xdbm.IndexEntry;
-import org.apache.directory.server.core.entry.ServerEntry;
 import org.apache.directory.shared.ldap.constants.SchemaConstants;
 import org.apache.directory.shared.ldap.cursor.Cursor;
-
-import java.util.Set;
-import java.util.HashSet;
-import java.io.File;
-import java.io.IOException;
+import org.apache.directory.shared.ldap.schema.AttributeType;
+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.ldif.extractor.impl.DefaultSchemaLdifExtractor;
+import org.apache.directory.shared.ldap.schema.loader.ldif.LdifSchemaLoader;
+import org.apache.directory.shared.ldap.schema.manager.impl.DefaultSchemaManager;
+import org.apache.directory.shared.ldap.util.ExceptionUtils;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
 
 
 /**
@@ -53,27 +56,41 @@
  */
 public class JdbmIndexTest
 {
-    AttributeTypeRegistry registry;
-    File dbFileDir;
+    private static File dbFileDir;
     Index<String,ServerEntry> idx;
+    private static SchemaManager schemaManager;
+
+
+    @BeforeClass
+    public static void init() throws Exception
+    {
+    	String workingDirectory = System.getProperty( "workingDirectory" );
+
+        if ( workingDirectory == null )
+        {
+            String path = JdbmIndexTest.class.getResource( "" ).getPath();
+            int targetPos = path.indexOf( "target" );
+            workingDirectory = path.substring( 0, targetPos + 6 );
+        }
 
+        File schemaRepository = new File( workingDirectory, "schema" );
+        SchemaLdifExtractor extractor = new DefaultSchemaLdifExtractor( new File( workingDirectory ) );
+        extractor.extractOrCopy( true );
+        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 setup() throws Exception
+    public void setup() throws IOException
     {
-        BootstrapSchemaLoader loader = new BootstrapSchemaLoader();
-        OidRegistry oidRegistry = new DefaultOidRegistry();
-        Registries registries = new DefaultRegistries( "bootstrap", loader, oidRegistry );
-        SerializableComparator.setRegistry( registries.getComparatorRegistry() );
-
-        // load essential bootstrap schemas
-        Set<Schema> bootstrapSchemas = new HashSet<Schema>();
-        bootstrapSchemas.add( new ApachemetaSchema() );
-        bootstrapSchemas.add( new ApacheSchema() );
-        bootstrapSchemas.add( new CoreSchema() );
-        bootstrapSchemas.add( new SystemSchema() );
-        loader.loadWithDependencies( bootstrapSchemas, registries );
-        this.registry = registries.getAttributeTypeRegistry();
 
         File tmpIndexFile = File.createTempFile( JdbmIndexTest.class.getSimpleName(), "db" );
         tmpIndexFile.deleteOnExit();
@@ -87,7 +104,6 @@
     @After
     public void teardown() throws Exception
     {
-        registry = null;
         destroyIndex();
         
         if ( ( dbFileDir != null ) && dbFileDir.exists() )
@@ -130,7 +146,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;
     }
 
@@ -153,6 +169,7 @@
 
         // initialized index
         initIndex();
+        
         try
         {
             idx.setAttributeId( "foo" );
@@ -251,7 +268,7 @@
         assertNull( jdbmIndex.getAttribute() );
 
         initIndex();
-        assertEquals( registry.lookup( "ou" ), idx.getAttribute() );
+        assertEquals( schemaManager.lookupAttributeTypeRegistry( "ou" ), idx.getAttribute() );
     }
 
 
@@ -550,7 +567,9 @@
 
         try
         {
-            jdbmIndex.init( new NoEqMatchAttribute(), dbFileDir );
+            AttributeType noEqMatchAttribute = new AttributeType( "1.1" );
+            
+            jdbmIndex.init( schemaManager, noEqMatchAttribute, dbFileDir );
             fail( "should not get here" );
         }
         catch( IOException e )
@@ -568,7 +587,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();
     }
 }



Mime
View raw message