Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.mapdb;
  
  
  import org.junit.Before;
  import org.junit.Test;
  
  import java.util.Arrays;
  import java.util.HashMap;
  import java.util.Map;
 
 import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
 import static org.mapdb.Serializer.BYTE_ARRAY_NOSIZE;

Tests contract of various implementations of Engine interface
 
 public abstract class EngineTest<ENGINE extends Engine>{
 
     protected abstract ENGINE openEngine();
 
     void reopen(){
         if(!canReopen()) return;
         .close();
         =openEngine();
     }
 
     boolean canReopen(){return true;}
     boolean canRollback(){return true;}
 
     ENGINE e;
     @Before public void init(){
          = openEngine();
     }
 
     @Test public void put_get(){
         Long l = 11231203099090L;
         long recid = .put(l.);
         assertEquals(l.get(recid.));
     }
 
     @Test public void put_reopen_get(){
         if(!canReopen()) return;
         Long l = 11231203099090L;
         long recid = .put(l.);
         .commit();
         reopen();
         assertEquals(l.get(recid.));
     }
 
     @Test public void put_get_large(){
         byte[] b = new byte[(int) 1e6];
         new Random().nextBytes(b);
         long recid = .put(b.);
         assertArrayEquals(b.get(recid.));
     }
 
     @Test public void put_reopen_get_large(){
         if(!canReopen()) return;
         byte[] b = new byte[(int) 1e6];
         new Random().nextBytes(b);
         long recid = .put(b.);
         .commit();
         reopen();
         assertArrayEquals(b.get(recid.));
     }
 
 
     @Test public void first_recid(){
     }
 
 
     @Test public void compact0(){
         Long v1 = 129031920390121423L;
         Long v2 = 909090901290129990L;
         Long v3 = 998898989L;
         long recid1 = .put(v1.);
         long recid2 = .put(v2.);
 
         .commit();
         .compact();
 
         assertEquals(v1.get(recid1,.));
         assertEquals(v2.get(recid2,.));
         long recid3 = .put(v3.);
         assertEquals(v1.get(recid1,.));
         assertEquals(v2.get(recid2,.));
         assertEquals(v3.get(recid3,.));
         .commit();
         assertEquals(v1.get(recid1,.));
         assertEquals(v2.get(recid2,.));
         assertEquals(v3.get(recid3,.));
 
     }
 
 
     @Test public void compact(){
        Map<Long,Longrecids = new HashMap<LongLong>();
        for(Long l=0L;l<1000;l++){
            recids.put(l,
                    .put(l.));
        }
        .commit();
        .compact();
        for(Map.Entry<Long,Longm:recids.entrySet()){
            Long recidm.getValue();
            Long value = m.getKey();
            assertEquals(value.get(recid.));
        }
    }
    @Test public void compact2(){
        Map<Long,Longrecids = new HashMap<LongLong>();
        for(Long l=0L;l<1000;l++){
            recids.put(l,
                    .put(l.));
        }
        .commit();
        .compact();
        for(Long l=1000L;l<2000;l++){
            recids.put(l.put(l.));
        }
        for(Map.Entry<Long,Longm:recids.entrySet()){
            Long recidm.getValue();
            Long value = m.getKey();
            assertEquals(value.get(recid.));
        }
    }
    @Test public void compact_large_record(){
        byte[] b = new byte[100000];
        long recid = .put(b.);
        .commit();
        .compact();
        assertArrayEquals(b.get(recid.));
    }
    @Test public void testSetGet(){
        long recid  = .put((long) 10000, .);
        Long  s2 = .get(recid.);
        assertEquals(s2, Long.valueOf(10000));
    }
    @Test
    public void large_record(){
        byte[] b = new byte[100000];
        Arrays.fill(b, (byte) 111);
        long recid = .put(b);
        byte[] b2 = .get(recid);
        assertArrayEquals(b,b2);
    }
    @Test public void large_record_update(){
        byte[] b = new byte[100000];
        Arrays.fill(b, (byte) 111);
        long recid = .put(b);
        Arrays.fill(b, (byte)222);
        .update(recidb);
        byte[] b2 = .get(recid);
        assertArrayEquals(b,b2);
        .commit();
        reopen();
        b2 = .get(recid);
        assertArrayEquals(b,b2);
    }
    @Test public void large_record_delete(){
        byte[] b = new byte[100000];
        Arrays.fill(b, (byte) 111);
        long recid = .put(b);
        .delete(recid);
    }
    @Test public void large_record_larger(){
        byte[] b = new byte[10000000];
        Arrays.fill(b, (byte) 111);
        long recid = .put(b);
        byte[] b2 = .get(recid);
        assertArrayEquals(b,b2);
        .commit();
        reopen();
        b2 = .get(recid);
        assertArrayEquals(b,b2);
    }
    @Test public void test_store_reopen(){
        long recid = .put("aaa".);
        .commit();
        reopen();
        String aaa = .get(recid.);
        assertEquals("aaa",aaa);
    }
    @Test public void test_store_reopen_nocommit(){
        long recid = .put("aaa".);
        .commit();
        .update(recid,"bbb",.);
        reopen();
        String expected = canRollback()&&canReopen()?"aaa":"bbb";
        assertEquals(expected.get(recid.));
    }
    @Test public void rollback(){
        long recid = .put("aaa".);
        .commit();
        .update(recid"bbb".);
        if(!canRollback())return;
        .rollback();
        assertEquals("aaa",.get(recid.));
    }
    @Test public void rollback_reopen(){
        long recid = .put("aaa".);
        .commit();
        .update(recid"bbb".);
        if(!canRollback())return;
        .rollback();
        assertEquals("aaa",.get(recid.));
        reopen();
        assertEquals("aaa",.get(recid.));
    }
New to GrepCode? Check out our FAQ X