Пример #1
0
 @Test
 public void testGetFromEmpty() {
   OpenIntToFieldHashMap<Fraction> map = new OpenIntToFieldHashMap<Fraction>(field);
   Assert.assertTrue(field.getZero().equals(map.get(5)));
   Assert.assertTrue(field.getZero().equals(map.get(0)));
   Assert.assertTrue(field.getZero().equals(map.get(50)));
 }
Пример #2
0
 private OpenIntToFieldHashMap<Fraction> createFromJavaMap(Field<Fraction> field) {
   OpenIntToFieldHashMap<Fraction> map = new OpenIntToFieldHashMap<Fraction>(field);
   for (Map.Entry<Integer, Fraction> mapEntry : javaMap.entrySet()) {
     map.put(mapEntry.getKey(), mapEntry.getValue());
   }
   return map;
 }
Пример #3
0
  @Test
  public void testGetAbsent() {
    Map<Integer, Fraction> generated = generateAbsent();
    OpenIntToFieldHashMap<Fraction> map = createFromJavaMap(field);

    for (Map.Entry<Integer, Fraction> mapEntry : generated.entrySet())
      Assert.assertTrue(field.getZero().equals(map.get(mapEntry.getKey())));
  }
Пример #4
0
  @Test
  public void testCopy() {
    OpenIntToFieldHashMap<Fraction> copy =
        new OpenIntToFieldHashMap<Fraction>(createFromJavaMap(field));
    Assert.assertEquals(javaMap.size(), copy.size());

    for (Map.Entry<Integer, Fraction> mapEntry : javaMap.entrySet())
      Assert.assertEquals(mapEntry.getValue(), copy.get(mapEntry.getKey()));
  }
Пример #5
0
 @Test
 public void testPutOnExisting() {
   OpenIntToFieldHashMap<Fraction> map = createFromJavaMap(field);
   for (Map.Entry<Integer, Fraction> mapEntry : javaMap.entrySet()) {
     map.put(mapEntry.getKey(), mapEntry.getValue());
     Assert.assertEquals(javaMap.size(), map.size());
     Assert.assertEquals(mapEntry.getValue(), map.get(mapEntry.getKey()));
   }
 }
Пример #6
0
 private void assertPutAndGet(
     OpenIntToFieldHashMap<Fraction> map, int mapSize, Set<Integer> keysInMap) {
   Assert.assertEquals(mapSize, map.size());
   for (Map.Entry<Integer, Fraction> mapEntry : javaMap.entrySet()) {
     map.put(mapEntry.getKey(), mapEntry.getValue());
     if (!keysInMap.contains(mapEntry.getKey())) ++mapSize;
     Assert.assertEquals(mapSize, map.size());
     Assert.assertEquals(mapEntry.getValue(), map.get(mapEntry.getKey()));
   }
 }
Пример #7
0
 @Test
 public void testConcurrentModification() {
   OpenIntToFieldHashMap<Fraction> map = createFromJavaMap(field);
   OpenIntToFieldHashMap<Fraction>.Iterator iterator = map.iterator();
   map.put(3, new Fraction(3));
   try {
     iterator.advance();
     Assert.fail("an exception should have been thrown");
   } catch (ConcurrentModificationException cme) {
     // expected
   }
 }
Пример #8
0
  @Test
  public void testRemoveAbsent() {
    Map<Integer, Fraction> generated = generateAbsent();

    OpenIntToFieldHashMap<Fraction> map = createFromJavaMap(field);
    int mapSize = map.size();

    for (Map.Entry<Integer, Fraction> mapEntry : generated.entrySet()) {
      map.remove(mapEntry.getKey());
      Assert.assertEquals(mapSize, map.size());
      Assert.assertTrue(field.getZero().equals(map.get(mapEntry.getKey())));
    }
  }
Пример #9
0
  @Test
  public void testRemove() {
    OpenIntToFieldHashMap<Fraction> map = createFromJavaMap(field);
    int mapSize = javaMap.size();
    Assert.assertEquals(mapSize, map.size());
    for (Map.Entry<Integer, Fraction> mapEntry : javaMap.entrySet()) {
      map.remove(mapEntry.getKey());
      Assert.assertEquals(--mapSize, map.size());
      Assert.assertTrue(field.getZero().equals(map.get(mapEntry.getKey())));
    }

    /* Ensure that put and get still work correctly after removals */
    assertPutAndGet(map);
  }
Пример #10
0
  /**
   * Regression test for a bug in findInsertionIndex where the hashing in the second probing loop
   * was inconsistent with the first causing duplicate keys after the right sequence of puts and
   * removes.
   */
  @Test
  public void testPutKeysWithCollisions() {
    OpenIntToFieldHashMap<Fraction> map = new OpenIntToFieldHashMap<Fraction>(field);
    int key1 = -1996012590;
    Fraction value1 = new Fraction(1);
    map.put(key1, value1);
    int key2 = 835099822;
    map.put(key2, value1);
    int key3 = 1008859686;
    map.put(key3, value1);
    Assert.assertEquals(value1, map.get(key3));
    Assert.assertEquals(3, map.size());

    map.remove(key2);
    Fraction value2 = new Fraction(2);
    map.put(key3, value2);
    Assert.assertEquals(value2, map.get(key3));
    Assert.assertEquals(2, map.size());
  }
Пример #11
0
  /**
   * Similar to testPutKeysWithCollisions() but exercises the codepaths in a slightly different
   * manner.
   */
  @Test
  public void testPutKeysWithCollision2() {
    OpenIntToFieldHashMap<Fraction> map = new OpenIntToFieldHashMap<Fraction>(field);
    int key1 = 837989881;
    Fraction value1 = new Fraction(1);
    map.put(key1, value1);
    int key2 = 476463321;
    map.put(key2, value1);
    Assert.assertEquals(2, map.size());
    Assert.assertEquals(value1, map.get(key2));

    map.remove(key1);
    Fraction value2 = new Fraction(2);
    map.put(key2, value2);
    Assert.assertEquals(1, map.size());
    Assert.assertEquals(value2, map.get(key2));
  }
Пример #12
0
 @Test
 public void testIterator() {
   OpenIntToFieldHashMap<Fraction> map = createFromJavaMap(field);
   OpenIntToFieldHashMap<Fraction>.Iterator iterator = map.iterator();
   for (int i = 0; i < map.size(); ++i) {
     Assert.assertTrue(iterator.hasNext());
     iterator.advance();
     int key = iterator.key();
     Assert.assertTrue(map.containsKey(key));
     Assert.assertEquals(javaMap.get(key), map.get(key));
     Assert.assertEquals(javaMap.get(key), iterator.value());
     Assert.assertTrue(javaMap.containsKey(key));
   }
   Assert.assertFalse(iterator.hasNext());
   try {
     iterator.advance();
     Assert.fail("an exception should have been thrown");
   } catch (NoSuchElementException nsee) {
     // expected
   }
 }
Пример #13
0
 @Test
 public void testContainsKey() {
   OpenIntToFieldHashMap<Fraction> map = createFromJavaMap(field);
   for (Entry<Integer, Fraction> mapEntry : javaMap.entrySet()) {
     Assert.assertTrue(map.containsKey(mapEntry.getKey()));
   }
   for (Map.Entry<Integer, Fraction> mapEntry : generateAbsent().entrySet()) {
     Assert.assertFalse(map.containsKey(mapEntry.getKey()));
   }
   for (Entry<Integer, Fraction> mapEntry : javaMap.entrySet()) {
     int key = mapEntry.getKey();
     Assert.assertTrue(map.containsKey(key));
     map.remove(key);
     Assert.assertFalse(map.containsKey(key));
   }
 }