Javadoc

Author: garydgregory

src/test/java/org/apache/commons/collections4/collection/AbstractCollectionTest.java

@@ -57,19 +57,24 @@
  * implement the {@link #makeObject()}, {@link #makeConfirmedCollection()}
  * and {@link #makeConfirmedFullCollection()} methods.
  * You might want to override some of the additional public methods as well:
+ * </p>
  * <p>
  * <strong>Element Population Methods</strong>
+ * </p>
  * <p>
  * Override these if your collection restricts what kind of elements are
  * allowed (for instance, if {@code null} is not permitted):
+ * </p>
  * <ul>
  * <li>{@link #getFullElements()}
  * <li>{@link #getOtherElements()}
  * </ul>
  * <p>
  * <strong>Supported Operation Methods</strong>
+ * </p>
  * <p>
  * Override these if your collection doesn't support certain operations:
+ * </p>
  * <ul>
  * <li>{@link #isAddSupported()}
  * <li>{@link #isRemoveSupported()}
@@ -79,13 +84,16 @@
  * </ul>
  * <p>
  * <strong>Indicate Collection Behaviour</strong>
+ * </p>
  * <p>
  * Override these if your collection makes specific behavior guarantees:
+ * </p>
  * <ul>
  * <li>{@link #getIterationBehaviour()}</li>
  * </ul>
  * <p>
  * <strong>Fixture Methods</strong>
+ * </p>
  * <p>
  * Fixtures are used to verify that the operation results in correct state
  * for the collection.  Basically, the operation is performed against your
@@ -99,12 +107,14 @@
  * than a simple {@code equals} test.  This verification is used to ensure
  * proper modifications are made along with ensuring that the collection does
  * not change when read-only modifications are made.
+ * </p>
  * <p>
  * The {@link #collection} field holds an instance of your collection
  * implementation; the {@link #confirmed} field holds an instance of the
  * confirmed collection implementation.  The {@link #resetEmpty()} and
  * {@link #resetFull()} methods set these fields to empty or full collections,
  * so that tests can proceed from a known state.
+ * </p>
  * <p>
  * After a modification operation to both {@link #collection} and
  * {@link #confirmed}, the {@link #verify()} method is invoked to compare
@@ -113,29 +123,35 @@
  * views of a map, {@link org.apache.commons.collections4.map.AbstractMapTest AbstractTestMap}
  * would override {@link #verify()} to make
  * sure the map is changed after the collection view is changed.
+ * </p>
  * <p>
  * If you're extending this class directly, you will have to provide
  * implementations for the following:
+ * </p>
  * <ul>
  * <li>{@link #makeConfirmedCollection()}
  * <li>{@link #makeConfirmedFullCollection()}
  * </ul>
  * <p>
  * Those methods should provide a confirmed collection implementation
  * that's compatible with your collection implementation.
+ * </p>
  * <p>
  * If you're extending {@link org.apache.commons.collections4.list.AbstractListTest AbstractListTest},
  * {@link org.apache.commons.collections4.set.AbstractSetTest AbstractTestSet},
  * or {@link org.apache.commons.collections4.bag.AbstractBagTest AbstractBagTest},
  * you probably don't have to worry about the
  * above methods, because those three classes already override the methods
- * to provide standard JDK confirmed collections.<P>
+ * to provide standard JDK confirmed collections.
+ * </p>
  * <p>
  * <strong>Other notes</strong>
+ * </p>
  * <p>
  * If your {@link Collection} fails one of these tests by design,
  * you may still use this base set of cases.  Simply override the
  * test case (method) your {@link Collection} fails.
+ * </p>
  */
 public abstract class AbstractCollectionTest<E> extends AbstractObjectTest {
 
@@ -261,26 +277,30 @@ private static void assertUnorderedArrayEquals(final Object[] a1, final Object[]
 
     /**
      *  Specifies whether equal elements in the collection are, in fact,
-     *  distinguishable with information not readily available.  That is, if a
-     *  particular value is to be removed from the collection, then there is
+     *  distinguishable with information not readily available.
+     *  <p>
+     *  If a particular value is to be removed from the collection, then there is
      *  one and only one value that can be removed, even if there are other
      *  elements which are equal to it.
-     *
-     *  <P>In most collection cases, elements are not distinguishable (equal is
+     *  </p>
+     *  <p>
+     *  In most collection cases, elements are not distinguishable (equal is
      *  equal), thus this method defaults to return false.  In some cases,
      *  however, they are.  For example, the collection returned from the map's
      *  values() collection view are backed by the map, so while there may be
      *  two values that are equal, their associated keys are not.  Since the
      *  keys are distinguishable, the values are.
-     *
-     *  <P>This flag is used to skip some verifications for iterator.remove()
+     *  </p>
+     *  <p>
+     *  This flag is used to skip some verifications for iterator.remove()
      *  where it is impossible to perform an equivalent modification on the
      *  confirmed collection because it is not possible to determine which
      *  value in the confirmed collection to actually remove.  Tests that
      *  override the default (i.e. where equal elements are distinguishable),
      *  should provide additional tests on iterator.remove() to make sure the
      *  proper elements are removed when remove() is called on the iterator.
-     **/
+     *  </p>
+     */
     public boolean areEqualElementsDistinguishable() {
         return false;
     }
@@ -304,13 +324,17 @@ public Collection<E> getConfirmed() {
 
     /**
      *  Returns an array of objects that are contained in a collection
-     *  produced by {@link #makeFullCollection()}.  Every element in the
-     *  returned array <em>must</em> be an element in a full collection.<P>
+     *  produced by {@link #makeFullCollection()}.
+     *  <p>
+     *  Every element in the returned array <em>must</em> be an element in a full collection.
+     *  </p>
+     *  <p>
      *  The default implementation returns a heterogeneous array of
      *  objects with some duplicates. null is added if allowed.
      *  Override if you require specific testing elements.  Note that if you
      *  override {@link #makeFullCollection()}, you <em>must</em> override
      *  this method to reflect the contents of a full collection.
+     *  <p>
      */
     @SuppressWarnings("unchecked")
     public E[] getFullElements() {
@@ -429,9 +453,11 @@ public Object[] getOtherNonNullStringElements() {
      *  Returns true if the collections produced by
      *  {@link #makeObject()} and {@link #makeFullCollection()}
      *  support the {@code add} and {@code addAll}
-     *  operations.<P>
+     *  operations.
+     *  <p>
      *  Default implementation returns true.  Override if your collection
      *  class does not support add or addAll.
+     *  </p>
      */
     public boolean isAddSupported() {
         return true;