Exemplo n.º 1
0
 /**
  * Tests the {@link EMFCompareMap}'s key set. The set is expected not to support the add()
  * operation.
  */
 public void testNoAddThroughSet() {
   final Set keySet = testedMap.keySet();
   try {
     keySet.add(VALUE_SET[10]);
     fail("UnsupportedOperationException should have been thrown.");
   } catch (UnsupportedOperationException e) {
     // We expected this
   }
 }
Exemplo n.º 2
0
  /**
   * Tests the {@link EMFCompareMap}'s key set. The set is expected to support the
   * retainAll(Collection) operation and it effectively removes all the map's element not contained
   * within the given collection.
   */
  public void testRetainAll() {
    testedMethod = "RetainAll(Collection)";
    Set keySet = testedMap.keySet();
    final Set retainedElements = new HashSet();
    try {
      keySet.retainAll(retainedElements);
    } catch (UnsupportedOperationException e) {
      fail(testedMethod + ' ' + MESSAGE_UNSUPPORTED);
    }
    assertEquals("Map should have been emptied by its keySet retainAll().", 0, testedMap.size());

    for (int i = 0; i < KEY_SET.length; i++) {
      // Adds more and more values to the map for each loop
      for (int j = 0; j < i; j++) {
        testedMap.put(KEY_SET[j], VALUE_SET[j]);
      }

      keySet = testedMap.keySet();
      // Create an array of the entries to avoid concurrent modification exception
      final Object[] array = keySet.toArray();
      int currentMapSize = testedMap.size();
      for (int j = 0; j < array.length; j++) {
        for (int k = 0; k < array.length - j; k++) {
          retainedElements.add(array[k]);
        }
        try {
          keySet.retainAll(retainedElements);
        } catch (UnsupportedOperationException e) {
          fail(testedMethod + ' ' + MESSAGE_UNSUPPORTED);
        }

        for (int k = 0; k < array.length - j; k++) {
          assertTrue(
              "Operation retainAll(Collection) did not retain necessary elements within the map.",
              testedMap.containsKey(array[k]));
        }

        assertEquals(
            "Unexpected size of the map after retainAll() execution.",
            currentMapSize--,
            array.length - j);
      }
    }
  }
Exemplo n.º 3
0
 /**
  * Tests the {@link EMFCompareMap}'s key set. The set is expected to support the clear() operation
  * and it effectively empties the map.
  */
 public void testClear() {
   testedMethod = "Clear()";
   final Set keySet = testedMap.keySet();
   try {
     keySet.clear();
   } catch (UnsupportedOperationException e) {
     fail(testedMethod + ' ' + MESSAGE_UNSUPPORTED);
   }
   assertEquals("Clear() operation didn't effectively empty the map.", 0, testedMap.size());
 }
Exemplo n.º 4
0
  /**
   * Tests the {@link EMFCompareMap}'s key set. The set's iterator is expected to throw a {@link
   * ConcurrentModificationException} if its original map is structurally modified via the clear()
   * method.
   */
  public void testConcurrentClear() {
    testedMethod = "Clear()";
    final Iterator keyIterator = testedMap.keySet().iterator();
    testedMap.clear();

    try {
      keyIterator.next();
      fail(MESSAGE_CONCURRENT + ' ' + testedMethod + '.');
    } catch (ConcurrentModificationException e) {
      // We expected this
    } catch (NoSuchElementException e) {
      fail(MESSAGE_CONCURRENT + ' ' + testedMethod + '.');
    }
  }
Exemplo n.º 5
0
  /**
   * Tests the {@link EMFCompareMap}'s key set. The set's iterator is expected to throw a {@link
   * ConcurrentModificationException} if its original map is structurally modified via the
   * remove(Object) method.
   */
  public void testConcurrentRemove() {
    testedMethod = "Remove(Object)";
    final Iterator keyIterator = testedMap.keySet().iterator();
    // Removes a random entry from the set
    testedMap.remove(KEY_SET[10]);

    try {
      keyIterator.next();
      fail(MESSAGE_CONCURRENT + ' ' + testedMethod + '.');
    } catch (ConcurrentModificationException e) {
      // We expected this
    } catch (NoSuchElementException e) {
      fail(MESSAGE_CONCURRENT + ' ' + testedMethod + '.');
    }
  }
Exemplo n.º 6
0
  /**
   * Tests the {@link EMFCompareMap}'s key set. The set's iterator is expected to throw a {@link
   * ConcurrentModificationException} if its original map is structurally modified via the
   * putAll(Collection) method.
   */
  public void testConcurrentPutAll() {
    testedMethod = "PutAll(Collection)";
    final EMFCompareMap anotherMap = new EMFCompareMap();
    final Iterator keyIterator = anotherMap.keySet().iterator();
    anotherMap.putAll(testedMap);

    try {
      keyIterator.next();
      fail(MESSAGE_CONCURRENT + ' ' + testedMethod + '.');
    } catch (ConcurrentModificationException e) {
      // We expected this
    } catch (NoSuchElementException e) {
      fail(MESSAGE_CONCURRENT + ' ' + testedMethod + '.');
    }
  }
Exemplo n.º 7
0
  /**
   * Tests the {@link EMFCompareMap}'s key set. The set's iterator is expected to throw a {@link
   * ConcurrentModificationException} if its original map is structurally modified via the
   * put(Object) method.
   */
  public void testConcurrentPut() {
    testedMethod = "Put(Object)";
    final Iterator keyIterator = testedMap.keySet().iterator();
    // This entry cannot exist (random value as a key, random key as a value)
    testedMap.put(VALUE_SET[5], KEY_SET[10]);

    try {
      keyIterator.next();
      fail(MESSAGE_CONCURRENT + ' ' + testedMethod + '.');
    } catch (ConcurrentModificationException e) {
      // We expected this
    } catch (NoSuchElementException e) {
      fail(MESSAGE_CONCURRENT + ' ' + testedMethod + '.');
    }
  }
Exemplo n.º 8
0
  /**
   * Tests the creation of the {@link EMFCompareMap}'s key set.
   *
   * <p>
   *
   * <ul>
   *   Assertions :
   *   <li>Created set isn't <code>null</code>
   *   <li>Created set's size is the same as its original map's.
   *   <li>The set's entries correspond to the original map's keys.
   * </ul>
   */
  public void testSetCreation() {
    final Set keySet = testedMap.keySet();

    assertNotNull("Key set hasn't been created.", keySet);
    assertEquals(
        "Created set hasn't got the same size as its original map.",
        testedMap.size(),
        keySet.size());

    for (final Iterator keyIterator = keySet.iterator(); keyIterator.hasNext(); ) {
      final Object currentKey = keyIterator.next();
      assertTrue(
          "The set's iterator contains mappings different than its original map's keys.",
          testedMap.containsKey(currentKey));
    }
  }
Exemplo n.º 9
0
  /**
   * Tests the {@link EMFCompareMap}'s key set's iterator. The iterator is expected to support the
   * remove(Object) operation and this method is expected to effectively remove the given object
   * from the map. Size of the map afterward should have decreased by 1.
   */
  public void testRemoveViaIterator() {
    testedMethod = "Iterator's remove(Object)";

    int currentMapSize = testedMap.size();
    for (final Iterator keyIterator = testedMap.keySet().iterator(); keyIterator.hasNext(); ) {
      final Object currentKey = keyIterator.next();
      try {
        keyIterator.remove();
      } catch (UnsupportedOperationException e) {
        fail(testedMethod + ' ' + MESSAGE_UNSUPPORTED);
      }
      assertFalse(
          "Operation remove() of the key set's iterator did not remove the element from the map.",
          testedMap.containsKey(currentKey));
      assertEquals(
          "Unexpected size of the map after removal of an element.",
          --currentMapSize,
          testedMap.size());
    }
  }
Exemplo n.º 10
0
  /**
   * Tests the {@link EMFCompareMap}'s key set. The set is expected to support the remove(Object)
   * operation and this method is expected to effectively remove the given object from the map. Size
   * of the map afterward should have decreased by 1.
   */
  public void testRemoveViaSet() {
    testedMethod = "Set's remove(Object)";

    final Set keySet = testedMap.keySet();
    // Create an array of the entries to avoid concurrent modification exception
    final Object[] array = keySet.toArray();
    int currentMapSize = testedMap.size();
    for (Object key : array) {
      try {
        keySet.remove(key);
      } catch (UnsupportedOperationException e) {
        fail(testedMethod + ' ' + MESSAGE_UNSUPPORTED);
      }
      assertFalse(
          "Operation remove() of the key set did not remove the element from the map.",
          testedMap.containsKey(key));
      assertEquals(
          "Map size didn't decrease by one after removal of one element.",
          --currentMapSize,
          testedMap.size());
    }
  }