Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.mapdb;
  
  import org.junit.Test;
  
  import java.util.*;
  
  import static org.junit.Assert.*;
 
 @SuppressWarnings({ "unchecked""rawtypes" })
 public class HTreeMap2Test {
 
 
     DB db = new DB();
 
     void printMap(HTreeMap m){
         ..println(toString(m.segmentRecids));
     }
 
     static String toString(long[] rootRecidsEngine engine){
         String s = "Arrays.asList(\n";
         for(long r:rootRecids){
             s+= (r==0)?null:recursiveToString(r,""engine);
         }
         //s=s.substring(0,s.length()-2);
         s+=");";
         return s;
     }
 
     protected static Serializer serializer = DBMaker.newTempHashMap().;
 
     static private String recursiveToString(long rString prefixEngine engine) {
         prefix+="  ";
         String s="";
         long[][] nn = engine.get(r.);
         if(nn==null){
             s+=prefix+"null,\n";
         }else{
             s+= prefix+"Arrays.asList(\n";
         for(long[] n:nn){
             if(n==null){
                 s+=prefix+"  null,\n";
             }else{
                 s+=prefix+"  Arrays.asList(\n";
                 for(long r2:n){
                     if(r2==0){
                         s+=prefix+"    "+"null,\n";
                     }else{
                         if((r2&1)==0){
                             s+=recursiveToString(r2>>>1, prefix+"    "engine);
                         }else{
                             s+=prefix+"    "+"Array.asList(";
                             TreeMap m = new TreeMap();
                             HTreeMap.LinkedNode node =
                                     (HTreeMap.LinkedNodeengine.get
                                             (r2 >>> 1, );
                             while(node!=null){
                                 m.put(node.keynode.value);
                                 node = (HTreeMap.LinkedNodeengine.get(node.next);
                             }
                             for(Object k:m.keySet()){
                                 s+= k+","+m.get(k)+",";
                             }
                             //s=s.substring(0,s.length()-1);
                             s+="),\n";
                         }
                     }
                 }
                 s+=prefix+"  ),\n";
             }
         }
 //            s=s.substring(0,s.length()-2);
             s+=prefix+"),\n";
         }
         return s;
     }
 
 
     @Test public void testDirSerializer() throws IOException {
 
         long[][] l = new long[16][];
         l[3] = new long[] {0,0,12,13,14,0,.,0};
         l[6] = new long[] {1,2,3,4,5,6,7,8};
 
         DataOutput2 out = new DataOutput2();
         ..serialize(out,l);
 
         DataInput2 in = swap(out);
 
         long[][] b = ..deserialize(in, -1);
 
         assertEquals(nullb[0]);
         assertEquals(nullb[1]);
         assertEquals(nullb[2]);
         assertEquals(Arrays.toString(new long[] {0,0,12,13,14,0,.,0}), Arrays.toString(b[3]));
         assertEquals(nullb[4]);
         assertEquals(nullb[5]);
        assertEquals(Arrays.toString(new long[] {1,2,3,4,5,6,7,8}), Arrays.toString(b[6]));
        assertEquals(nullb[7]);
    }
        byte[] b = d.copyBytes();
        return new DataInput2(ByteBuffer.wrap(b),0);
    }
    @Test public void ln_serialization() throws IOException {
        HTreeMap.LinkedNode n = new HTreeMap.LinkedNode(123456, 1111L, 123L, 456L);
        DataOutput2 out = new DataOutput2();
        .serialize(outn);
        DataInput2 in = swap(out);
        HTreeMap.LinkedNode n2  = (HTreeMap.LinkedNode.deserialize(in, -1);
        assertEquals(123456, n2.next);
        assertEquals(0L, n2.expireLinkNodeRecid);
        assertEquals(123L,n2.key);
        assertEquals(456L,n2.value);
    }
    @Test public void test_simple_put(){
        HTreeMap m = new HTreeMap(,0,0,HTreeMap.preallocateSegments(),..,0,0,0,0,null,null,null);
        m.put(111L, 222L);
        m.put(333L, 444L);
        assertTrue(m.containsKey(111L));
        assertTrue(!m.containsKey(222L));
        assertTrue(m.containsKey(333L));
        assertTrue(!m.containsKey(444L));
        assertEquals(222L, m.get(111L));
        assertEquals(nullm.get(222L));
        assertEquals(444l, m.get(333L));
    }
    @Test public void test_hash_collision(){
        HTreeMap m = new HTreeMap(,0,0,HTreeMap.preallocateSegments(),..,0,0,0,0,null,null,null){
            @Override
            protected int hash(Object key) {
                return 0;
            }
        };
        for(long i = 0;i<20;i++){
            m.put(i,i+100);
        }
        for(long i = 0;i<20;i++){
            assertTrue(m.containsKey(i));
            assertEquals(i+100, m.get(i));
        }
        m.put(11L, 1111L);
        assertEquals(1111L,m.get(11L) );
    }
    @Test public void test_hash_dir_expand(){
        HTreeMap m = new HTreeMap(,0,0,HTreeMap.preallocateSegments(),..,0,0,0,0,null,null,null){
            @Override
            protected int hash(Object key) {
                return 0;
            }
        };
        for(long i = 0;i.;i++){
            m.put(i,i);
        }
        //segment should not be expanded
        long[][] l = .get(m.segmentRecids[0], .);
        assertNotNull(l[0]);
        assertEquals(1, l[0][0]&1);  //last bite indicates leaf
        for(int j=1;j<8;j++){ //all others should be null
            assertEquals(0, l[0][j]);
        }
        long recid = l[0][0]>>>1;
        for(long i = . -1; i>=0; i--){
            assertTrue(recid!=0);
            HTreeMap.LinkedNode  n = (HTreeMap.LinkedNode.get(recidm.LN_SERIALIZER);
            assertEquals(in.key);
            assertEquals(in.value);
            recid = n.next;
        }
        //adding one more item should trigger dir expansion to next level
        m.put((long., (long.);
        recid = m.segmentRecids[0];
        l = .get(recid.);
        assertNotNull(l[0]);
        for(int j=1;j<8;j++){ //all others should be null
           assertEquals(nulll[j]);
        }
        assertEquals(0, l[0][0]&1); //last bite indicates leaf
        for(int j=1;j<8;j++){ //all others should be zero
          assertEquals(0, l[0][j]);
        }
        recid = l[0][0]>>>1;
        l = .get(recid.);
        assertNotNull(l[0]);
        for(int j=1;j<8;j++){ //all others should be null
            assertEquals(nulll[j]);
        }
        assertEquals(1, l[0][0]&1); //last bite indicates leaf
        for(int j=1;j<8;j++){ //all others should be zero
            assertEquals(0, l[0][j]);
        }
        recid = l[0][0]>>>1;
        for(long i = 0; i<= .i++){
            assertTrue(recid!=0);
            HTreeMap.LinkedNode n = (HTreeMap.LinkedNode.get(recidm.LN_SERIALIZER);
            assertNotNull(n);
            assertEquals(in.key);
            assertEquals(in.value);
            recid = n.next;
        }
    }
    @Test public void test_delete(){
        HTreeMap m = new HTreeMap(,0,0,HTreeMap.preallocateSegments(),..,0,0,0,0,null,null,null){
            @Override
            protected int hash(Object key) {
                return 0;
            }
        };
        for(long i = 0;i<20;i++){
            m.put(i,i+100);
        }
        for(long i = 0;i<20;i++){
            assertTrue(m.containsKey(i));
            assertEquals(i+100, m.get(i));
        }
        for(long i = 0;i<20;i++){
            m.remove(i);
        }
        for(long i = 0;i<20;i++){
            assertTrue(!m.containsKey(i));
            assertEquals(nullm.get(i));
        }
    }
    @Test public void clear(){
        HTreeMap m = new HTreeMap(,0,0,HTreeMap.preallocateSegments(),..,0,0,0,0,null,null,null);
        for(Integer i=0;i<100;i++){
            m.put(i,i);
        }
        m.clear();
        assertTrue(m.isEmpty());
        assertEquals(0, m.size());
    }
    @Test //(timeout = 10000)
     public void testIteration(){
        HTreeMap m = new HTreeMap(, 0,0,HTreeMap.preallocateSegments(),.,.,0,0,0,0,null,null,null){
            @Override
            protected int hash(Object key) {
                return (Integerkey;
            }
        };
        final int max = 140;
        final int inc = 111111;
        for(Integer i=0;i<max;i++){
            m.put(i,i+inc);
        }
        Iterator<Integerkeys = m.keySet().iterator();
        for(Integer i=0;i<max;i++){
            assertTrue(keys.hasNext());
            assertEquals(ikeys.next());
        }
        assertTrue(!keys.hasNext());
        Iterator<Integervals = m.values().iterator();
        for(Integer i=inc;i<max+inc;i++){
            assertTrue(vals.hasNext());
            assertEquals(ivals.next());
        }
        assertTrue(!vals.hasNext());
        //great it worked, test stuff spread across segments
        m.clear();
        assertTrue(m.isEmpty());
        for(int i = 0;i<max;i++){
            m.put((1<<30)+ii+inc);
            m.put((2<<30)+ii+inc);
            m.put((3<<30)+ii+inc);
        }
        assertEquals(max*3,m.size());
        int countSegments = 0;
        for(long segmentRecid:m.segmentRecids){
            long[][] segment = .get(segmentRecid.);
            for(long[] s:segment){
                if(s!=null){
                    countSegments++;
                    break;
                }
            }
        }
        assertEquals(3, countSegments);
        keys = m.keySet().iterator();
        for(int i=1;i<=3;i++){
            for(int j=0;j<max;j++){
                assertTrue(keys.hasNext());
                assertEquals(Integer.valueOf((i<<30)+j), keys.next());
            }
        }
        assertTrue(!keys.hasNext());
    }
    static final Long ZERO  = 0L;
    @Test public void expire_link_simple_add_remove(){
        HTreeMap m = .createHashMap("test").expireMaxSize(100).make();
        m.segmentLocks[0].writeLock().lock();
        assertEquals(.get(m.expireHeads[0], .));
        assertEquals(.get(m.expireTails[0], .));
        m.expireLinkAdd(0,m.engine.put(....),  111L,222);
        Long recid = .get(m.expireHeads[0], .);
        assertNotEquals(,recid);
        assertEquals(recid.get(m.expireTails[0], .));
        assertEquals(0, n.prev);
        assertEquals(0, n.next);
        assertEquals(111L, n.keyRecid);
        assertEquals(222, n.hash);
        assertArrayEquals(new int[]{222},getExpireList(m,0));
        n = m.expireLinkRemoveLast(0);
        assertEquals(0, n.prev);
        assertEquals(0, n.next);
        assertEquals(111L, n.keyRecid);
        assertEquals(222L, n.hash);
        assertEquals(.get(m.expireHeads[0], .));
        assertEquals(.get(m.expireTails[0], .));
        assertArrayEquals(new int[]{},getExpireList(m,0));
    }
    @Test public void expire_link_test(){
        HTreeMap m = .createHashMap("test").expireMaxSize(100).make();
        m.segmentLocks[2].writeLock().lock();
        long[] recids = new long[10];
        for(int i=1;i<10;i++){
            recids[i] = m.engine.put(....);
            m.expireLinkAdd(2, recids[i],i*10,i*100);
        }
        assertArrayEquals(new int[]{100,200,300,400,500,600,700,800,900},getExpireList(m,2));
        m.expireLinkBump(2,recids[8],true);
        assertArrayEquals(new int[]{100,200,300,400,500,600,700,900,800},getExpireList(m,2));
        m.expireLinkBump(2,recids[5],true);
        assertArrayEquals(new int[]{100,200,300,400,600,700,900,800,500},getExpireList(m,2));
        m.expireLinkBump(2,recids[1],true);
        assertArrayEquals(new int[]{200,300,400,600,700,900,800,500,100},getExpireList(m,2));
        assertEquals(200, m.expireLinkRemoveLast(2).);
        assertArrayEquals(new int[]{300,400,600,700,900,800,500,100},getExpireList(m,2));
        assertEquals(300, m.expireLinkRemoveLast(2).);
        assertArrayEquals(new int[]{400,600,700,900,800,500,100},getExpireList(m,2));
        assertEquals(600, m.expireLinkRemove(2,recids[6]).);
        assertArrayEquals(new int[]{400,700,900,800,500,100},getExpireList(m,2));
        assertEquals(400, m.expireLinkRemove(2,recids[4]).);
        assertArrayEquals(new int[]{700,900,800,500,100},getExpireList(m,2));
        assertEquals(100, m.expireLinkRemove(2,recids[1]).);
        assertArrayEquals(new int[]{700,900,800,500},getExpireList(m,2));
    }
    int[] getExpireList(HTreeMap mint segment){
        int[] ret = new int[0];
        long recid = .get(m.expireTails[segment], .);
        long prev = 0;
        //System.out.println("--");
        while(recid!=0){
            HTreeMap.ExpireLinkNode n = .get(recid..);
            //System.out.println(n.hash);
            assertEquals(prev,n.prev);
            prev = recid;
            recid = n.next;
            ret=Arrays.copyOf(ret,ret.length+1);
            ret[ret.length-1] = n.hash;
        }
        //System.out.println(Arrays.toString(ret));
        assertEquals(new Long(prev), .get(m.expireHeads[segment], .));
        return ret;
    }
    @Test (timeout = 20000)
    public void expire_put() {
        HTreeMap m = .createHashMap("test")
                .expireAfterWrite(100)
                .make();
        m.put("aa","bb");
        //should be removed in a moment or timeout
        while(m.get("aa")!=null){
        }
    }
    @Test(timeout = 20000)
    public void expire_max_size() throws InterruptedException {
        HTreeMap m = .createHashMap("test")
                .expireMaxSize(1000)
                .make();
        for(int i=0;i<1100;i++){
            m.put(""+i,i);
        }
        //first should be removed soon
        while(m.size()>1050){};
        Thread.sleep(500);
        long size = m.size();
        assertTrue(""+size,size>900 && size<=1050);
    }
    @Test public void testSingleIter(){
        Map m = DBMaker.newTempHashMap();
        m.put("aa","bb");
        Iterator iter = m.keySet().iterator();
        assertTrue(iter.hasNext());
        assertEquals("aa",iter.next());
        assertFalse(iter.hasNext());
    }
    @Test public void testMinMaxExpiryTime(){
        HTreeMap m = .createHashMap("test")
                .expireAfterWrite(10000)
                .expireAfterAccess(100000)
                .make();
        long t = System.currentTimeMillis();
        assertEquals(0L, m.getMaxExpireTime());
        assertEquals(0L, m.getMinExpireTime());
        m.put("11","11");
        m.put("12","12");
        assertTrue(Math.abs(m.getMaxExpireTime()-t-10000)<300);
        assertTrue(Math.abs(m.getMinExpireTime()-t-10000)<300);
        m.get("11");
        assertTrue(Math.abs(m.getMaxExpireTime()-t-100000)<300);
        assertTrue(Math.abs(m.getMinExpireTime()-t-10000)<300);
        m.remove("11");
        m.remove("12");
        assertEquals(0L, m.getMaxExpireTime());
        assertEquals(0L, m.getMinExpireTime());
    }
    @Test (timeout = 20000)
    public void cache_load_time_expire(){
        DB db =
                DBMaker.newMemoryDB()
                .sizeLimit(1)
                .transactionDisable()
                .asyncWriteDisable()
                .snapshotDisable()
                .cacheDisable()
                .make();
        HTreeMap m = db.createHashMap("test")
                //.expireMaxSize(11000000)
                .expireAfterWrite(100)
                .make();
        long time = System.currentTimeMillis();
        long counter = 0;
        while(time+5000>System.currentTimeMillis()){
            m.put(counter++,counter++);
        }
        m.clear();
    }
    @Test(timeout = 20000)
    public void cache_load_size_expire(){
        DB db = DBMaker.newMemoryDB()
                .sizeLimit(1)
                .transactionDisable()
                .asyncWriteDisable()
                .snapshotDisable()
                .make();
        HTreeMap m = db.createHashMap("test")
                //.expireMaxSize(11000000)
                .expireMaxSize(10000)
                .make();
        long time = System.currentTimeMillis();
        long counter = 0;
        while(time+5000>System.currentTimeMillis()){
            m.put(counter++,counter++);
//            if(counter%1000<2) System.out.println(m.size());
        }
        m.clear();
    }
    @Test public void divMod8(){
        for(int i= 0;i<1000000;i++){
            assertEquals(i/8,i>>.);
            assertEquals(i%8,i&.);
        }
    }
New to GrepCode? Check out our FAQ X