Exemplo n.º 1
0
  @Test
  public void long_stack_page_overflow() throws IOException {
    engine.lock.writeLock().lock();
    // fill page until near overflow
    for (int i = 0; i < StorageDirect.LONG_STACK_NUM_OF_RECORDS_PER_PAGE; i++) {
      engine.longStackPut(TEST_LS_RECID, 1000L + i);
    }
    engine.commit();

    // check content
    long pageId = engine.index.getLong(TEST_LS_RECID * 8);
    assertEquals(StorageDirect.LONG_STACK_PAGE_SIZE, pageId >>> 48);
    pageId = pageId & StorageDirect.PHYS_OFFSET_MASK;
    assertEquals(8L, pageId);
    assertEquals(StorageDirect.LONG_STACK_NUM_OF_RECORDS_PER_PAGE, engine.phys.getByte(pageId));
    for (int i = 0; i < StorageDirect.LONG_STACK_NUM_OF_RECORDS_PER_PAGE; i++) {
      assertEquals(1000L + i, engine.phys.getLong(pageId + 8 + i * 8));
    }

    // add one more item, this will trigger page overflow
    engine.longStackPut(TEST_LS_RECID, 11L);
    engine.commit();
    // check page overflowed
    pageId = engine.index.getLong(TEST_LS_RECID * 8);
    assertEquals(StorageDirect.LONG_STACK_PAGE_SIZE, pageId >>> 48);
    pageId = pageId & StorageDirect.PHYS_OFFSET_MASK;
    assertEquals(8L + StorageDirect.LONG_STACK_PAGE_SIZE, pageId);
    assertEquals(1, engine.phys.getByte(pageId));
    assertEquals(8L, engine.phys.getLong(pageId) & StorageDirect.PHYS_OFFSET_MASK);
    assertEquals(11L, engine.phys.getLong(pageId + 8));
  }
Exemplo n.º 2
0
 @Test
 public void test_long_stack_puts_record_size_into_index() throws IOException {
   engine.lock.writeLock().lock();
   engine.longStackPut(TEST_LS_RECID, 1);
   engine.commit();
   assertEquals(
       StorageDirect.LONG_STACK_PAGE_SIZE, engine.index.getUnsignedShort(TEST_LS_RECID * 8));
 }
Exemplo n.º 3
0
 @Test
 public void long_stack_page_deleted_after_take() throws IOException {
   engine.lock.writeLock().lock();
   engine.longStackPut(TEST_LS_RECID, 111);
   engine.commit();
   assertEquals(111L, engine.longStackTake(TEST_LS_RECID));
   engine.commit();
   assertEquals(0L, engine.index.getLong(TEST_LS_RECID * 8));
 }
Exemplo n.º 4
0
 @Test
 public void test_index_record_delete() {
   long recid = engine.put(1000L, Serializer.LONG_SERIALIZER);
   engine.commit();
   assertEquals(1, countIndexRecords());
   engine.delete(recid, Serializer.LONG_SERIALIZER);
   engine.commit();
   assertEquals(0, countIndexRecords());
 }
Exemplo n.º 5
0
  @Test
  public void test_phys_record_reused() {
    final long recid = engine.put(1L, Serializer.LONG_SERIALIZER);
    final long physRecid = engine.index.getLong(recid * 8 + StorageDirect.INDEX_OFFSET_START * 8);
    engine.delete(recid, Serializer.LONG_SERIALIZER);
    final long recid2 = engine.put(1L, Serializer.LONG_SERIALIZER);

    assertEquals(recid, recid2);
    assertEquals(physRecid, engine.index.getLong(recid * 8 + StorageDirect.INDEX_OFFSET_START * 8));
  }
Exemplo n.º 6
0
 @Test
 public void in_memory_test() {
   StorageDirect engine = new StorageDirect(Volume.memoryFactory(false));
   Map<Long, Integer> recids = new HashMap<Long, Integer>();
   for (int i = 0; i < 1000; i++) {
     long recid = engine.recordPut(i, Serializer.BASIC_SERIALIZER);
     recids.put(recid, i);
   }
   for (Long recid : recids.keySet()) {
     assertEquals(recids.get(recid), engine.recordGet(recid, Serializer.BASIC_SERIALIZER));
   }
 }
Exemplo n.º 7
0
 @Test
 public void long_stack_page_created_after_put() throws IOException {
   engine.lock.writeLock().lock();
   engine.longStackPut(TEST_LS_RECID, 111);
   engine.commit();
   long pageId = engine.index.getLong(TEST_LS_RECID * 8);
   assertEquals(StorageDirect.LONG_STACK_PAGE_SIZE, pageId >>> 48);
   pageId = pageId & StorageDirect.PHYS_OFFSET_MASK;
   assertEquals(8L, pageId);
   assertEquals(1, engine.phys.getByte(pageId));
   assertEquals(0, engine.phys.getLong(pageId) & StorageDirect.PHYS_OFFSET_MASK);
   assertEquals(111, engine.phys.getLong(pageId + 8));
 }
Exemplo n.º 8
0
  @Test
  public void test_long_stack_put_take() throws IOException {
    engine.lock.writeLock().lock();

    final long max = 150;
    for (long i = 1; i < max; i++) {
      engine.longStackPut(TEST_LS_RECID, i);
    }

    for (long i = max - 1; i > 0; i--) {
      assertEquals(i, engine.longStackTake(TEST_LS_RECID));
    }

    assertEquals(0, getLongStack(TEST_LS_RECID).size());
  }
Exemplo n.º 9
0
  @Test
  public void compact() {
    Map<Long, Long> recids = new HashMap<Long, Long>();
    for (Long l = 0L; l < 1000; l++) {
      recids.put(l, engine.put(l, Serializer.LONG_SERIALIZER));
    }

    engine.commit();
    engine.compact();

    for (Map.Entry<Long, Long> e : recids.entrySet()) {
      Long recid = e.getValue();
      Long value = e.getKey();
      assertEquals(value, engine.get(recid, Serializer.LONG_SERIALIZER));
    }
  }
Exemplo n.º 10
0
  @Test
  public void test_basic_long_stack() throws IOException {
    // dirty hack to make sure we have lock
    engine.lock.writeLock().lock();
    final long max = 150;
    ArrayList<Long> list = new ArrayList<Long>();
    for (long i = 1; i < max; i++) {
      engine.longStackPut(TEST_LS_RECID, i);
      list.add(i);
    }

    Collections.reverse(list);
    engine.commit();

    assertEquals(list, getLongStack(TEST_LS_RECID));
  }
Exemplo n.º 11
0
  @Test
  public void test_freePhysRecSize2FreeSlot_asserts() {
    try {
      engine.freePhysRecSize2FreeSlot(StorageDirect.MAX_RECORD_SIZE + 1);
      fail();
    } catch (IllegalArgumentException e) {
      // expected
    }

    try {
      engine.freePhysRecSize2FreeSlot(-1);
      fail();
    } catch (IllegalArgumentException e) {
      // expected
    }
  }
Exemplo n.º 12
0
  @Test
  public void test_freePhys_PutAndTake() throws IOException {
    engine.lock.writeLock().lock();

    final long offset = 1111000;
    final int size = 344;
    final long indexVal = (((long) size) << 48) | offset;

    engine.freePhysRecPut(indexVal);

    assertEquals(indexVal, engine.freePhysRecTake(size));
    assertEquals(
        arrayList(),
        getLongStack(
            StorageDirect.RECID_FREE_PHYS_RECORDS_START + engine.freePhysRecSize2FreeSlot(size)));
  }
Exemplo n.º 13
0
 @Test
 public void test_freePhysRecSize2FreeSlot_incremental() {
   int oldSlot = -1;
   for (int size = 1; size <= StorageDirect.MAX_RECORD_SIZE; size++) {
     int slot = engine.freePhysRecSize2FreeSlot(size);
     assertTrue(slot >= 0);
     assertTrue(oldSlot <= slot);
     assertTrue(slot - oldSlot <= 1);
     oldSlot = slot;
   }
   assertEquals(StorageDirect.NUMBER_OF_PHYS_FREE_SLOT - 1, oldSlot);
 }
Exemplo n.º 14
0
  @Test
  public void test_index_record_delete_and_reuse_large() {
    final long MAX = 10;

    List<Long> recids = new ArrayList<Long>();
    for (int i = 0; i < MAX; i++) {
      recids.add(engine.put(0L, Serializer.LONG_SERIALIZER));
    }

    for (long recid : recids) {
      engine.delete(recid, Serializer.LONG_SERIALIZER);
    }

    // now allocate again second recid list
    List<Long> recids2 = new ArrayList<Long>();
    for (int i = 0; i < MAX; i++) {
      recids2.add(engine.put(0L, Serializer.LONG_SERIALIZER));
    }

    // second list should be reverse of first, as Linked Offset List is LIFO
    Collections.reverse(recids);
    assertEquals(recids, recids2);
  }
Exemplo n.º 15
0
  @Test
  public void test_index_stores_record_size() throws IOException {

    final long recid = engine.put(1, Serializer.INTEGER_SERIALIZER);
    engine.commit();
    assertEquals(
        4, engine.index.getUnsignedShort(recid * 8 + StorageDirect.INDEX_OFFSET_START * 8));
    assertEquals(Integer.valueOf(1), engine.get(recid, Serializer.INTEGER_SERIALIZER));

    engine.update(recid, 1L, Serializer.LONG_SERIALIZER);
    engine.commit();
    assertEquals(
        8, engine.index.getUnsignedShort(recid * 8 + StorageDirect.INDEX_OFFSET_START * 8));
    assertEquals(Long.valueOf(1), engine.get(recid, Serializer.LONG_SERIALIZER));
  }
Exemplo n.º 16
0
 @Test
 public void test_index_record_delete_and_reusef() {
   long recid = engine.put(1000L, Serializer.LONG_SERIALIZER);
   engine.commit();
   assertEquals(1, countIndexRecords());
   assertEquals(Engine.LAST_RESERVED_RECID + 1, recid);
   engine.delete(recid, Serializer.LONG_SERIALIZER);
   engine.commit();
   assertEquals(0, countIndexRecords());
   long recid2 = engine.put(1000L, Serializer.LONG_SERIALIZER);
   engine.commit();
   // test that previously deleted index slot was reused
   assertEquals(recid, recid2);
   assertEquals(1, countIndexRecords());
   assertNotEquals(0, engine.index.getLong(recid * 8 + StorageDirect.INDEX_OFFSET_START * 8));
 }
Exemplo n.º 17
0
 @Test
 public void test_freePhysRecSize2FreeSlot_max_size_has_unique_slot() {
   int slotMax = engine.freePhysRecSize2FreeSlot(StorageDirect.MAX_RECORD_SIZE);
   int slotMaxMinus1 = engine.freePhysRecSize2FreeSlot(StorageDirect.MAX_RECORD_SIZE - 1);
   assertEquals(slotMax, slotMaxMinus1 + 1);
 }
Exemplo n.º 18
0
 @Test
 public void test_long_stack_put_take_simple() throws IOException {
   engine.lock.writeLock().lock();
   engine.longStackPut(TEST_LS_RECID, 111);
   assertEquals(111L, engine.longStackTake(TEST_LS_RECID));
 }