Exemple #1
0
  public void testAddMissing() {
    Table<Integer> buf = new Table<Integer>(3, 10, 0);
    for (int i : Arrays.asList(1, 2, 4, 5, 6)) buf.add(i, i);
    System.out.println("buf = " + buf);
    assert buf.size() == 5 && buf.getNumMissing() == 1;

    Integer num = buf.remove();
    assert num == 1;
    num = buf.remove();
    assert num == 2;
    num = buf.remove();
    assert num == null;

    buf.add(3, 3);
    System.out.println("buf = " + buf);
    assert buf.size() == 4 && buf.getNumMissing() == 0;

    for (int i = 3; i <= 6; i++) {
      num = buf.remove();
      System.out.println("buf = " + buf);
      assert num == i;
    }

    num = buf.remove();
    assert num == null;
  }
Exemple #2
0
  public void testCompact2() {
    Table<Integer> table = new Table<Integer>(3, 10, 0);
    for (int i = 1; i <= 80; i++) addAndGet(table, i);
    assert table.size() == 80;
    for (long i = 1; i <= 60; i++) table.remove();

    assert table.size() == 20;
    table.compact();
    assert table.size() == 20;
    assertCapacity(table.capacity(), table.getNumRows(), 10);
  }
Exemple #3
0
 public static void testComputeSize2() {
   Table<Integer> table = new Table<Integer>(3, 10, 0);
   table.add(1, 1);
   System.out.println("table = " + table);
   assert table.computeSize() == table.size();
   assert table.computeSize() == 1;
   table.remove(false);
   System.out.println("table = " + table);
   assert table.computeSize() == table.size();
   assert table.computeSize() == 0;
 }
Exemple #4
0
 public static void testAddition() {
   Table<Integer> table = new Table<Integer>(3, 10, 0);
   assert !table.add(0, 0);
   addAndGet(table, 1, 5, 9, 10, 11, 19, 20, 29);
   System.out.println("table: " + table.dump());
   assert table.size() == 8;
   int size = table.computeSize();
   assert size == 8;
   assert table.size() == table.computeSize();
   assertCapacity(table.capacity(), 3, 10);
   assertIndices(table, 0, 0, 29);
 }
Exemple #5
0
 public static void testRemoveManyWithWrapping2() {
   Table<Integer> table = new Table<Integer>(3, 10, 0);
   for (int seqno : Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 15, 16, 17, 18, 19, 20))
     table.add(seqno, seqno);
   System.out.println("table = " + table);
   assertIndices(table, 0, 0, 20);
   assert table.size() == 18 && table.getNumMissing() == 2;
   List<Integer> list = table.removeMany(false, 0);
   assert list.size() == 12;
   assertIndices(table, 0, 12, 20);
   assert table.size() == 6 && table.getNumMissing() == 2;
   table.purge(12);
   assertIndices(table, 12, 12, 20);
   assert table.size() == 6 && table.getNumMissing() == 2;
 }
Exemple #6
0
 public static void testAdditionList() {
   Table<Integer> table = new Table<Integer>(3, 10, 0);
   List<Tuple<Long, Integer>> msgs = createList(0);
   assert !table.add(msgs);
   long[] seqnos = {1, 5, 9, 10, 11, 19, 20, 29};
   msgs = createList(seqnos);
   assert table.add(msgs);
   System.out.println("table: " + table.dump());
   for (long seqno : seqnos) assert table.get(seqno) == seqno;
   assert table.size() == 8;
   int size = table.computeSize();
   assert size == 8;
   assert table.size() == table.computeSize();
   assertCapacity(table.capacity(), 3, 10);
   assertIndices(table, 0, 0, 29);
 }
Exemple #7
0
  /**
   * Runs NUM adder threads, each adder adds 1 (unique) seqno. When all adders are done, we should
   * have NUM elements in the table.
   */
  public void testConcurrentAdd() {
    final int NUM = 100;
    final Table<Integer> buf = new Table<Integer>(3, 10, 0);

    CountDownLatch latch = new CountDownLatch(1);
    Adder[] adders = new Adder[NUM];
    for (int i = 0; i < adders.length; i++) {
      adders[i] = new Adder(latch, i + 1, buf);
      adders[i].start();
    }

    System.out.println("starting threads");
    latch.countDown();
    System.out.print("waiting for threads to be done: ");
    for (Adder adder : adders) {
      try {
        adder.join();
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
    System.out.println("OK");
    System.out.println("buf = " + buf);
    assert buf.size() == NUM;
  }
Exemple #8
0
 public void testAdd() {
   Table<Integer> buf = new Table<Integer>(3, 10, 0);
   buf.add(1, 322649);
   buf.add(2, 100000);
   System.out.println("buf = " + buf);
   assert buf.size() == 2;
 }
Exemple #9
0
  public void testResizeWithPurge2() {
    Table<Integer> table = new Table<Integer>(3, 10, 0);
    for (int i = 1; i <= 50; i++) addAndGet(table, i);
    System.out.println("table = " + table);
    assert table.size() == 50;
    assertCapacity(table.capacity(), table.getNumRows(), 10);
    assertIndices(table, 0, 0, 50);
    table.removeMany(false, 43);
    System.out.println("table = " + table);
    assertIndices(table, 0, 43, 50);
    table.purge(43);
    System.out.println("table = " + table);
    assertIndices(table, 43, 43, 50);
    addAndGet(table, 52);
    assert table.get(43) == null;

    for (long i = 44; i <= 50; i++) {
      Integer num = table.get(i);
      assert num != null && num == i;
    }

    assert table.get(50) != null;
    assert table.get(51) == null;
    Integer num = table.get(52);
    assert num != null && num == 52;
    assert table.get(53) == null;
  }
Exemple #10
0
  public void testPurgeForce() {
    Table<Integer> table = new Table<Integer>(3, 10, 0);
    for (int i = 1; i <= 30; i++) table.add(i, i);
    System.out.println("table = " + table);
    table.purge(15, true);
    System.out.println("table = " + table);
    assertIndices(table, 15, 15, 30);
    for (int i = 1; i <= 15; i++) assert table._get(i) == null;
    for (int i = 16; i <= 30; i++) assert table._get(i) != null;
    assert table.get(5) == null && table.get(25) != null;

    table.purge(30, true);
    System.out.println("table = " + table);
    assertIndices(table, 30, 30, 30);
    assert table.isEmpty();
    for (int i = 1; i <= 30; i++) assert table._get(i) == null;

    for (int i = 31; i <= 40; i++) table.add(i, i);
    System.out.println("table = " + table);
    assert table.size() == 10;
    assertIndices(table, 30, 30, 40);

    table.purge(50, true);
    System.out.println("table = " + table);
    assert table.isEmpty();
    assertIndices(table, 40, 40, 40);
  }
Exemple #11
0
  public static void testPurge() {
    Table<Integer> table = new Table<Integer>(5, 10, 0);
    for (int seqno = 1; seqno <= 25; seqno++) table.add(seqno, seqno);

    int[] seqnos = {30, 31, 32, 37, 38, 39, 40, 41, 42, 47, 48, 49};
    for (int seqno : seqnos) table.add(seqno, seqno);

    System.out.println("table (before remove):\n" + table.dump());
    for (int seqno = 1; seqno <= 22; seqno++) table.remove(false);

    System.out.println("\ntable (after remove 22, before purge):\n" + table.dump());
    table.purge(22);
    System.out.println("\ntable: (after purge 22):\n" + table.dump());
    assert table.size() == 3 + seqnos.length;
    assert table.computeSize() == table.size();
  }
Exemple #12
0
 public static void testDuplicateAddition() {
   Table<Integer> table = new Table<Integer>(3, 10, 0);
   addAndGet(table, 1, 5, 9, 10);
   assert !table.add(5, 5);
   assert table.get(5) == 5;
   assert table.size() == 4;
   assertIndices(table, 0, 0, 10);
 }
Exemple #13
0
 public static void testCreation() {
   Table<Integer> table = new Table<Integer>(3, 10, 0);
   System.out.println("table = " + table);
   int size = table.size();
   assert size == 0;
   assert table.get(15) == null;
   assertIndices(table, 0, 0, 0);
 }
Exemple #14
0
 public static void testAdditionWithOffset() {
   Table<Integer> table = new Table<Integer>(3, 10, 100);
   addAndGet(table, 101, 105, 109, 110, 111, 119, 120, 129);
   System.out.println("table: " + table.dump());
   assert table.size() == 8;
   assertCapacity(table.capacity(), 3, 10);
   assertIndices(table, 100, 100, 129);
 }
Exemple #15
0
 public void testCompact() {
   Table<Integer> table = new Table<Integer>(3, 10, 0);
   for (int i = 1; i <= 80; i++) addAndGet(table, i);
   assert table.size() == 80;
   assertIndices(table, 0, 0, 80);
   List<Integer> list = table.removeMany(false, 60);
   assert list.size() == 60;
   assert list.get(0) == 1 && list.get(list.size() - 1) == 60;
   assertIndices(table, 0, 60, 80);
   table.purge(60);
   assertIndices(table, 60, 60, 80);
   assert table.size() == 20;
   table.compact();
   assertIndices(table, 60, 60, 80);
   assert table.size() == 20;
   assertCapacity(table.capacity(), table.getNumRows(), 10);
 }
Exemple #16
0
 public void testAddList() {
   Table<Integer> buf = new Table<Integer>(3, 10, 0);
   List<Tuple<Long, Integer>> msgs = createList(1, 2);
   boolean rc = buf.add(msgs);
   System.out.println("buf = " + buf);
   assert rc;
   assert buf.size() == 2;
 }
Exemple #17
0
 public static void testMove() {
   Table<Integer> table = new Table<Integer>(3, 10, 0);
   for (int i = 1; i < 50; i++) addAndGet(table, i);
   table.removeMany(true, 49);
   assert table.isEmpty();
   addAndGet(table, 50);
   assert table.size() == 1;
   assertCapacity(table.capacity(), table.getNumRows(), 10);
 }
Exemple #18
0
 public static void testAdditionWithOffset2() {
   Table<Integer> table = new Table<Integer>(3, 10, 2);
   addAndGet(table, 1000, 1001);
   table.compact();
   addAndGet(table, 1005, 1009, 1010, 1011, 1019, 1020, 1029);
   System.out.println("table: " + table.dump());
   assert table.size() == 9;
   assertIndices(table, 2, 2, 1029);
 }
Exemple #19
0
 public static void testMassAddition() {
   Table<Integer> table = new Table<Integer>(3, 10, 0);
   final int NUM_ELEMENTS = 10005;
   for (int i = 1; i <= NUM_ELEMENTS; i++) table.add(i, i);
   System.out.println("table = " + table);
   assert table.size() == NUM_ELEMENTS;
   assertCapacity(table.capacity(), table.getNumRows(), 10);
   assertIndices(table, 0, 0, NUM_ELEMENTS);
   assert table.getNumMissing() == 0;
 }
Exemple #20
0
 public static void testAdditionListWithOffset() {
   Table<Integer> table = new Table<Integer>(3, 10, 100);
   long seqnos[] = {101, 105, 109, 110, 111, 119, 120, 129};
   List<Tuple<Long, Integer>> msgs = createList(seqnos);
   System.out.println("table: " + table.dump());
   assert table.add(msgs);
   assert table.size() == 8;
   for (long seqno : seqnos) assert table.get(seqno) == seqno;
   assertCapacity(table.capacity(), 3, 10);
   assertIndices(table, 100, 100, 129);
 }
Exemple #21
0
 public static void testRemoveMany() {
   Table<Integer> table = new Table<Integer>(3, 10, 0);
   for (int seqno : Arrays.asList(1, 2, 3, 4, 5, 7, 8, 9, 10)) table.add(seqno, seqno);
   System.out.println("table = " + table);
   assertIndices(table, 0, 0, 10);
   List<Integer> list = table.removeMany(true, 4);
   System.out.println("list=" + list + ", table=" + table);
   assert table.size() == 5 && table.getNumMissing() == 1;
   assert list != null && list.size() == 4;
   for (int num : Arrays.asList(1, 2, 3, 4)) assert list.contains(num);
   assertIndices(table, 4, 4, 10);
 }
Exemple #22
0
  public static void testGetNullMessages() {
    Table<Integer> table = new Table<Integer>(3, 10, 0);
    table.add(1, 1);
    table.add(100, 100);
    System.out.println("table = " + table);
    int num_null_elements = table.getNumMissing();
    assert num_null_elements == 98; // [2 .. 99]

    table.add(50, 50);
    System.out.println("table = " + table);
    assert table.size() == 3;
    assert table.getNumMissing() == 97;
  }
Exemple #23
0
  public static void testRemove() {
    Table<Integer> table = new Table<Integer>(3, 10, 0);
    for (int i = 1; i <= 9; i++) table.add(i, i);
    table.add(20, 20);
    System.out.println("table = " + table);
    assert table.size() == 10;
    assertIndices(table, 0, 0, 20);

    int num_null_msgs = table.getNumMissing();
    System.out.println("num_null_msgs = " + num_null_msgs);
    assert num_null_msgs == 10;

    for (long i = 1; i <= 10; i++) // 10 is missing
    table.remove();
    System.out.println("table = " + table);
    assert table.size() == 1;
    assertIndices(table, 9, 9, 20);

    num_null_msgs = table.getNumMissing();
    System.out.println("num_null_msgs = " + num_null_msgs);
    assert num_null_msgs == 10;
  }
Exemple #24
0
  public void testResizeWithPurgeAndGetOfNonExistingElement() {
    Table<Integer> table = new Table<Integer>(3, 10, 0);
    for (int i = 1; i <= 50; i++) addAndGet(table, i);
    System.out.println("table: " + table);
    assertIndices(table, 0, 0, 50);
    assert table.size() == 50 && table.getNumMissing() == 0;

    // now remove 15 messages
    for (long i = 1; i <= 15; i++) {
      Integer num = table.remove(false);
      assert num != null && num == i;
    }
    System.out.println("table after removal of seqno 15: " + table);
    assertIndices(table, 0, 15, 50);
    assert table.size() == 35 && table.getNumMissing() == 0;

    table.purge(15);
    System.out.println("now triggering a resize() by addition of seqno=55");
    addAndGet(table, 55);
    assertIndices(table, 15, 15, 55);
    assert table.size() == 36 && table.getNumMissing() == 4;

    // now we have elements 40-49 in row 1 and 55 in row 2:
    List<Integer> list = new ArrayList<Integer>(20);
    for (int i = 16; i < 50; i++) list.add(i);
    list.add(55);

    for (long i = table.getOffset(); i < table.capacity() + table.getOffset(); i++) {
      Integer num = table._get(i);
      if (num != null) {
        System.out.println("num=" + num);
        list.remove(num);
      }
    }

    System.out.println("table:\n" + table.dump());
    assert list.isEmpty() : " list: " + Util.print(list);
  }
Exemple #25
0
  public static void testGetNullMessages2() {
    Table<Integer> table = new Table<Integer>(1, 10, 0);
    table.add(1, 1);
    table.add(5, 5);
    System.out.println("table = " + table);
    int num_null_elements = table.getNumMissing();
    assert num_null_elements == 3; // [2 .. 4]

    table.add(10, 10);
    System.out.println("table = " + table);
    assert table.size() == 3;
    assert table.getNumMissing() == 7;

    table.add(14, 14);
    System.out.println("table = " + table);
    assert table.size() == 4;
    assert table.getNumMissing() == 10;

    while (table.remove() != null) ;
    System.out.println("table = " + table);
    assert table.size() == 3;
    assert table.getNumMissing() == 10;
  }
Exemple #26
0
  public static void testComputeSize() {
    Table<Integer> table = new Table<Integer>(3, 10, 0);
    for (int num : Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)) table.add(num, num);
    System.out.println("table = " + table);
    assert table.computeSize() == 10;
    table.removeMany(false, 3);
    System.out.println("table = " + table);
    assert table.computeSize() == 7;

    table.removeMany(true, 4);
    System.out.println("table = " + table);
    assert table.computeSize() == table.size();
    assert table.computeSize() == 3;
  }
Exemple #27
0
  /**
   * Creates a table and fills it to capacity. Then starts a number of adder threads, each trying to
   * add a seqno, blocking until there is more space. Each adder will block until the remover
   * removes elements, so the adder threads get unblocked and can then add their elements to the
   * buffer.
   */
  public void testConcurrentAddAndRemove() throws Exception {
    final int NUM = 5;
    final Table<Integer> buf = new Table<Integer>(3, 10, 0);
    for (int i = 1; i <= 10; i++) buf.add(i, i); // fill the buffer, add() will block now

    CountDownLatch latch = new CountDownLatch(1);
    Adder[] adders = new Adder[NUM];
    for (int i = 0; i < adders.length; i++) {
      adders[i] = new Adder(latch, i + 11, buf);
      adders[i].start();
    }

    System.out.println("releasing threads");
    latch.countDown();
    System.out.print("waiting for threads to be done: ");

    Thread remover =
        new Thread("Remover") {
          public void run() {
            Util.sleep(2000);
            List<Integer> list = buf.removeMany(true, 5);
            System.out.println("\nremover: removed = " + list);
          }
        };
    remover.start();

    for (Adder adder : adders) {
      try {
        adder.join();
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }

    remover.join();

    System.out.println("OK");
    System.out.println("buf = " + buf);
    assert buf.size() == 10;
    assertIndices(buf, 5, 5, 15);

    List<Integer> list = buf.removeMany(true, 0);
    System.out.println("removed = " + list);
    assert list.size() == 10;
    for (int i = 6; i <= 15; i++) assert list.contains(i);
    assertIndices(buf, 15, 15, 15);
  }
Exemple #28
0
 public void testAddListWithConstValue() {
   Table<Integer> buf = new Table<Integer>(3, 10, 0);
   List<Tuple<Long, Integer>> msgs = createList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
   final Integer DUMMY = 0;
   boolean rc = buf.add(msgs, false, DUMMY);
   System.out.println("buf = " + buf);
   assert rc;
   assert buf.size() == 10;
   List<Integer> list =
       buf.removeMany(
           null,
           true,
           0,
           new Filter<Integer>() {
             public boolean accept(Integer element) {
               return element.hashCode() == DUMMY.hashCode();
             }
           });
   System.out.println("list = " + list);
   assert list.size() == 10;
   for (int num : list) assert num == DUMMY;
 }