diff --git a/src/main/java/org/apache/commons/beanutils2/BaseDynaBeanMapDecorator.java b/src/main/java/org/apache/commons/beanutils2/BaseDynaBeanMapDecorator.java
index da7f8bc..6adc4af 100644
--- a/src/main/java/org/apache/commons/beanutils2/BaseDynaBeanMapDecorator.java
+++ b/src/main/java/org/apache/commons/beanutils2/BaseDynaBeanMapDecorator.java
@@ -25,7 +25,7 @@
 import java.util.Set;
 
 /**
- * <p>A base class for decorators providing <code>Map</code> behavior on
+ * <p>A base class for decorators providing {@code Map} behavior on
  * {@link DynaBean}s.</p>
  *
  * <p>The motivation for this implementation is to provide access to {@link DynaBean}
@@ -54,7 +54,7 @@
     private final boolean readOnly;
     private transient Set<K> keySet;
 
-    // ------------------- Constructors ----------------------------------
+    
 
     /**
      * Constructs a read only Map for the specified
@@ -71,8 +71,8 @@
      * Construct a Map for the specified {@link DynaBean}.
      *
      * @param dynaBean The dyna bean being decorated
-     * @param readOnly <code>true</code> if the Map is read only
-     * otherwise <code>false</code>
+     * @param readOnly {@code true} if the Map is read only
+     * otherwise {@code false}
      * @throws IllegalArgumentException if the {@link DynaBean} is null.
      */
     public BaseDynaBeanMapDecorator(final DynaBean dynaBean, final boolean readOnly) {
@@ -84,20 +84,20 @@
     }
 
 
-    // ------------------- public Methods --------------------------------
+    
 
 
     /**
      * Indicate whether the Map is read only.
      *
-     * @return <code>true</code> if the Map is read only,
-     * otherwise <code>false</code>.
+     * @return {@code true} if the Map is read only,
+     * otherwise {@code false}.
      */
     public boolean isReadOnly() {
         return readOnly;
     }
 
-    // ------------------- java.util.Map Methods -------------------------
+    
 
     /**
      * clear() operation is not supported.
@@ -114,7 +114,7 @@
      * value for one (or more) of its properties.
      *
      * @param key The {@link DynaBean}'s property name
-     * @return <code>true</code> if one of the {@link DynaBean}'s
+     * @return {@code true} if one of the {@link DynaBean}'s
      * properties contains a specified value.
      */
     @Override
@@ -129,9 +129,9 @@
      * a specified value.
      *
      * @param value The value to check for.
-     * @return <code>true</code> if one of the the {@link DynaBean}'s
+     * @return {@code true} if one of the the {@link DynaBean}'s
      * properties contains the specified value, otherwise
-     * <code>false</code>.
+     * {@code false}.
      */
     @Override
     public boolean containsValue(final Object value) {
@@ -156,7 +156,7 @@
      * <p>Returns the Set of the property/value mappings
      * in the decorated {@link DynaBean}.</p>
      *
-     * <p>Each element in the Set is a <code>Map.Entry</code>
+     * <p>Each element in the Set is a {@code Map.Entry}
      * type.</p>
      *
      * @return An unmodifiable set of the DynaBean
@@ -190,8 +190,8 @@
      * Indicate whether the decorated {@link DynaBean} has
      * any properties.
      *
-     * @return <code>true</code> if the {@link DynaBean} has
-     * no properties, otherwise <code>false</code>.
+     * @return {@code true} if the {@link DynaBean} has
+     * no properties, otherwise {@code false}.
      */
     @Override
     public boolean isEmpty() {
@@ -241,7 +241,7 @@
      * @param value The value for the specified property.
      * @return The previous property's value.
      * @throws UnsupportedOperationException if
-     * <code>isReadOnly()</code> is true.
+     * {@code isReadOnly()} is true.
      */
     @Override
     public Object put(final K key, final Object value) {
@@ -259,7 +259,7 @@
      *
      * @param map The Map of values to copy.
      * @throws UnsupportedOperationException if
-     * <code>isReadOnly()</code> is true.
+     * {@code isReadOnly()} is true.
      */
     @Override
     public void putAll(final Map<? extends K, ? extends Object> map) {
@@ -311,7 +311,7 @@
         return Collections.unmodifiableList(values);
     }
 
-    // ------------------- protected Methods -----------------------------
+    
 
     /**
      * Provide access to the underlying {@link DynaBean}
@@ -331,7 +331,7 @@
      */
     protected abstract K convertKey(String propertyName);
 
-    // ------------------- private Methods -------------------------------
+    
 
     /**
      * Convenience method to retrieve the {@link DynaProperty}s
diff --git a/src/main/java/org/apache/commons/beanutils2/BasicDynaBean.java b/src/main/java/org/apache/commons/beanutils2/BasicDynaBean.java
index 1689ca0..6938955 100644
--- a/src/main/java/org/apache/commons/beanutils2/BasicDynaBean.java
+++ b/src/main/java/org/apache/commons/beanutils2/BasicDynaBean.java
@@ -27,7 +27,7 @@
 
 
 /**
- * <p>Minimal implementation of the <code>DynaBean</code> interface.  Can be
+ * <p>Minimal implementation of the {@code DynaBean} interface.  Can be
  * used as a convenience base class for more sophisticated implementations.</p>
  *
  * <p><strong>IMPLEMENTATION NOTE</strong> - Instances of this class that are
@@ -35,7 +35,7 @@
  *
  * <p><strong>IMPLEMENTATION NOTE</strong> - Instances of this class can be
  * successfully serialized and deserialized <strong>ONLY</strong> if all
- * property values are <code>Serializable</code>.</p>
+ * property values are {@code Serializable}.</p>
  *
  */
 
@@ -43,11 +43,11 @@
 
     private static final long serialVersionUID = 1L;
 
-    // ---------------------------------------------------------- Constructors
+
 
     /**
-     * Construct a new <code>DynaBean</code> associated with the specified
-     * <code>DynaClass</code> instance.
+     * Construct a new {@code DynaBean} associated with the specified
+     * {@code DynaClass} instance.
      *
      * @param dynaClass The DynaClass we are associated with
      */
@@ -59,11 +59,11 @@
     }
 
 
-    // ---------------------------------------------------- Instance Variables
+
 
 
     /**
-     * The <code>DynaClass</code> "base class" that this DynaBean
+     * The {@code DynaClass} "base class" that this DynaBean
      * is associated with.
      */
     protected DynaClass dynaClass = null;
@@ -82,8 +82,8 @@
      * Return a Map representation of this DynaBean.
      * <p>
      * This, for example, could be used in JSTL in the following way to access
-     * a DynaBean's <code>fooProperty</code>:
-     * <ul><li><code>${myDynaBean.<b>map</b>.fooProperty}</code></li></ul>
+     * a DynaBean's {@code fooProperty}:
+     * <ul><li>{@code ${myDynaBean.<b>map</b>.fooProperty}}</li></ul>
      *
      * @return a Map representation of this DynaBean
      * @since 1.8.0
@@ -98,7 +98,7 @@
 
     }
 
-    // ------------------------------------------------------ DynaBean Methods
+
 
 
     /**
@@ -107,8 +107,8 @@
      *
      * @param name Name of the property to check
      * @param key Name of the key to check
-     * @return <code>true</code> if the mapped property contains a value for
-     * the specified key, otherwise <code>false</code>
+     * @return {@code true} if the mapped property contains a value for
+     * the specified key, otherwise {@code false}
      *
      * @throws IllegalArgumentException if there is no property
      *  of the specified name
@@ -215,7 +215,7 @@
 
     /**
      * Return the value of a mapped property with the specified name,
-     * or <code>null</code> if there is no value for the specified key.
+     * or {@code null} if there is no value for the specified key.
      *
      * @param name Name of the property whose value is to be retrieved
      * @param key Key of the value to be retrieved
@@ -244,7 +244,7 @@
 
 
     /**
-     * Return the <code>DynaClass</code> instance that describes the set of
+     * Return the {@code DynaClass} instance that describes the set of
      * properties available for this DynaBean.
      *
      * @return The associated DynaClass
@@ -399,7 +399,7 @@
     }
 
 
-    // ------------------------------------------------------ Protected Methods
+
 
 
     /**
@@ -428,8 +428,8 @@
      *
      * @param dest Destination class
      * @param source Source class
-     * @return <code>true</code> if the source class is assignable to the
-     * destination class, otherwise <code>false</code>
+     * @return {@code true} if the source class is assignable to the
+     * destination class, otherwise {@code false}
      */
     protected boolean isAssignable(final Class<?> dest, final Class<?> source) {
 
diff --git a/src/main/java/org/apache/commons/beanutils2/BasicDynaClass.java b/src/main/java/org/apache/commons/beanutils2/BasicDynaClass.java
index 2c2a6b6..66ec0bb 100644
--- a/src/main/java/org/apache/commons/beanutils2/BasicDynaClass.java
+++ b/src/main/java/org/apache/commons/beanutils2/BasicDynaClass.java
@@ -26,11 +26,11 @@
 
 
 /**
- * <p>Minimal implementation of the <code>DynaClass</code> interface.  Can be
+ * <p>Minimal implementation of the {@code DynaClass} interface.  Can be
  * used as a convenience base class for more sophisticated implementations.</p>
- * <p><strong>IMPLEMENTATION NOTE</strong> - The <code>DynaBean</code>
+ * <p><strong>IMPLEMENTATION NOTE</strong> - The {@code DynaBean}
  * implementation class supplied to our constructor MUST have a one-argument
- * constructor of its own that accepts a <code>DynaClass</code>.  This is
+ * constructor of its own that accepts a {@code DynaClass}.  This is
  * used to associate the DynaBean instance with this DynaClass.</p>
  *
  */
@@ -39,7 +39,7 @@
 
     private static final long serialVersionUID = 1L;
 
-    // ----------------------------------------------------------- Constructors
+    
 
 
     /**
@@ -90,11 +90,11 @@
     }
 
 
-    // ----------------------------------------------------- Instance Variables
+    
 
 
     /**
-     * The constructor of the <code>dynaBeanClass</code> that we will use
+     * The constructor of the {@code dynaBeanClass} that we will use
      * for creating new instances.
      */
     protected transient Constructor<?> constructor = null;
@@ -115,7 +115,7 @@
 
 
     /**
-     * The <code>DynaBean</code> implementation class we will use for
+     * The {@code DynaBean} implementation class we will use for
      * creating new instances.
      */
     protected Class<?> dynaBeanClass = BasicDynaBean.class;
@@ -136,12 +136,12 @@
     /**
      * The set of dynamic properties that are part of this DynaClass,
      * keyed by the property name.  Individual descriptor instances will
-     * be the same instances as those in the <code>properties</code> list.
+     * be the same instances as those in the {@code properties} list.
      */
     protected HashMap<String, DynaProperty> propertiesMap = new HashMap<>();
 
 
-    // ------------------------------------------------------ DynaClass Methods
+    
 
 
     /**
@@ -231,7 +231,7 @@
     }
 
 
-    // --------------------------------------------------------- Public Methods
+    
 
 
     /**
@@ -248,7 +248,7 @@
     }
 
 
-    // ------------------------------------------------------ Protected Methods
+    
 
 
     /**
diff --git a/src/main/java/org/apache/commons/beanutils2/BeanAccessLanguageException.java b/src/main/java/org/apache/commons/beanutils2/BeanAccessLanguageException.java
index 25d51a6..0f0c8e8 100644
--- a/src/main/java/org/apache/commons/beanutils2/BeanAccessLanguageException.java
+++ b/src/main/java/org/apache/commons/beanutils2/BeanAccessLanguageException.java
@@ -29,17 +29,17 @@
 
     private static final long serialVersionUID = 1L;
 
-    // --------------------------------------------------------- Constructors
+    
 
     /**
-     * Constructs a <code>BeanAccessLanguageException</code> without a detail message.
+     * Constructs a {@code BeanAccessLanguageException} without a detail message.
      */
     public BeanAccessLanguageException() {
         super();
     }
 
     /**
-     * Constructs a <code>BeanAccessLanguageException</code> without a detail message.
+     * Constructs a {@code BeanAccessLanguageException} without a detail message.
      *
      * @param message the detail message explaining this exception
      */
diff --git a/src/main/java/org/apache/commons/beanutils2/BeanComparator.java b/src/main/java/org/apache/commons/beanutils2/BeanComparator.java
index 06f494d..381b26f 100644
--- a/src/main/java/org/apache/commons/beanutils2/BeanComparator.java
+++ b/src/main/java/org/apache/commons/beanutils2/BeanComparator.java
@@ -31,8 +31,8 @@
  * <p>
  * <strong>Note:</strong> The BeanComparator passes the values of the specified bean property to an internal natural
  * order {@link Comparator}, if no comparator is specified in the constructor. If you are comparing two beans based on a
- * property that could contain "null" values, a suitable <code>Comparator</code> or Apache Commons Collection
- * <code>ComparatorChain</code> should be supplied in the constructor. Note that the passed in {@code Comparator} must
+ * property that could contain "null" values, a suitable {@code Comparator} or Apache Commons Collection
+ * {@code ComparatorChain} should be supplied in the constructor. Note that the passed in {@code Comparator} must
  * be able to handle the passed in objects. Because the type of the property to be compared is not known at compile time
  * no type checks can be performed by the compiler. Thus {@code ClassCastException} exceptions can be thrown if
  * unexpected property values occur.
@@ -65,13 +65,13 @@
     /**
      * <p>
      * Constructs a property-based comparator for beans. This compares two beans by the property specified in the
-     * property parameter. This constructor creates a <code>BeanComparator</code> that uses a
-     * <code>ComparableComparator</code> to compare the property values.
+     * property parameter. This constructor creates a {@code BeanComparator} that uses a
+     * {@code ComparableComparator} to compare the property values.
      * </p>
      *
      * <p>
      * Passing "null" to this constructor will cause the BeanComparator to compare objects based on natural order, that
-     * is <code>java.lang.Comparable</code>.
+     * is {@code java.lang.Comparable}.
      * </p>
      *
      * @param property String Name of a bean property, which may contain the name of a simple, nested, indexed, mapped,
@@ -151,7 +151,7 @@
     }
 
     /**
-     * Two <code>BeanComparator</code>'s are equals if and only if the wrapped comparators and the property names to be
+     * Two {@code BeanComparator}'s are equals if and only if the wrapped comparators and the property names to be
      * compared are equal.
      *
      * @param o Comparator to compare to
diff --git a/src/main/java/org/apache/commons/beanutils2/BeanIntrospector.java b/src/main/java/org/apache/commons/beanutils2/BeanIntrospector.java
index c3058b1..12bfefb 100644
--- a/src/main/java/org/apache/commons/beanutils2/BeanIntrospector.java
+++ b/src/main/java/org/apache/commons/beanutils2/BeanIntrospector.java
@@ -27,7 +27,7 @@
  * Before {@link PropertyUtils} can be used for interaction with a specific Java
  * class, the class's properties have to be determined. This is called
  * <em>introspection</em> and is initiated automatically on demand.
- * <code>PropertyUtils</code> does not perform introspection on its own, but
+ * {@code PropertyUtils} does not perform introspection on its own, but
  * delegates this task to one or more objects implementing this interface. This
  * makes it possible to customize introspection which may be useful for certain
  * code bases using non-standard conventions for accessing properties.
@@ -38,7 +38,7 @@
 public interface BeanIntrospector {
     /**
      * Performs introspection on a Java class. The current class to be inspected
-     * can be queried from the passed in <code>IntrospectionContext</code>
+     * can be queried from the passed in {@code IntrospectionContext}
      * object. A typical implementation has to obtain this class, determine its
      * properties according to the rules it implements, and add them to the
      * passed in context object.
diff --git a/src/main/java/org/apache/commons/beanutils2/BeanMap.java b/src/main/java/org/apache/commons/beanutils2/BeanMap.java
index b7b5e3a..c6e77b8 100644
--- a/src/main/java/org/apache/commons/beanutils2/BeanMap.java
+++ b/src/main/java/org/apache/commons/beanutils2/BeanMap.java
@@ -77,17 +77,17 @@
     }
 
     // Constructors
-    // -------------------------------------------------------------------------
+    
 
     /**
-     * Constructs a new empty <code>BeanMap</code>.
+     * Constructs a new empty {@code BeanMap}.
      */
     public BeanMap() {
     }
 
     /**
-     * Constructs a new <code>BeanMap</code> that operates on the specified bean. If the given bean is
-     * <code>null</code>, then this map will be empty.
+     * Constructs a new {@code BeanMap} that operates on the specified bean. If the given bean is
+     * {@code null}, then this map will be empty.
      *
      * @param bean the bean for this map to operate on
      */
@@ -97,12 +97,12 @@
     }
 
     // Map interface
-    // -------------------------------------------------------------------------
+    
 
     /**
      * Renders a string representation of this object.
      *
-     * @return a <code>String</code> representation of this object
+     * @return a {@code String} representation of this object
      */
     @Override
     public String toString() {
@@ -197,7 +197,7 @@
     /**
      * This method reinitializes the bean map to have default values for the bean's properties. This is accomplished by
      * constructing a new instance of the bean which the map uses as its underlying data source. This behavior for
-     * <code>clear()</code> differs from the Map contract in that the mappings are not actually removed from the map
+     * {@code clear()} differs from the Map contract in that the mappings are not actually removed from the map
      * (the mappings for a BeanMap are fixed).
      */
     @Override
@@ -221,13 +221,13 @@
     /**
      * Returns true if the bean defines a property with the given name.
      * <p>
-     * The given name must be a <code>String</code>; if not, this method returns false. This method will also return
+     * The given name must be a {@code String}; if not, this method returns false. This method will also return
      * false if the bean does not define a property with that name.
      * <p>
      * Write-only properties will not be matched as the test operates against property read methods.
      *
      * @param name the name of the property to check
-     * @return false if the given name is null or is not a <code>String</code>; false if the bean does not define a
+     * @return false if the given name is null or is not a {@code String}; false if the bean does not define a
      *         property with that name; or true if the bean does define a property with that name
      */
     @Override
@@ -251,9 +251,9 @@
     /**
      * Returns the value of the bean's property with the given name.
      * <p>
-     * The given name must be a {@link String} and must not be null; otherwise, this method returns <code>null</code>.
+     * The given name must be a {@link String} and must not be null; otherwise, this method returns {@code null}.
      * If the bean defines a property with the given name, the value of that property is returned. Otherwise,
-     * <code>null</code> is returned.
+     * {@code null} is returned.
      * <p>
      * Write-only properties will not be matched as the test operates against property read methods.
      *
@@ -387,13 +387,13 @@
     }
 
     // Helper methods
-    // -------------------------------------------------------------------------
+    
 
     /**
      * Returns the type of the property with the given name.
      *
      * @param name the name of the property
-     * @return the type of the property, or <code>null</code> if no such property exists
+     * @return the type of the property, or {@code null} if no such property exists
      */
     public Class<?> getType(final String name) {
         return types.get(name);
@@ -466,7 +466,7 @@
     }
 
     // Properties
-    // -------------------------------------------------------------------------
+    
 
     /**
      * Returns the bean currently being operated on. The return value may be null if this map is empty.
@@ -508,7 +508,7 @@
     }
 
     // Implementation methods
-    // -------------------------------------------------------------------------
+    
 
     /**
      * Returns the accessor for the property with the given name.
@@ -588,7 +588,7 @@
     }
 
     // Implementation classes
-    // -------------------------------------------------------------------------
+    
 
     /**
      * Map entry used by {@link BeanMap}.
@@ -599,7 +599,7 @@
         private final BeanMap owner;
 
         /**
-         * Constructs a new <code>Entry</code>.
+         * Constructs a new {@code Entry}.
          *
          * @param owner the BeanMap this entry belongs to
          * @param key the key for this entry
@@ -679,7 +679,7 @@
      * If no such constructor exists, and the given type is a primitive type, then the given value is converted to a
      * string using its {@link Object#toString() toString()} method, and that string is parsed into the correct
      * primitive type using, for instance, {@link Integer#valueOf(String)} to convert the string into an
-     * <code>int</code>.
+     * {@code int}.
      * <P>
      *
      * If no special constructor exists and the given type is not a primitive type, this method returns the original
@@ -723,7 +723,7 @@
     }
 
     /**
-     * Logs the given exception to <code>System.out</code>. Used to display warnings while accessing/mutating the bean.
+     * Logs the given exception to {@code System.out}. Used to display warnings while accessing/mutating the bean.
      *
      * @param ex the exception to log
      */
@@ -733,7 +733,7 @@
     }
 
     /**
-     * Logs the given exception to <code>System.err</code>. Used to display errors while accessing/mutating the bean.
+     * Logs the given exception to {@code System.err}. Used to display errors while accessing/mutating the bean.
      *
      * @param ex the exception to log
      */
diff --git a/src/main/java/org/apache/commons/beanutils2/BeanPredicate.java b/src/main/java/org/apache/commons/beanutils2/BeanPredicate.java
index 3e49829..ed3f1a9 100644
--- a/src/main/java/org/apache/commons/beanutils2/BeanPredicate.java
+++ b/src/main/java/org/apache/commons/beanutils2/BeanPredicate.java
@@ -24,7 +24,7 @@
 import org.apache.commons.logging.LogFactory;
 
 /**
- * <p>Predicate implementation that applies the given <code>Predicate</code>
+ * <p>Predicate implementation that applies the given {@code Predicate}
  * to the result of calling the given property getter.
  * </p>
  *
@@ -36,15 +36,15 @@
 
     /** Name of the property whose value will be predicated */
     private String propertyName;
-    /** <code>Predicate</code> to be applied to the property value */
+    /** {@code Predicate} to be applied to the property value */
     private Predicate<T> predicate;
 
     /**
-     * Constructs a <code>BeanPredicate</code> that applies the given
-     * <code>Predicate</code> to the named property value.
+     * Constructs a {@code BeanPredicate} that applies the given
+     * {@code Predicate} to the named property value.
      * @param propertyName the name of the property whose value is to be predicated,
      * not null
-     * @param predicate the <code>Predicate</code> to be applied,
+     * @param predicate the {@code Predicate} to be applied,
      * not null
      */
     public BeanPredicate(final String propertyName, final Predicate<T> predicate) {
@@ -107,18 +107,18 @@
     }
 
     /**
-     * Gets the <code>Predicate</code> to be applied to the value of the named property
+     * Gets the {@code Predicate} to be applied to the value of the named property
      * during {@link #test(Object)}.
-     * @return <code>Predicate</code>, not null
+     * @return {@code Predicate}, not null
      */
     public Predicate<T> getPredicate() {
         return predicate;
     }
 
     /**
-     * Sets the <code>Predicate</code> to be applied to the value of the named property
+     * Sets the {@code Predicate} to be applied to the value of the named property
      * during {@link #test(Object)}.
-     * @param predicate <code>Predicate</code>, not null
+     * @param predicate {@code Predicate}, not null
      */
     public void setPredicate(final Predicate<T> predicate) {
         this.predicate = predicate;
diff --git a/src/main/java/org/apache/commons/beanutils2/BeanPropertyValueChangeConsumer.java b/src/main/java/org/apache/commons/beanutils2/BeanPropertyValueChangeConsumer.java
index 6d014c5..0b6a698 100644
--- a/src/main/java/org/apache/commons/beanutils2/BeanPropertyValueChangeConsumer.java
+++ b/src/main/java/org/apache/commons/beanutils2/BeanPropertyValueChangeConsumer.java
@@ -25,27 +25,27 @@
 
 
 /**
- * <p><code>Closure</code> that sets a property.</p>
+ * <p>{@code Closure} that sets a property.</p>
  * <p>
- * An implementation of <code>java.util.function.Consumer</code> that updates
+ * An implementation of {@code java.util.function.Consumer} that updates
  * a specified property on the object provided with a specified value.
- * The <code>BeanPropertyValueChangeClosure</code> constructor takes two parameters which determine
+ * The {@code BeanPropertyValueChangeClosure} constructor takes two parameters which determine
  * what property will be updated and with what value.
  * <dl>
  *    <dt>
- *       <code>public BeanPropertyValueChangeClosure( String propertyName, Object propertyValue )</code>
+ *       {@code public BeanPropertyValueChangeClosure( String propertyName, Object propertyValue )}
  *    </dt>
  *    <dd>
- *       Will create a <code>Closure</code> that will update an object by setting the property
- *       specified by <code>propertyName</code> to the value specified by <code>propertyValue</code>.
+ *       Will create a {@code Closure} that will update an object by setting the property
+ *       specified by {@code propertyName</code> to the value specified by <code>propertyValue}.
  *    </dd>
  * </dl>
  *
  * <p>
  * <strong>Note:</strong> Property names can be a simple, nested, indexed, or mapped property as defined by
- * <code>org.apache.commons.beanutils2.PropertyUtils</code>.  If any object in the property path
- * specified by <code>propertyName</code> is <code>null</code> then the outcome is based on the
- * value of the <code>ignoreNull</code> attribute.
+ * {@code org.apache.commons.beanutils2.PropertyUtils}.  If any object in the property path
+ * specified by {@code propertyName</code> is <code>null} then the outcome is based on the
+ * value of the {@code ignoreNull} attribute.
  * </p>
  * <p>
  * A typical usage might look like:
@@ -59,17 +59,17 @@
  * CollectionUtils.forAllDo( peopleCollection, closure );
  * </code></pre>
  *
- * This would take a <code>Collection</code> of person objects and update the
- * <code>activeEmployee</code> property of each object in the <code>Collection</code> to
- * <code>true</code>. Assuming...
+ * This would take a {@code Collection} of person objects and update the
+ * {@code activeEmployee</code> property of each object in the <code>Collection} to
+ * {@code true}. Assuming...
  * <ul>
  *    <li>
- *       The top level object in the <code>peopleCollection</code> is an object which represents a
+ *       The top level object in the {@code peopleCollection} is an object which represents a
  *       person.
  *    </li>
  *    <li>
- *       The person object has a <code>setActiveEmployee( boolean )</code> method which updates
- *       the value for the object's <code>activeEmployee</code> property.
+ *       The person object has a {@code setActiveEmployee( boolean )} method which updates
+ *       the value for the object's {@code activeEmployee} property.
  *    </li>
  * </ul>
  *
@@ -85,35 +85,35 @@
     private final Log log = LogFactory.getLog(this.getClass());
 
     /**
-     * The name of the property which will be updated when this <code>Closure</code> executes.
+     * The name of the property which will be updated when this {@code Closure} executes.
      */
     private String propertyName;
 
     /**
-     * The value that the property specified by <code>propertyName</code>
-     * will be updated to when this <code>Closure</code> executes.
+     * The value that the property specified by {@code propertyName}
+     * will be updated to when this {@code Closure} executes.
      */
     private V propertyValue;
 
     /**
-     * Determines whether <code>null</code> objects in the property path will generate an
-     * <code>IllegalArgumentException</code> or not. If set to <code>true</code> then if any objects
-     * in the property path leading up to the target property evaluate to <code>null</code> then the
-     * <code>IllegalArgumentException</code> throw by <code>PropertyUtils</code> will be logged but
-     * not re-thrown.  If set to <code>false</code> then if any objects in the property path leading
-     * up to the target property evaluate to <code>null</code> then the
-     * <code>IllegalArgumentException</code> throw by <code>PropertyUtils</code> will be logged and
+     * Determines whether {@code null} objects in the property path will generate an
+     * {@code IllegalArgumentException</code> or not. If set to <code>true} then if any objects
+     * in the property path leading up to the target property evaluate to {@code null} then the
+     * {@code IllegalArgumentException</code> throw by <code>PropertyUtils} will be logged but
+     * not re-thrown.  If set to {@code false} then if any objects in the property path leading
+     * up to the target property evaluate to {@code null} then the
+     * {@code IllegalArgumentException</code> throw by <code>PropertyUtils} will be logged and
      * re-thrown.
      */
     private boolean ignoreNull;
 
     /**
      * Constructor which takes the name of the property to be changed, the new value to set
-     * the property to, and assumes <code>ignoreNull</code> to be <code>false</code>.
+     * the property to, and assumes {@code ignoreNull</code> to be <code>false}.
      *
      * @param propertyName The name of the property that will be updated with the value specified by
-     * <code>propertyValue</code>.
-     * @param propertyValue The value that <code>propertyName</code> will be set to on the target
+     * {@code propertyValue}.
+     * @param propertyValue The value that {@code propertyName} will be set to on the target
      * object.
      * @throws IllegalArgumentException If the propertyName provided is null or empty.
      */
@@ -123,15 +123,15 @@
 
     /**
      * Constructor which takes the name of the property to be changed, the new value to set
-     * the property to and a boolean which determines whether <code>null</code> objects in the
-     * property path will generate an <code>IllegalArgumentException</code> or not.
+     * the property to and a boolean which determines whether {@code null} objects in the
+     * property path will generate an {@code IllegalArgumentException} or not.
      *
      * @param propertyName The name of the property that will be updated with the value specified by
-     * <code>propertyValue</code>.
-     * @param propertyValue The value that <code>propertyName</code> will be set to on the target
+     * {@code propertyValue}.
+     * @param propertyValue The value that {@code propertyName} will be set to on the target
      * object.
-     * @param ignoreNull Determines whether <code>null</code> objects in the property path will
-     * generate an <code>IllegalArgumentException</code> or not.
+     * @param ignoreNull Determines whether {@code null} objects in the property path will
+     * generate an {@code IllegalArgumentException} or not.
      * @throws IllegalArgumentException If the propertyName provided is null or empty.
      */
     public BeanPropertyValueChangeConsumer(final String propertyName, final V propertyValue, final boolean ignoreNull) {
@@ -148,17 +148,17 @@
 
     /**
      * Updates the target object provided using the property update criteria provided when this
-     * <code>BeanPropertyValueChangeClosure</code> was constructed.  If any object in the property
-     * path leading up to the target property is <code>null</code> then the outcome will be based on
-     * the value of the <code>ignoreNull</code> attribute. By default, <code>ignoreNull</code> is
-     * <code>false</code> and would result in an <code>IllegalArgumentException</code> if an object
-     * in the property path leading up to the target property is <code>null</code>.
+     * {@code BeanPropertyValueChangeClosure} was constructed.  If any object in the property
+     * path leading up to the target property is {@code null} then the outcome will be based on
+     * the value of the {@code ignoreNull</code> attribute. By default, <code>ignoreNull} is
+     * {@code false</code> and would result in an <code>IllegalArgumentException} if an object
+     * in the property path leading up to the target property is {@code null}.
      *
      * @param object The object to be updated.
      * @throws IllegalArgumentException If an IllegalAccessException, InvocationTargetException, or
      * NoSuchMethodException is thrown when trying to access the property specified on the object
-     * provided. Or if an object in the property path provided is <code>null</code> and
-     * <code>ignoreNull</code> is set to <code>false</code>.
+     * provided. Or if an object in the property path provided is {@code null} and
+     * {@code ignoreNull</code> is set to <code>false}.
      */
     @Override
     public void accept(final Object object) {
@@ -202,37 +202,37 @@
     }
 
     /**
-     * Returns the name of the property which will be updated when this <code>Closure</code> executes.
+     * Returns the name of the property which will be updated when this {@code Closure} executes.
      *
-     * @return The name of the property which will be updated when this <code>Closure</code> executes.
+     * @return The name of the property which will be updated when this {@code Closure} executes.
      */
     public String getPropertyName() {
         return propertyName;
     }
 
     /**
-     * Returns the value that the property specified by <code>propertyName</code>
-     * will be updated to when this <code>Closure</code> executes.
+     * Returns the value that the property specified by {@code propertyName}
+     * will be updated to when this {@code Closure} executes.
      *
-     * @return The value that the property specified by <code>propertyName</code>
-     * will be updated to when this <code>Closure</code> executes.
+     * @return The value that the property specified by {@code propertyName}
+     * will be updated to when this {@code Closure} executes.
      */
     public V getPropertyValue() {
         return propertyValue;
     }
 
     /**
-     * Returns the flag that determines whether <code>null</code> objects in the property path will
-     * generate an <code>IllegalArgumentException</code> or not. If set to <code>true</code> then
+     * Returns the flag that determines whether {@code null} objects in the property path will
+     * generate an {@code IllegalArgumentException</code> or not. If set to <code>true} then
      * if any objects in the property path leading up to the target property evaluate to
-     * <code>null</code> then the <code>IllegalArgumentException</code> throw by
-     * <code>PropertyUtils</code> will be logged but not re-thrown.  If set to <code>false</code> then
+     * {@code null</code> then the <code>IllegalArgumentException} throw by
+     * {@code PropertyUtils</code> will be logged but not re-thrown.  If set to <code>false} then
      * if any objects in the property path leading up to the target property evaluate to
-     * <code>null</code> then the <code>IllegalArgumentException</code> throw by
-     * <code>PropertyUtils</code> will be logged and re-thrown.
+     * {@code null</code> then the <code>IllegalArgumentException} throw by
+     * {@code PropertyUtils} will be logged and re-thrown.
      *
-     * @return The flag that determines whether <code>null</code> objects in the property path will
-     * generate an <code>IllegalArgumentException</code> or not.
+     * @return The flag that determines whether {@code null} objects in the property path will
+     * generate an {@code IllegalArgumentException} or not.
      */
     public boolean isIgnoreNull() {
         return ignoreNull;
diff --git a/src/main/java/org/apache/commons/beanutils2/BeanPropertyValueEqualsPredicate.java b/src/main/java/org/apache/commons/beanutils2/BeanPropertyValueEqualsPredicate.java
index 586f6ec..1f8f7ce 100644
--- a/src/main/java/org/apache/commons/beanutils2/BeanPropertyValueEqualsPredicate.java
+++ b/src/main/java/org/apache/commons/beanutils2/BeanPropertyValueEqualsPredicate.java
@@ -24,33 +24,33 @@
 import org.apache.commons.logging.LogFactory;
 
 /**
- * <p><code>Predicate</code> that evaluates a property value against a specified value.</p>
+ * <p>{@code Predicate} that evaluates a property value against a specified value.</p>
  * <p>
- * An implementation of <code>java.util.function.Predicate</code> that evaluates a
- * property value on the object provided against a specified value and returns <code>true</code>
- * if equal; <code>false</code> otherwise.
- * The <code>BeanPropertyValueEqualsPredicate</code> constructor takes two parameters which
+ * An implementation of {@code java.util.function.Predicate} that evaluates a
+ * property value on the object provided against a specified value and returns {@code true}
+ * if equal; {@code false} otherwise.
+ * The {@code BeanPropertyValueEqualsPredicate} constructor takes two parameters which
  * determine what property will be evaluated on the target object and what its expected value should
  * be.
  * </p>
  * <dl>
  *    <dt>
  *       <strong>
- *           <code>public BeanPropertyValueEqualsPredicate( String propertyName, Object propertyValue )</code>
+ *           {@code public BeanPropertyValueEqualsPredicate( String propertyName, Object propertyValue )}
  *       </strong>
  *    </dt>
  *    <dd>
- *       Will create a <code>Predicate</code> that will evaluate the target object and return
- *       <code>true</code> if the property specified by <code>propertyName</code> has a value which
- *       is equal to the the value specified by <code>propertyValue</code>. Or return
- *       <code>false</code> otherwise.
+ *       Will create a {@code Predicate} that will evaluate the target object and return
+ *       {@code true</code> if the property specified by <code>propertyName} has a value which
+ *       is equal to the the value specified by {@code propertyValue}. Or return
+ *       {@code false} otherwise.
  *    </dd>
  * </dl>
  * <p>
  * <strong>Note:</strong> Property names can be a simple, nested, indexed, or mapped property as defined by
- * <code>org.apache.commons.beanutils2.PropertyUtils</code>.  If any object in the property path
- * specified by <code>propertyName</code> is <code>null</code> then the outcome is based on the
- * value of the <code>ignoreNull</code> attribute.
+ * {@code org.apache.commons.beanutils2.PropertyUtils}.  If any object in the property path
+ * specified by {@code propertyName</code> is <code>null} then the outcome is based on the
+ * value of the {@code ignoreNull} attribute.
  * </p>
  * <p>
  * A typical usage might look like:
@@ -64,17 +64,17 @@
  * CollectionUtils.filter( peopleCollection, predicate );
  * </code></pre>
  * <p>
- * This would take a <code>Collection</code> of person objects and filter out any people whose
- * <code>activeEmployee</code> property is <code>false</code>. Assuming...
+ * This would take a {@code Collection} of person objects and filter out any people whose
+ * {@code activeEmployee</code> property is <code>false}. Assuming...
  * </p>
  * <ul>
  *    <li>
- *       The top level object in the <code>peeopleCollection</code> is an object which represents a
+ *       The top level object in the {@code peeopleCollection} is an object which represents a
  *       person.
  *    </li>
  *    <li>
- *       The person object has a <code>getActiveEmployee()</code> method which returns
- *       the boolean value for the object's <code>activeEmployee</code> property.
+ *       The person object has a {@code getActiveEmployee()} method which returns
+ *       the boolean value for the object's {@code activeEmployee} property.
  *    </li>
  * </ul>
  * <p>
@@ -89,17 +89,17 @@
  * CollectionUtils.find( peopleCollection, predicate );
  * </code></pre>
  * <p>
- * This would search a <code>Collection</code> of person objects and return the first object whose
- * <code>personId</code> property value equals <code>456-12-1234</code>. Assuming...
+ * This would search a {@code Collection} of person objects and return the first object whose
+ * {@code personId</code> property value equals <code>456-12-1234}. Assuming...
  * </p>
  * <ul>
  *    <li>
- *       The top level object in the <code>peeopleCollection</code> is an object which represents a
+ *       The top level object in the {@code peeopleCollection} is an object which represents a
  *       person.
  *    </li>
  *    <li>
- *       The person object has a <code>getPersonId()</code> method which returns
- *       the value for the object's <code>personId</code> property.
+ *       The person object has a {@code getPersonId()} method which returns
+ *       the value for the object's {@code personId} property.
  *    </li>
  * </ul>
  *
@@ -115,26 +115,26 @@
     private final Log log = LogFactory.getLog(this.getClass());
 
     /**
-     * The name of the property which will be evaluated when this <code>Predicate</code> is executed.
+     * The name of the property which will be evaluated when this {@code Predicate} is executed.
      */
     private String propertyName;
 
     /**
-     * The value that the property specified by <code>propertyName</code>
-     * will be compared to when this <code>Predicate</code> executes.
+     * The value that the property specified by {@code propertyName}
+     * will be compared to when this {@code Predicate} executes.
      */
     private V propertyValue;
 
     /**
-     * <p>Should <code>null</code> objects in the property path be ignored?</p>
+     * <p>Should {@code null} objects in the property path be ignored?</p>
      * <p>
-     * Determines whether <code>null</code> objects in the property path will generate an
-     * <code>IllegalArgumentException</code> or not. If set to <code>true</code> then if any objects
-     * in the property path evaluate to <code>null</code> then the
-     * <code>IllegalArgumentException</code> throw by <code>PropertyUtils</code> will be logged but
-     * not re-thrown and <code>false</code> will be returned.  If set to <code>false</code> then if
-     * any objects in the property path evaluate to <code>null</code> then the
-     * <code>IllegalArgumentException</code> throw by <code>PropertyUtils</code> will be logged and
+     * Determines whether {@code null} objects in the property path will generate an
+     * {@code IllegalArgumentException</code> or not. If set to <code>true} then if any objects
+     * in the property path evaluate to {@code null} then the
+     * {@code IllegalArgumentException</code> throw by <code>PropertyUtils} will be logged but
+     * not re-thrown and {@code false</code> will be returned.  If set to <code>false} then if
+     * any objects in the property path evaluate to {@code null} then the
+     * {@code IllegalArgumentException</code> throw by <code>PropertyUtils} will be logged and
      * re-thrown.
      * </p>
      */
@@ -142,7 +142,7 @@
 
     /**
      * Constructor which takes the name of the property, its expected value to be used in evaluation,
-     * and assumes <code>ignoreNull</code> to be <code>false</code>.
+     * and assumes {@code ignoreNull</code> to be <code>false}.
      *
      * @param propertyName The name of the property that will be evaluated against the expected value.
      * @param propertyValue The value to use in object evaluation.
@@ -154,13 +154,13 @@
 
     /**
      * Constructor which takes the name of the property, its expected value
-     * to be used in evaluation, and a boolean which determines whether <code>null</code> objects in
-     * the property path will generate an <code>IllegalArgumentException</code> or not.
+     * to be used in evaluation, and a boolean which determines whether {@code null} objects in
+     * the property path will generate an {@code IllegalArgumentException} or not.
      *
      * @param propertyName The name of the property that will be evaluated against the expected value.
      * @param propertyValue The value to use in object evaluation.
-     * @param ignoreNull Determines whether <code>null</code> objects in the property path will
-     * generate an <code>IllegalArgumentException</code> or not.
+     * @param ignoreNull Determines whether {@code null} objects in the property path will
+     * generate an {@code IllegalArgumentException} or not.
      * @throws IllegalArgumentException If the property name provided is null or empty.
      */
     public BeanPropertyValueEqualsPredicate(final String propertyName, final V propertyValue, final boolean ignoreNull) {
@@ -177,21 +177,21 @@
 
     /**
      * Evaluates the object provided against the criteria specified when this
-     * <code>BeanPropertyValueEqualsPredicate</code> was constructed.  Equality is based on
+     * {@code BeanPropertyValueEqualsPredicate} was constructed.  Equality is based on
      * either reference or logical equality as defined by the property object's equals method. If
-     * any object in the property path leading up to the target property is <code>null</code> then
-     * the outcome will be based on the value of the <code>ignoreNull</code> attribute. By default,
-     * <code>ignoreNull</code> is <code>false</code> and would result in an
-     * <code>IllegalArgumentException</code> if an object in the property path leading up to the
-     * target property is <code>null</code>.
+     * any object in the property path leading up to the target property is {@code null} then
+     * the outcome will be based on the value of the {@code ignoreNull} attribute. By default,
+     * {@code ignoreNull</code> is <code>false} and would result in an
+     * {@code IllegalArgumentException} if an object in the property path leading up to the
+     * target property is {@code null}.
      *
      * @param object The object to be evaluated.
-     * @return True if the object provided meets all the criteria for this <code>Predicate</code>;
+     * @return True if the object provided meets all the criteria for this {@code Predicate};
      * false otherwise.
      * @throws IllegalArgumentException If an IllegalAccessException, InvocationTargetException, or
      * NoSuchMethodException is thrown when trying to access the property specified on the object
-     * provided. Or if an object in the property path provided is <code>null</code> and
-     * <code>ignoreNull</code> is set to <code>false</code>.
+     * provided. Or if an object in the property path provided is {@code null} and
+     * {@code ignoreNull</code> is set to <code>false}.
      */
     @Override
     public boolean test(final T object) {
@@ -252,10 +252,10 @@
     }
 
     /**
-     * Returns the name of the property which will be evaluated when this <code>Predicate</code> is
+     * Returns the name of the property which will be evaluated when this {@code Predicate} is
      * executed.
      *
-     * @return The name of the property which will be evaluated when this <code>Predicate</code> is
+     * @return The name of the property which will be evaluated when this {@code Predicate} is
      * executed.
      */
     public String getPropertyName() {
@@ -263,28 +263,28 @@
     }
 
     /**
-     * Returns the value that the property specified by <code>propertyName</code> will be compared to
-     * when this <code>Predicate</code> executes.
+     * Returns the value that the property specified by {@code propertyName} will be compared to
+     * when this {@code Predicate} executes.
      *
-     * @return The value that the property specified by <code>propertyName</code> will be compared to
-     * when this <code>Predicate</code> executes.
+     * @return The value that the property specified by {@code propertyName} will be compared to
+     * when this {@code Predicate} executes.
      */
     public V getPropertyValue() {
         return propertyValue;
     }
 
     /**
-     * Returns the flag which determines whether <code>null</code> objects in the property path will
-     * generate an <code>IllegalArgumentException</code> or not. If set to <code>true</code> then
-     * if any objects in the property path evaluate to <code>null</code> then the
-     * <code>IllegalArgumentException</code> throw by <code>PropertyUtils</code> will be logged but
-     * not re-thrown and <code>false</code> will be returned.  If set to <code>false</code> then if
-     * any objects in the property path evaluate to <code>null</code> then the
-     * <code>IllegalArgumentException</code> throw by <code>PropertyUtils</code> will be logged and
+     * Returns the flag which determines whether {@code null} objects in the property path will
+     * generate an {@code IllegalArgumentException</code> or not. If set to <code>true} then
+     * if any objects in the property path evaluate to {@code null} then the
+     * {@code IllegalArgumentException</code> throw by <code>PropertyUtils} will be logged but
+     * not re-thrown and {@code false</code> will be returned.  If set to <code>false} then if
+     * any objects in the property path evaluate to {@code null} then the
+     * {@code IllegalArgumentException</code> throw by <code>PropertyUtils} will be logged and
      * re-thrown.
      *
-     * @return The flag which determines whether <code>null</code> objects in the property path will
-     * generate an <code>IllegalArgumentException</code> or not.
+     * @return The flag which determines whether {@code null} objects in the property path will
+     * generate an {@code IllegalArgumentException} or not.
      */
     public boolean isIgnoreNull() {
         return ignoreNull;
diff --git a/src/main/java/org/apache/commons/beanutils2/BeanToPropertyValueTransformer.java b/src/main/java/org/apache/commons/beanutils2/BeanToPropertyValueTransformer.java
index 1a13701..2785537 100644
--- a/src/main/java/org/apache/commons/beanutils2/BeanToPropertyValueTransformer.java
+++ b/src/main/java/org/apache/commons/beanutils2/BeanToPropertyValueTransformer.java
@@ -25,15 +25,15 @@
 
 
 /**
- * <p><code>Transformer</code> that outputs a property value.</p>
+ * <p>{@code Transformer} that outputs a property value.</p>
  *
- * <p>An implementation of <code>java.util.function.Function</code> that transforms
+ * <p>An implementation of {@code java.util.function.Function} that transforms
  * the object provided by returning the value of a specified property of the object.  The
- * constructor for <code>BeanToPropertyValueTransformer</code> requires the name of the property
+ * constructor for {@code BeanToPropertyValueTransformer} requires the name of the property
  * that will be used in the transformation.  The property can be a simple, nested, indexed, or
- * mapped property as defined by <code>org.apache.commons.beanutils2.PropertyUtils</code>. If any
- * object in the property path specified by <code>propertyName</code> is <code>null</code> then the
- * outcome is based on the value of the <code>ignoreNull</code> attribute.
+ * mapped property as defined by {@code org.apache.commons.beanutils2.PropertyUtils}. If any
+ * object in the property path specified by {@code propertyName</code> is <code>null} then the
+ * outcome is based on the value of the {@code ignoreNull} attribute.
  * </p>
  *
  * <p>
@@ -48,19 +48,19 @@
  * </code></pre>
  *
  * <p>
- * This would take a <code>Collection</code> of person objects and return a <code>Collection</code>
+ * This would take a {@code Collection</code> of person objects and return a <code>Collection}
  * of objects which represents the cities in which each person lived. Assuming...
  * <ul>
  *    <li>
- *       The top level object in the <code>peeopleCollection</code> is an object which represents a
+ *       The top level object in the {@code peeopleCollection} is an object which represents a
  *       person.
  *    </li>
  *    <li>
- *       The person object has a <code>getAddress()</code> method which returns an object which
+ *       The person object has a {@code getAddress()} method which returns an object which
  *       represents a person's address.
  *    </li>
  *    <li>
- *       The address object has a <code>getCity()</code> method which returns an object which
+ *       The address object has a {@code getCity()} method which returns an object which
  *       represents the city in which a person lives.
  *    </li>
  * </ul>
@@ -80,15 +80,15 @@
     private String propertyName;
 
     /**
-     * <p>Should null objects on the property path throw an <code>IllegalArgumentException</code>?</p>
+     * <p>Should null objects on the property path throw an {@code IllegalArgumentException}?</p>
      * <p>
-     * Determines whether <code>null</code> objects in the property path will generate an
-     * <code>IllegalArgumentException</code> or not. If set to <code>true</code> then if any objects
-     * in the property path evaluate to <code>null</code> then the
-     * <code>IllegalArgumentException</code> throw by <code>PropertyUtils</code> will be logged but
-     * not re-thrown and <code>null</code> will be returned.  If set to <code>false</code> then if any
-     * objects in the property path evaluate to <code>null</code> then the
-     * <code>IllegalArgumentException</code> throw by <code>PropertyUtils</code> will be logged and
+     * Determines whether {@code null} objects in the property path will generate an
+     * {@code IllegalArgumentException</code> or not. If set to <code>true} then if any objects
+     * in the property path evaluate to {@code null} then the
+     * {@code IllegalArgumentException</code> throw by <code>PropertyUtils} will be logged but
+     * not re-thrown and {@code null</code> will be returned.  If set to <code>false} then if any
+     * objects in the property path evaluate to {@code null} then the
+     * {@code IllegalArgumentException</code> throw by <code>PropertyUtils} will be logged and
      * re-thrown.
      * </p>
      */
@@ -97,10 +97,10 @@
     /**
      * Constructs a Transformer which does not ignore nulls.
      * Constructor which takes the name of the property that will be used in the transformation and
-     * assumes <code>ignoreNull</code> to be <code>false</code>.
+     * assumes {@code ignoreNull</code> to be <code>false}.
      *
      * @param propertyName The name of the property that will be used in the transformation.
-     * @throws IllegalArgumentException If the <code>propertyName</code> is <code>null</code> or
+     * @throws IllegalArgumentException If the {@code propertyName</code> is <code>null} or
      * empty.
      */
     public BeanToPropertyValueTransformer(final String propertyName) {
@@ -110,13 +110,13 @@
     /**
      * Constructs a Transformer and sets ignoreNull.
      * Constructor which takes the name of the property that will be used in the transformation and
-     * a boolean which determines whether <code>null</code> objects in the property path will
-     * generate an <code>IllegalArgumentException</code> or not.
+     * a boolean which determines whether {@code null} objects in the property path will
+     * generate an {@code IllegalArgumentException} or not.
      *
      * @param propertyName The name of the property that will be used in the transformation.
-     * @param ignoreNull Determines whether <code>null</code> objects in the property path will
-     * generate an <code>IllegalArgumentException</code> or not.
-     * @throws IllegalArgumentException If the <code>propertyName</code> is <code>null</code> or
+     * @param ignoreNull Determines whether {@code null} objects in the property path will
+     * generate an {@code IllegalArgumentException} or not.
+     * @throws IllegalArgumentException If the {@code propertyName</code> is <code>null} or
      * empty.
      */
     public BeanToPropertyValueTransformer(final String propertyName, final boolean ignoreNull) {
@@ -134,18 +134,18 @@
     /**
      * Returns the value of the property named in the transformer's constructor for
      * the object provided. If any object in the property path leading up to the target property is
-     * <code>null</code> then the outcome will be based on the value of the <code>ignoreNull</code>
-     * attribute. By default, <code>ignoreNull</code> is <code>false</code> and would result in an
-     * <code>IllegalArgumentException</code> if an object in the property path leading up to the
-     * target property is <code>null</code>.
+     * {@code null</code> then the outcome will be based on the value of the <code>ignoreNull}
+     * attribute. By default, {@code ignoreNull</code> is <code>false} and would result in an
+     * {@code IllegalArgumentException} if an object in the property path leading up to the
+     * target property is {@code null}.
      *
      * @param object The object to be transformed.
      * @return The value of the property named in the transformer's constructor for the object
      * provided.
      * @throws IllegalArgumentException If an IllegalAccessException, InvocationTargetException, or
      * NoSuchMethodException is thrown when trying to access the property specified on the object
-     * provided. Or if an object in the property path provided is <code>null</code> and
-     * <code>ignoreNull</code> is set to <code>false</code>.
+     * provided. Or if an object in the property path provided is {@code null} and
+     * {@code ignoreNull</code> is set to <code>false}.
      */
     @Override
     public R apply(final T object) {
@@ -203,17 +203,17 @@
     }
 
     /**
-     * Returns the flag which determines whether <code>null</code> objects in the property path will
-     * generate an <code>IllegalArgumentException</code> or not. If set to <code>true</code> then
-     * if any objects in the property path evaluate to <code>null</code> then the
-     * <code>IllegalArgumentException</code> throw by <code>PropertyUtils</code> will be logged but
-     * not re-thrown and <code>null</code> will be returned.  If set to <code>false</code> then if any
-     * objects in the property path evaluate to <code>null</code> then the
-     * <code>IllegalArgumentException</code> throw by <code>PropertyUtils</code> will be logged and
+     * Returns the flag which determines whether {@code null} objects in the property path will
+     * generate an {@code IllegalArgumentException</code> or not. If set to <code>true} then
+     * if any objects in the property path evaluate to {@code null} then the
+     * {@code IllegalArgumentException</code> throw by <code>PropertyUtils} will be logged but
+     * not re-thrown and {@code null</code> will be returned.  If set to <code>false} then if any
+     * objects in the property path evaluate to {@code null} then the
+     * {@code IllegalArgumentException</code> throw by <code>PropertyUtils} will be logged and
      * re-thrown.
      *
-     * @return The flag which determines whether <code>null</code> objects in the property path will
-     * generate an <code>IllegalArgumentException</code> or not.
+     * @return The flag which determines whether {@code null} objects in the property path will
+     * generate an {@code IllegalArgumentException} or not.
      */
     public boolean isIgnoreNull() {
         return ignoreNull;
diff --git a/src/main/java/org/apache/commons/beanutils2/BeanUtils.java b/src/main/java/org/apache/commons/beanutils2/BeanUtils.java
index 8870d7e..84ec984 100644
--- a/src/main/java/org/apache/commons/beanutils2/BeanUtils.java
+++ b/src/main/java/org/apache/commons/beanutils2/BeanUtils.java
@@ -28,7 +28,7 @@
  *
  * <p>The implementations are provided by {@link BeanUtilsBean}.
  * These static utility methods use the default instance.
- * More sophisticated behavior can be provided by using a <code>BeanUtilsBean</code> instance.</p>
+ * More sophisticated behavior can be provided by using a {@code BeanUtilsBean} instance.</p>
  *
  * @see BeanUtilsBean
  */
@@ -36,19 +36,19 @@
 public class BeanUtils {
 
 
-    // ------------------------------------------------------ Private Variables
+    
 
 
 
 
-    // --------------------------------------------------------- Class Methods
+    
 
 
     /**
      * <p>Clone a bean based on the available property getters and setters,
      * even if the bean class itself does not implement Cloneable.</p>
      *
-     * <p>For more details see <code>BeanUtilsBean</code>.</p>
+     * <p>For more details see {@code BeanUtilsBean}.</p>
      *
      * @param bean Bean to be cloned
      * @return the cloned bean
@@ -76,15 +76,15 @@
      * <p>Copy property values from the origin bean to the destination bean
      * for all cases where the property names are the same.</p>
      *
-     * <p>For more details see <code>BeanUtilsBean</code>.</p>
+     * <p>For more details see {@code BeanUtilsBean}.</p>
      *
      * @param dest Destination bean whose properties are modified
      * @param orig Origin bean whose properties are retrieved
      *
      * @throws IllegalAccessException if the caller does not have
      *  access to the property accessor method
-     * @throws IllegalArgumentException if the <code>dest</code> or
-     *  <code>orig</code> argument is null or if the <code>dest</code>
+     * @throws IllegalArgumentException if the {@code dest} or
+     *  {@code orig</code> argument is null or if the <code>dest}
      *  property type is different from the source type and the relevant
      *  converter has not been registered.
      * @throws InvocationTargetException if the property accessor method
@@ -102,7 +102,7 @@
      * <p>Copy the specified property value to the specified destination bean,
      * performing any type conversion that is required.</p>
      *
-     * <p>For more details see <code>BeanUtilsBean</code>.</p>
+     * <p>For more details see {@code BeanUtilsBean}.</p>
      *
      * @param bean Bean on which setting is to be performed
      * @param name Property name (can be nested/indexed/mapped/combo)
@@ -125,7 +125,7 @@
      * <p>Return the entire set of properties for which the specified bean
      * provides a read method.</p>
      *
-     * <p>For more details see <code>BeanUtilsBean</code>.</p>
+     * <p>For more details see {@code BeanUtilsBean}.</p>
      *
      * @param bean Bean whose properties are to be extracted
      * @return Map of property descriptors
@@ -150,7 +150,7 @@
      * <p>Return the value of the specified array property of the specified
      * bean, as a String array.</p>
      *
-     * <p>For more details see <code>BeanUtilsBean</code>.</p>
+     * <p>For more details see {@code BeanUtilsBean}.</p>
      *
      * @param bean Bean whose property is to be extracted
      * @param name Name of the property to be extracted
@@ -176,10 +176,10 @@
      * <p>Return the value of the specified indexed property of the specified
      * bean, as a String.</p>
      *
-     * <p>For more details see <code>BeanUtilsBean</code>.</p>
+     * <p>For more details see {@code BeanUtilsBean}.</p>
      *
      * @param bean Bean whose property is to be extracted
-     * @param name <code>propertyname[index]</code> of the property value
+     * @param name {@code propertyname[index]} of the property value
      *  to be extracted
      * @return The indexed property's value, converted to a String
      *
@@ -205,7 +205,7 @@
      * bean, as a String.  The index is specified as a method parameter and
      * must *not* be included in the property name expression
      *
-     * <p>For more details see <code>BeanUtilsBean</code>.</p>
+     * <p>For more details see {@code BeanUtilsBean}.</p>
      *
      * @param bean Bean whose property is to be extracted
      * @param name Simple property name of the property value to be extracted
@@ -234,10 +234,10 @@
      * <p>Return the value of the specified indexed property of the specified
      * bean, as a String.</p>
      *
-     * <p>For more details see <code>BeanUtilsBean</code>.</p>
+     * <p>For more details see {@code BeanUtilsBean}.</p>
      *
      * @param bean Bean whose property is to be extracted
-     * @param name <code>propertyname(index)</code> of the property value
+     * @param name {@code propertyname(index)} of the property value
      *  to be extracted
      * @return The mapped property's value, converted to a String
      *
@@ -262,7 +262,7 @@
      * <p>Return the value of the specified mapped property of the specified
      * bean, as a String.</p>
      *
-     * <p>For more details see <code>BeanUtilsBean</code>.</p>
+     * <p>For more details see {@code BeanUtilsBean}.</p>
      *
      * @param bean Bean whose property is to be extracted
      * @param name Simple property name of the property value to be extracted
@@ -291,7 +291,7 @@
      * <p>Return the value of the (possibly nested) property of the specified
      * name, for the specified bean, as a String.</p>
      *
-     * <p>For more details see <code>BeanUtilsBean</code>.</p>
+     * <p>For more details see {@code BeanUtilsBean}.</p>
      *
      * @param bean Bean whose property is to be extracted
      * @param name Possibly nested name of the property to be extracted
@@ -320,7 +320,7 @@
      * <p>Return the value of the specified property of the specified bean,
      * no matter which property reference format is used, as a String.</p>
      *
-     * <p>For more details see <code>BeanUtilsBean</code>.</p>
+     * <p>For more details see {@code BeanUtilsBean}.</p>
      *
      * @param bean Bean whose property is to be extracted
      * @param name Possibly indexed and/or nested name of the property
@@ -348,7 +348,7 @@
      * <p>Return the value of the specified simple property of the specified
      * bean, converted to a String.</p>
      *
-     * <p>For more details see <code>BeanUtilsBean</code>.</p>
+     * <p>For more details see {@code BeanUtilsBean}.</p>
      *
      * @param bean Bean whose property is to be extracted
      * @param name Name of the property to be extracted
@@ -375,7 +375,7 @@
      * <p>Populate the JavaBeans properties of the specified bean, based on
      * the specified name/value pairs.</p>
      *
-     * <p>For more details see <code>BeanUtilsBean</code>.</p>
+     * <p>For more details see {@code BeanUtilsBean}.</p>
      *
      * @param bean JavaBean whose properties are being populated
      * @param properties Map keyed by property name, with the
@@ -398,7 +398,7 @@
      * <p>Set the specified property value, performing type conversions as
      * required to conform to the type of the destination property.</p>
      *
-     * <p>For more details see <code>BeanUtilsBean</code>.</p>
+     * <p>For more details see {@code BeanUtilsBean}.</p>
      *
      * @param bean Bean on which setting is to be performed
      * @param name Property name (can be nested/indexed/mapped/combo)
diff --git a/src/main/java/org/apache/commons/beanutils2/BeanUtilsBean.java b/src/main/java/org/apache/commons/beanutils2/BeanUtilsBean.java
index 57498ea..fc80ae9 100644
--- a/src/main/java/org/apache/commons/beanutils2/BeanUtilsBean.java
+++ b/src/main/java/org/apache/commons/beanutils2/BeanUtilsBean.java
@@ -50,10 +50,10 @@
 public class BeanUtilsBean {
 
 
-    // ------------------------------------------------------ Private Class Variables
+    
 
     /**
-     * Contains <code>BeanUtilsBean</code> instances indexed by context classloader.
+     * Contains {@code BeanUtilsBean} instances indexed by context classloader.
      */
     private static final ContextClassLoaderLocal<BeanUtilsBean>
             BEANS_BY_CLASSLOADER = new ContextClassLoaderLocal<BeanUtilsBean>() {
@@ -86,7 +86,7 @@
         BEANS_BY_CLASSLOADER.set(newInstance);
     }
 
-    // --------------------------------------------------------- Attributes
+    
 
     /**
      * Logging for this instance
@@ -102,7 +102,7 @@
     /** A reference to Throwable's initCause method, or null if it's not there in this JVM */
     private static final Method INIT_CAUSE_METHOD = getInitCauseMethod();
 
-    // --------------------------------------------------------- Constructors
+    
 
     /**
      * <p>Constructs an instance using new property
@@ -116,7 +116,7 @@
      * <p>Constructs an instance using given conversion instances
      * and new {@link PropertyUtilsBean} instance.</p>
      *
-     * @param convertUtilsBean use this <code>ConvertUtilsBean</code>
+     * @param convertUtilsBean use this {@code ConvertUtilsBean}
      * to perform conversions from one object to another
      *
      * @since 1.8.0
@@ -128,9 +128,9 @@
     /**
      * <p>Constructs an instance using given property and conversion instances.</p>
      *
-     * @param convertUtilsBean use this <code>ConvertUtilsBean</code>
+     * @param convertUtilsBean use this {@code ConvertUtilsBean}
      * to perform conversions from one object to another
-     * @param propertyUtilsBean use this <code>PropertyUtilsBean</code>
+     * @param propertyUtilsBean use this {@code PropertyUtilsBean}
      * to access properties
      */
     public BeanUtilsBean(
@@ -141,7 +141,7 @@
         this.propertyUtilsBean = propertyUtilsBean;
     }
 
-    // --------------------------------------------------------- Public Methods
+    
 
     /**
      * <p>Clone a bean based on the available property getters and setters,
@@ -193,21 +193,21 @@
      * in the destination bean (or are read-only in the destination bean) are
      * silently ignored.</p>
      *
-     * <p>If the origin "bean" is actually a <code>Map</code>, it is assumed
+     * <p>If the origin "bean" is actually a {@code Map}, it is assumed
      * to contain String-valued <strong>simple</strong> property names as the keys, pointing at
      * the corresponding property values that will be converted (if necessary)
      * and set in the destination bean. <strong>Note</strong> that this method
      * is intended to perform a "shallow copy" of the properties and so complex
      * properties (for example, nested ones) will not be copied.</p>
      *
-     * <p>This method differs from <code>populate()</code>, which
+     * <p>This method differs from {@code populate()}, which
      * was primarily designed for populating JavaBeans from the map of request
      * parameters retrieved on an HTTP request, is that no scalar-&gt;indexed
      * or indexed-&gt;scalar manipulations are performed.  If the origin property
      * is indexed, the destination property must be also.</p>
      *
      * <p>If you know that no type conversions are required, the
-     * <code>copyProperties()</code> method in {@link PropertyUtils} will
+     * {@code copyProperties()} method in {@link PropertyUtils} will
      * execute faster than this method.</p>
      *
      * <p><strong>FIXME</strong> - Indexed and mapped properties that do not
@@ -219,8 +219,8 @@
      *
      * @throws IllegalAccessException if the caller does not have
      *  access to the property accessor method
-     * @throws IllegalArgumentException if the <code>dest</code> or
-     *  <code>orig</code> argument is null or if the <code>dest</code>
+     * @throws IllegalArgumentException if the {@code dest} or
+     *  {@code orig</code> argument is null or if the <code>dest}
      *  property type is different from the source type and the relevant
      *  converter has not been registered.
      * @throws InvocationTargetException if the property accessor method
@@ -297,7 +297,7 @@
      * bean does not have a property of the specified name, or the property
      * is read only on the destination bean, return without
      * doing anything.  If you have custom destination property types, register
-     * {@link Converter}s for them by calling the <code>register()</code>
+     * {@link Converter}s for them by calling the {@code register()}
      * method of {@link ConvertUtils}.</p>
      *
      * <p><strong>IMPLEMENTATION RESTRICTIONS</strong>:</p>
@@ -445,12 +445,12 @@
 
     /**
      * <p>Return the entire set of properties for which the specified bean
-     * provides a read method. This map contains the to <code>String</code>
+     * provides a read method. This map contains the to {@code String}
      * converted property values for all properties for which a read method
      * is provided (i.e. where the getReadMethod() returns non-null).</p>
      *
      * <p>This map can be fed back to a call to
-     * <code>BeanUtils.populate()</code> to re-constitute the same set of
+     * {@code BeanUtils.populate()} to re-constitute the same set of
      * properties, modulo differences for read-only and write-only
      * properties, but only if there are no indexed properties.</p>
      *
@@ -467,9 +467,9 @@
      * }
      * </code></pre>
      * <p>
-     * will result in an infinite regression when <code>getParametersMap</code>
+     * will result in an infinite regression when {@code getParametersMap}
      * is called. It is recommended that such methods are given alternative
-     * names (for example, <code>parametersMap</code>).
+     * names (for example, {@code parametersMap}).
      * </p>
      * @param bean Bean whose properties are to be extracted
      * @return Map of property descriptors
@@ -577,11 +577,11 @@
      * Return the value of the specified indexed property of the specified
      * bean, as a String.  The zero-relative index of the
      * required value must be included (in square brackets) as a suffix to
-     * the property name, or <code>IllegalArgumentException</code> will be
+     * the property name, or {@code IllegalArgumentException} will be
      * thrown.
      *
      * @param bean Bean whose property is to be extracted
-     * @param name <code>propertyname[index]</code> of the property value
+     * @param name {@code propertyname[index]} of the property value
      *  to be extracted
      * @return The indexed property's value, converted to a String
      *
@@ -634,11 +634,11 @@
      * Return the value of the specified indexed property of the specified
      * bean, as a String.  The String-valued key of the required value
      * must be included (in parentheses) as a suffix to
-     * the property name, or <code>IllegalArgumentException</code> will be
+     * the property name, or {@code IllegalArgumentException} will be
      * thrown.
      *
      * @param bean Bean whose property is to be extracted
-     * @param name <code>propertyname(index)</code> of the property value
+     * @param name {@code propertyname(index)} of the property value
      *  to be extracted
      * @return The mapped property's value, converted to a String
      *
@@ -768,9 +768,9 @@
      * <p>Populate the JavaBeans properties of the specified bean, based on
      * the specified name/value pairs.  This method uses Java reflection APIs
      * to identify corresponding "property setter" method names, and deals
-     * with setter arguments of type <code>String</code>, <code>boolean</code>,
-     * <code>int</code>, <code>long</code>, <code>float</code>, and
-     * <code>double</code>.  In addition, array setters for these types (or the
+     * with setter arguments of type {@code String</code>, <code>boolean},
+     * {@code int</code>, <code>long</code>, <code>float}, and
+     * {@code double}.  In addition, array setters for these types (or the
      * corresponding primitive types) can also be identified.</p>
      *
      * <p>The particular setter method to be called for each property is
@@ -788,7 +788,7 @@
      * for extracting String-based request parameters from an HTTP request.
      * It is probably not what you want for general property copying with
      * type conversion.  For that purpose, check out the
-     * <code>copyProperties()</code> method instead.</p>
+     * {@code copyProperties()} method instead.</p>
      *
      * @param bean JavaBean whose properties are being populated
      * @param properties Map keyed by property name, with the
@@ -834,13 +834,13 @@
      * <p>If the property is read only then the method returns
      * without throwing an exception.</p>
      *
-     * <p>If <code>null</code> is passed into a property expecting a primitive value,
-     * then this will be converted as if it were a <code>null</code> string.</p>
+     * <p>If {@code null} is passed into a property expecting a primitive value,
+     * then this will be converted as if it were a {@code null} string.</p>
      *
      * <p><strong>WARNING</strong> - The logic of this method is customized
-     * to meet the needs of <code>populate()</code>, and is probably not what
+     * to meet the needs of {@code populate()}, and is probably not what
      * you want for general property copying with type conversion.  For that
-     * purpose, check out the <code>copyProperty()</code> method instead.</p>
+     * purpose, check out the {@code copyProperty()} method instead.</p>
      *
      * <p><strong>WARNING</strong> - PLEASE do not modify the behavior of this
      * method without consulting with the Struts developer community.  There
@@ -1024,7 +1024,7 @@
     }
 
     /**
-     * Gets the <code>ConvertUtilsBean</code> instance used to perform the conversions.
+     * Gets the {@code ConvertUtilsBean} instance used to perform the conversions.
      *
      * @return The ConvertUtils bean instance
      */
@@ -1033,7 +1033,7 @@
     }
 
     /**
-     * Gets the <code>PropertyUtilsBean</code> instance used to access properties.
+     * Gets the {@code PropertyUtilsBean} instance used to access properties.
      *
      * @return The ConvertUtils bean instance
      */
@@ -1097,11 +1097,11 @@
     /**
      * Returns a <code>Method<code> allowing access to
      * {@link Throwable#initCause(Throwable)} method of {@link Throwable},
-     * or <code>null</code> if the method
+     * or {@code null} if the method
      * does not exist.
      *
-     * @return A <code>Method<code> for <code>Throwable.initCause</code>, or
-     * <code>null</code> if unavailable.
+     * @return A {@code Method<code> for <code>Throwable.initCause}, or
+     * {@code null} if unavailable.
      */
     private static Method getInitCauseMethod() {
         try {
diff --git a/src/main/java/org/apache/commons/beanutils2/BeanUtilsBean2.java b/src/main/java/org/apache/commons/beanutils2/BeanUtilsBean2.java
index 09e1c31..0a549c8 100644
--- a/src/main/java/org/apache/commons/beanutils2/BeanUtilsBean2.java
+++ b/src/main/java/org/apache/commons/beanutils2/BeanUtilsBean2.java
@@ -24,12 +24,12 @@
  *
  * <p>
  * To configure this implementation for the current context ClassLoader invoke
- * <code>BeanUtilsBean.setInstance(new BeanUtilsBean2());</code>
+ * {@code BeanUtilsBean.setInstance(new BeanUtilsBean2());}
  * </p>
  *
  * <p>
  * BeanUtils 1.7.0 delegated all conversion to String to the converter
- * registered for the <code>String.class</code>. One of the improvements in
+ * registered for the {@code String.class}. One of the improvements in
  * BeanUtils 1.8.0 was to upgrade the {@link Converter} implementations so
  * that they could handle conversion to String for their type (e.g.
  * IntegerConverter now handles conversion from an Integer to a String as
diff --git a/src/main/java/org/apache/commons/beanutils2/ConstructorUtils.java b/src/main/java/org/apache/commons/beanutils2/ConstructorUtils.java
index 37c00a6..0c58261 100644
--- a/src/main/java/org/apache/commons/beanutils2/ConstructorUtils.java
+++ b/src/main/java/org/apache/commons/beanutils2/ConstructorUtils.java
@@ -28,10 +28,10 @@
  * <h4>Accessing Public Constructors In A Default Access Superclass</h4>
  * <p>There is an issue when invoking public constructors contained in a default access superclass.
  * Reflection locates these constructors fine and correctly assigns them as public.
- * However, an <code>IllegalAccessException</code> is thrown if the constructors is invoked.</p>
+ * However, an {@code IllegalAccessException} is thrown if the constructors is invoked.</p>
  *
- * <p><code>ConstructorUtils</code> contains a workaround for this situation.
- * It will attempt to call <code>setAccessible</code> on this constructor.
+ * <p>{@code ConstructorUtils} contains a workaround for this situation.
+ * It will attempt to call {@code setAccessible} on this constructor.
  * If this call succeeds, then the method can be invoked as normal.
  * This call will only succeed when the application has sufficient security privileges.
  * If this call fails then a warning will be logged and the method may fail.</p>
@@ -39,17 +39,17 @@
  */
 public class ConstructorUtils {
 
-    // --------------------------------------------------------- Private Members
+    
     /** An empty class array */
     private static final Class<?>[] EMPTY_CLASS_PARAMETERS = new Class<?>[0];
     /** An empty object array */
     private static final Object[] EMPTY_OBJECT_ARRAY = new Object[0];
 
-    // --------------------------------------------------------- Public Methods
+    
 
     /**
-     * <p>Convenience method returning new instance of <code>klazz</code> using a single argument constructor.
-     * The formal parameter type is inferred from the actual values of <code>arg</code>.
+     * <p>Convenience method returning new instance of {@code klazz} using a single argument constructor.
+     * The formal parameter type is inferred from the actual values of {@code arg}.
      * See {@link #invokeExactConstructor(Class, Object[], Class[])} for more details.</p>
      *
      * <p>The signatures should be assignment compatible.</p>
@@ -57,7 +57,7 @@
      * @param <T> the type of the object to be constructed
      * @param klass the class to be constructed.
      * @param arg the actual argument. May be null (this will result in calling the default constructor).
-     * @return new instance of <code>klazz</code>
+     * @return new instance of {@code klazz}
      *
      * @throws NoSuchMethodException If the constructor cannot be found
      * @throws IllegalAccessException If an error occurs accessing the constructor
@@ -78,8 +78,8 @@
     }
 
     /**
-     * <p>Returns new instance of <code>klazz</code> created using the actual arguments <code>args</code>.
-     * The formal parameter types are inferred from the actual values of <code>args</code>.
+     * <p>Returns new instance of {@code klazz</code> created using the actual arguments <code>args}.
+     * The formal parameter types are inferred from the actual values of {@code args}.
      * See {@link #invokeExactConstructor(Class, Object[], Class[])} for more details.</p>
      *
      * <p>The signatures should be assignment compatible.</p>
@@ -87,7 +87,7 @@
      * @param <T> the type of the object to be constructed
      * @param klass the class to be constructed.
      * @param args actual argument array. May be null (this will result in calling the default constructor).
-     * @return new instance of <code>klazz</code>
+     * @return new instance of {@code klazz}
      *
      * @throws NoSuchMethodException If the constructor cannot be found
      * @throws IllegalAccessException If an error occurs accessing the constructor
@@ -115,8 +115,8 @@
     }
 
     /**
-     * <p>Returns new instance of <code>klazz</code> created using constructor
-     * with signature <code>parameterTypes</code> and actual arguments <code>args</code>.</p>
+     * <p>Returns new instance of {@code klazz} created using constructor
+     * with signature {@code parameterTypes</code> and actual arguments <code>args}.</p>
      *
      * <p>The signatures should be assignment compatible.</p>
      *
@@ -124,7 +124,7 @@
      * @param klass the class to be constructed.
      * @param args actual argument array. May be null (this will result in calling the default constructor).
      * @param parameterTypes parameter types array
-     * @return new instance of <code>klazz</code>
+     * @return new instance of {@code klazz}
      *
      * @throws NoSuchMethodException if matching constructor cannot be found
      * @throws IllegalAccessException thrown on the constructor's invocation
@@ -160,8 +160,8 @@
 
 
     /**
-     * <p>Convenience method returning new instance of <code>klazz</code> using a single argument constructor.
-     * The formal parameter type is inferred from the actual values of <code>arg</code>.
+     * <p>Convenience method returning new instance of {@code klazz} using a single argument constructor.
+     * The formal parameter type is inferred from the actual values of {@code arg}.
      * See {@link #invokeExactConstructor(Class, Object[], Class[])} for more details.</p>
      *
      * <p>The signatures should match exactly.</p>
@@ -169,7 +169,7 @@
      * @param <T> the type of the object to be constructed
      * @param klass the class to be constructed.
      * @param arg the actual argument. May be null (this will result in calling the default constructor).
-     * @return new instance of <code>klazz</code>
+     * @return new instance of {@code klazz}
      *
      * @throws NoSuchMethodException If the constructor cannot be found
      * @throws IllegalAccessException If an error occurs accessing the constructor
@@ -190,8 +190,8 @@
     }
 
     /**
-     * <p>Returns new instance of <code>klazz</code> created using the actual arguments <code>args</code>.
-     * The formal parameter types are inferred from the actual values of <code>args</code>.
+     * <p>Returns new instance of {@code klazz</code> created using the actual arguments <code>args}.
+     * The formal parameter types are inferred from the actual values of {@code args}.
      * See {@link #invokeExactConstructor(Class, Object[], Class[])} for more details.</p>
      *
      * <p>The signatures should match exactly.</p>
@@ -199,7 +199,7 @@
      * @param <T> the type of the object to be constructed
      * @param klass the class to be constructed.
      * @param args actual argument array. May be null (this will result in calling the default constructor).
-     * @return new instance of <code>klazz</code>
+     * @return new instance of {@code klazz}
      *
      * @throws NoSuchMethodException If the constructor cannot be found
      * @throws IllegalAccessException If an error occurs accessing the constructor
@@ -227,9 +227,9 @@
     }
 
     /**
-     * <p>Returns new instance of <code>klazz</code> created using constructor
-     * with signature <code>parameterTypes</code> and actual arguments
-     * <code>args</code>.</p>
+     * <p>Returns new instance of {@code klazz} created using constructor
+     * with signature {@code parameterTypes} and actual arguments
+     * {@code args}.</p>
      *
      * <p>The signatures should match exactly.</p>
      *
@@ -237,7 +237,7 @@
      * @param klass the class to be constructed.
      * @param args actual argument array. May be null (this will result in calling the default constructor).
      * @param parameterTypes parameter types array
-     * @return new instance of <code>klazz</code>
+     * @return new instance of {@code klazz}
      *
      * @throws NoSuchMethodException if matching constructor cannot be found
      * @throws IllegalAccessException thrown on the constructor's invocation
@@ -313,7 +313,7 @@
      * Returns accessible version of the given constructor.
      * @param <T> the type of the constructor
      * @param ctor prototype constructor object.
-     * @return <code>null</code> if accessible constructor can not be found.
+     * @return {@code null} if accessible constructor can not be found.
      * @see java.lang.SecurityManager
      */
     public static <T> Constructor<T> getAccessibleConstructor(final Constructor<T> ctor) {
@@ -346,7 +346,7 @@
         return args;
     }
 
-    // -------------------------------------------------------- Private Methods
+    
     /**
      * <p>Find an accessible constructor with compatible parameters.
      * Compatible parameters mean that every method parameter is assignable from
@@ -361,7 +361,7 @@
      * @param <T> the type of the class to be inspected
      * @param clazz find constructor for this class
      * @param parameterTypes find method with compatible parameters
-     * @return a valid Constructor object. If there's no matching constructor, returns <code>null</code>.
+     * @return a valid Constructor object. If there's no matching constructor, returns {@code null}.
      */
     private static <T> Constructor<T> getMatchingAccessibleConstructor(
         final Class<T> clazz,
diff --git a/src/main/java/org/apache/commons/beanutils2/ConversionException.java b/src/main/java/org/apache/commons/beanutils2/ConversionException.java
index ab29291..4cf19f2 100644
--- a/src/main/java/org/apache/commons/beanutils2/ConversionException.java
+++ b/src/main/java/org/apache/commons/beanutils2/ConversionException.java
@@ -21,7 +21,7 @@
 
 /**
  * <p>A <strong>ConversionException</strong> indicates that a call to
- * <code>Converter.convert()</code> has failed to complete successfully.
+ * {@code Converter.convert()} has failed to complete successfully.
  *
  * @since 1.3
  */
@@ -30,7 +30,7 @@
 
     private static final long serialVersionUID = 1L;
 
-    // ----------------------------------------------------------- Constructors
+    
 
     /**
      * Construct a new exception with the specified message.
@@ -71,12 +71,12 @@
     }
 
 
-    // ------------------------------------------------------------- Properties
+    
 
 
     /**
-     * The root cause of this <code>ConversionException</code>, compatible with
-     * JDK 1.4's extensions to <code>java.lang.Throwable</code>.
+     * The root cause of this {@code ConversionException}, compatible with
+     * JDK 1.4's extensions to {@code java.lang.Throwable}.
      */
     protected Throwable cause = null;
 
diff --git a/src/main/java/org/apache/commons/beanutils2/ConvertUtils.java b/src/main/java/org/apache/commons/beanutils2/ConvertUtils.java
index ec3587e..e0e5ba7 100644
--- a/src/main/java/org/apache/commons/beanutils2/ConvertUtils.java
+++ b/src/main/java/org/apache/commons/beanutils2/ConvertUtils.java
@@ -22,7 +22,7 @@
  * <p>Utility methods for converting String scalar values to objects of the
  * specified Class, String arrays to arrays of the specified Class.</p>
  *
- * <p>For more details, see <code>ConvertUtilsBean</code> which provides the
+ * <p>For more details, see {@code ConvertUtilsBean} which provides the
  * implementations for these methods.</p>
  *
  * @see ConvertUtilsBean
@@ -31,17 +31,17 @@
 public class ConvertUtils {
 
 
-    // ------------------------------------------------------ Static Properties
+    
 
 
 
-    // --------------------------------------------------------- Public Classes
+    
 
 
     /**
      * <p>Convert the specified value into a String.</p>
      *
-     * <p>For more details see <code>ConvertUtilsBean</code>.</p>
+     * <p>For more details see {@code ConvertUtilsBean}.</p>
      *
      * @param value Value to be converted (may be null)
      * @return The converted String value or null if value is null
@@ -57,7 +57,7 @@
      * <p>Convert the specified value to an object of the specified class (if
      * possible).  Otherwise, return a String representation of the value.</p>
      *
-     * <p>For more details see <code>ConvertUtilsBean</code>.</p>
+     * <p>For more details see {@code ConvertUtilsBean}.</p>
      *
      * @param value Value to be converted (may be null)
      * @param clazz Java class to be converted to (must not be null)
@@ -74,7 +74,7 @@
      * <p>Convert an array of specified values to an array of objects of the
      * specified class (if possible).</p>
      *
-     * <p>For more details see <code>ConvertUtilsBean</code>.</p>
+     * <p>For more details see {@code ConvertUtilsBean}.</p>
      *
      * @param values Array of values to be converted
      * @param clazz Java array or element class to be converted to (must not be null)
@@ -104,7 +104,7 @@
      * <p>Remove all registered {@link Converter}s, and re-establish the
      * standard Converters.</p>
      *
-     * <p>For more details see <code>ConvertUtilsBean</code>.</p>
+     * <p>For more details see {@code ConvertUtilsBean}.</p>
      *
      * @see ConvertUtilsBean#deregister()
      */
@@ -115,9 +115,9 @@
 
     /**
      * <p>Remove any registered {@link Converter} for the specified destination
-     * <code>Class</code>.</p>
+     * {@code Class}.</p>
      *
-     * <p>For more details see <code>ConvertUtilsBean</code>.</p>
+     * <p>For more details see {@code ConvertUtilsBean}.</p>
      *
      * @param clazz Class for which to remove a registered Converter
      * @see ConvertUtilsBean#deregister(Class)
@@ -130,12 +130,12 @@
     /**
      * <p>Look up and return any registered {@link Converter} for the specified
      * destination class; if there is no registered Converter, return
-     * <code>null</code>.</p>
+     * {@code null}.</p>
      *
-     * <p>For more details see <code>ConvertUtilsBean</code>.</p>
+     * <p>For more details see {@code ConvertUtilsBean}.</p>
      *
      * @param clazz Class for which to return a registered Converter
-     * @return The registered {@link Converter} or <code>null</code> if not found
+     * @return The registered {@link Converter} or {@code null} if not found
      * @see ConvertUtilsBean#lookup(Class)
      */
     public static Converter lookup(final Class<?> clazz) {
@@ -145,11 +145,11 @@
     /**
      * Look up and return any registered {@link Converter} for the specified
      * source and destination class; if there is no registered Converter,
-     * return <code>null</code>.
+     * return {@code null}.
      *
      * @param sourceType Class of the value being converted
      * @param targetType Class of the value to be converted to
-     * @return The registered {@link Converter} or <code>null</code> if not found
+     * @return The registered {@link Converter} or {@code null} if not found
      */
     public static Converter lookup(final Class<?> sourceType, final Class<?> targetType) {
         return ConvertUtilsBean.getInstance().lookup(sourceType, targetType);
@@ -157,9 +157,9 @@
 
     /**
      * <p>Register a custom {@link Converter} for the specified destination
-     * <code>Class</code>, replacing any previously registered Converter.</p>
+     * {@code Class}, replacing any previously registered Converter.</p>
      *
-     * <p>For more details see <code>ConvertUtilsBean</code>.</p>
+     * <p>For more details see {@code ConvertUtilsBean}.</p>
      *
      * @param converter Converter to be registered
      * @param clazz Destination class for conversions performed by this
diff --git a/src/main/java/org/apache/commons/beanutils2/ConvertUtilsBean.java b/src/main/java/org/apache/commons/beanutils2/ConvertUtilsBean.java
index 43ec1bf..8372864 100644
--- a/src/main/java/org/apache/commons/beanutils2/ConvertUtilsBean.java
+++ b/src/main/java/org/apache/commons/beanutils2/ConvertUtilsBean.java
@@ -178,7 +178,7 @@
     private static final Integer ZERO = Integer.valueOf(0);
     private static final Character SPACE = Character.valueOf(' ');
 
-    // ------------------------------------------------------- Class Methods
+    
     /**
      * Get singleton instance
      * @return The singleton instance
@@ -187,7 +187,7 @@
         return BeanUtilsBean.getInstance().getConvertUtils();
     }
 
-    // ------------------------------------------------------- Variables
+    
 
 
     /**
@@ -198,11 +198,11 @@
             new WeakFastHashMap<>();
 
     /**
-     * The <code>Log</code> instance for this class.
+     * The {@code Log} instance for this class.
      */
     private final Log log = LogFactory.getLog(ConvertUtilsBean.class);
 
-    // ------------------------------------------------------- Constructors
+    
 
     /** Construct a bean with standard converters registered */
     public ConvertUtilsBean() {
@@ -211,13 +211,13 @@
         converters.setFast(true);
     }
 
-    // --------------------------------------------------------- Public Methods
+    
 
     /**
      * Convert the specified value into a String.  If the specified value
      * is an array, the first element (converted to a String) will be
      * returned.  The registered {@link Converter} for the
-     * <code>java.lang.String</code> class will be used, which allows
+     * {@code java.lang.String} class will be used, which allows
      * applications to customize Object-&gt;String conversions (the default
      * implementation simply uses toString()).
      *
@@ -389,16 +389,16 @@
     /**
      * Register the provided converters with the specified defaults.
      *
-     * @param throwException <code>true</code> if the converters should
+     * @param throwException {@code true} if the converters should
      * throw an exception when a conversion error occurs, otherwise
-     * <code>false</code> if a default value should be used.
-     * @param defaultNull <code>true</code>if the <i>standard</i> converters
+     * {@code false} if a default value should be used.
+     * @param defaultNull {@code true}if the <i>standard</i> converters
      * (see {@link ConvertUtilsBean#registerStandard(boolean, boolean)})
-     * should use a default value of <code>null</code>, otherwise <code>false</code>.
-     * N.B. This values is ignored if <code>throwException</code> is <code>true</code>
+     * should use a default value of {@code null</code>, otherwise <code>false}.
+     * N.B. This values is ignored if {@code throwException</code> is <code>true}
      * @param defaultArraySize The size of the default array value for array converters
-     * (N.B. This values is ignored if <code>throwException</code> is <code>true</code>).
-     * Specifying a value less than zero causes a <code>null</code> value to be used for
+     * (N.B. This values is ignored if {@code throwException</code> is <code>true}).
+     * Specifying a value less than zero causes a {@code null} value to be used for
      * the default.
      */
     public void register(final boolean throwException, final boolean defaultNull, final int defaultArraySize) {
@@ -413,18 +413,18 @@
      * </p>
      * This method registers the following converters:
      * <ul>
-     *     <li><code>Boolean.TYPE</code> - {@link BooleanConverter}</li>
-     *     <li><code>Byte.TYPE</code> - {@link ByteConverter}</li>
-     *     <li><code>Character.TYPE</code> - {@link CharacterConverter}</li>
-     *     <li><code>Double.TYPE</code> - {@link DoubleConverter}</li>
-     *     <li><code>Float.TYPE</code> - {@link FloatConverter}</li>
-     *     <li><code>Integer.TYPE</code> - {@link IntegerConverter}</li>
-     *     <li><code>Long.TYPE</code> - {@link LongConverter}</li>
-     *     <li><code>Short.TYPE</code> - {@link ShortConverter}</li>
+     *     <li>{@code Boolean.TYPE} - {@link BooleanConverter}</li>
+     *     <li>{@code Byte.TYPE} - {@link ByteConverter}</li>
+     *     <li>{@code Character.TYPE} - {@link CharacterConverter}</li>
+     *     <li>{@code Double.TYPE} - {@link DoubleConverter}</li>
+     *     <li>{@code Float.TYPE} - {@link FloatConverter}</li>
+     *     <li>{@code Integer.TYPE} - {@link IntegerConverter}</li>
+     *     <li>{@code Long.TYPE} - {@link LongConverter}</li>
+     *     <li>{@code Short.TYPE} - {@link ShortConverter}</li>
      * </ul>
-     * @param throwException <code>true</code> if the converters should
+     * @param throwException {@code true} if the converters should
      * throw an exception when a conversion error occurs, otherwise <code>
-     * <code>false</code> if a default value should be used.
+     * {@code false} if a default value should be used.
      */
     private void registerPrimitives(final boolean throwException) {
         register(Boolean.TYPE,   throwException ? new BooleanConverter()    : new BooleanConverter(Boolean.FALSE));
@@ -442,25 +442,25 @@
      * </p>
      * This method registers the following converters:
      * <ul>
-     *     <li><code>BigDecimal.class</code> - {@link BigDecimalConverter}</li>
-     *     <li><code>BigInteger.class</code> - {@link BigIntegerConverter}</li>
-     *     <li><code>Boolean.class</code> - {@link BooleanConverter}</li>
-     *     <li><code>Byte.class</code> - {@link ByteConverter}</li>
-     *     <li><code>Character.class</code> - {@link CharacterConverter}</li>
-     *     <li><code>Double.class</code> - {@link DoubleConverter}</li>
-     *     <li><code>Float.class</code> - {@link FloatConverter}</li>
-     *     <li><code>Integer.class</code> - {@link IntegerConverter}</li>
-     *     <li><code>Long.class</code> - {@link LongConverter}</li>
-     *     <li><code>Short.class</code> - {@link ShortConverter}</li>
-     *     <li><code>String.class</code> - {@link StringConverter}</li>
+     *     <li>{@code BigDecimal.class} - {@link BigDecimalConverter}</li>
+     *     <li>{@code BigInteger.class} - {@link BigIntegerConverter}</li>
+     *     <li>{@code Boolean.class} - {@link BooleanConverter}</li>
+     *     <li>{@code Byte.class} - {@link ByteConverter}</li>
+     *     <li>{@code Character.class} - {@link CharacterConverter}</li>
+     *     <li>{@code Double.class} - {@link DoubleConverter}</li>
+     *     <li>{@code Float.class} - {@link FloatConverter}</li>
+     *     <li>{@code Integer.class} - {@link IntegerConverter}</li>
+     *     <li>{@code Long.class} - {@link LongConverter}</li>
+     *     <li>{@code Short.class} - {@link ShortConverter}</li>
+     *     <li>{@code String.class} - {@link StringConverter}</li>
      * </ul>
-     * @param throwException <code>true</code> if the converters should
+     * @param throwException {@code true} if the converters should
      * throw an exception when a conversion error occurs, otherwise <code>
-     * <code>false</code> if a default value should be used.
-     * @param defaultNull <code>true</code>if the <i>standard</i> converters
+     * {@code false} if a default value should be used.
+     * @param defaultNull {@code true}if the <i>standard</i> converters
      * (see {@link ConvertUtilsBean#registerStandard(boolean, boolean)})
-     * should use a default value of <code>null</code>, otherwise <code>false</code>.
-     * N.B. This values is ignored if <code>throwException</code> is <code>true</code>
+     * should use a default value of {@code null</code>, otherwise <code>false}.
+     * N.B. This values is ignored if {@code throwException</code> is <code>true}
      */
     private void registerStandard(final boolean throwException, final boolean defaultNull) {
 
@@ -490,35 +490,35 @@
      * </p>
      * This method registers the following converters:
      * <ul>
-     *     <li><code>Class.class</code> - {@link ClassConverter}</li>
-     *     <li><code>Enum.class</code> - {@link EnumConverter}</li>
-     *     <li><code>java.util.Date.class</code> - {@link DateConverter}</li>
-     *     <li><code>java.util.Calendar.class</code> - {@link CalendarConverter}</li>
-     *     <li><code>File.class</code> - {@link FileConverter}</li>
-     *     <li><code>Path.class</code> - {@link PathConverter}</li>
-     *     <li><code>java.sql.Date.class</code> - {@link SqlDateConverter}</li>
-     *     <li><code>java.sql.Time.class</code> - {@link SqlTimeConverter}</li>
-     *     <li><code>java.sql.Timestamp.class</code> - {@link SqlTimestampConverter}</li>
-     *     <li><code>URL.class</code> - {@link URLConverter}</li>
-     *     <li><code>URI.class</code> - {@link URIConverter}</li>
-     *     <li><code>UUID.class</code> - {@link UUIDConverter}</li>
-     *     <li><code>LocalDate.class</code> - {@link LocalDateConverter}</li>
-     *     <li><code>LocalDateTime.class</code> - {@link LocalDateTimeConverter}</li>
-     *     <li><code>LocalTime.class</code> - {@link LocalTimeConverter}</li>
-     *     <li><code>OffsetDateTime.class</code> - {@link OffsetDateTimeConverter}</li>
-     *     <li><code>OffsetTime.class</code> - {@link OffsetTimeConverter}</li>
-     *     <li><code>ZonedDateTime.class</code> - {@link ZonedDateTimeConverter}</li>
-     *     <li><code>Duration.class</code> - {@link DurationConverter}</li>
-     *     <li><code>MonthDay.class</code> - {@link MonthDayConverter}</li>
-     *     <li><code>Period.class</code> - {@link PeriodConverter}</li>
-     *     <li><code>Year.class</code> - {@link YearConverter}</li>
-     *     <li><code>YearMonth.class</code> - {@link YearMonthConverter}</li>
-     *     <li><code>ZoneId.class</code> - {@link ZoneIdConverter}</li>
-     *     <li><code>ZoneOffset.class</code> - {@link ZoneOffsetConverter}</li>
+     *     <li>{@code Class.class} - {@link ClassConverter}</li>
+     *     <li>{@code Enum.class} - {@link EnumConverter}</li>
+     *     <li>{@code java.util.Date.class} - {@link DateConverter}</li>
+     *     <li>{@code java.util.Calendar.class} - {@link CalendarConverter}</li>
+     *     <li>{@code File.class} - {@link FileConverter}</li>
+     *     <li>{@code Path.class} - {@link PathConverter}</li>
+     *     <li>{@code java.sql.Date.class} - {@link SqlDateConverter}</li>
+     *     <li>{@code java.sql.Time.class} - {@link SqlTimeConverter}</li>
+     *     <li>{@code java.sql.Timestamp.class} - {@link SqlTimestampConverter}</li>
+     *     <li>{@code URL.class} - {@link URLConverter}</li>
+     *     <li>{@code URI.class} - {@link URIConverter}</li>
+     *     <li>{@code UUID.class} - {@link UUIDConverter}</li>
+     *     <li>{@code LocalDate.class} - {@link LocalDateConverter}</li>
+     *     <li>{@code LocalDateTime.class} - {@link LocalDateTimeConverter}</li>
+     *     <li>{@code LocalTime.class} - {@link LocalTimeConverter}</li>
+     *     <li>{@code OffsetDateTime.class} - {@link OffsetDateTimeConverter}</li>
+     *     <li>{@code OffsetTime.class} - {@link OffsetTimeConverter}</li>
+     *     <li>{@code ZonedDateTime.class} - {@link ZonedDateTimeConverter}</li>
+     *     <li>{@code Duration.class} - {@link DurationConverter}</li>
+     *     <li>{@code MonthDay.class} - {@link MonthDayConverter}</li>
+     *     <li>{@code Period.class} - {@link PeriodConverter}</li>
+     *     <li>{@code Year.class} - {@link YearConverter}</li>
+     *     <li>{@code YearMonth.class} - {@link YearMonthConverter}</li>
+     *     <li>{@code ZoneId.class} - {@link ZoneIdConverter}</li>
+     *     <li>{@code ZoneOffset.class} - {@link ZoneOffsetConverter}</li>
      * </ul>
-     * @param throwException <code>true</code> if the converters should
+     * @param throwException {@code true} if the converters should
      * throw an exception when a conversion error occurs, otherwise <code>
-     * <code>false</code> if a default value should be used.
+     * {@code false} if a default value should be used.
      */
     private void registerOther(final boolean throwException) {
     	  // @formatter:off
@@ -553,11 +553,11 @@
     /**
      * Register array converters.
      *
-     * @param throwException <code>true</code> if the converters should
+     * @param throwException {@code true} if the converters should
      * throw an exception when a conversion error occurs, otherwise <code>
-     * <code>false</code> if a default value should be used.
+     * {@code false} if a default value should be used.
      * @param defaultArraySize The size of the default array value for array converters
-     * (N.B. This values is ignored if <code>throwException</code> is <code>true</code>).
+     * (N.B. This values is ignored if {@code throwException</code> is <code>true}).
      * Specifying a value less than zero causes a <code>null<code> value to be used for
      * the default.
      */
@@ -645,7 +645,7 @@
 
     /**
      * Remove any registered {@link Converter} for the specified destination
-     * <code>Class</code>.
+     * {@code Class}.
      *
      * @param clazz Class for which to remove a registered Converter
      */
@@ -659,10 +659,10 @@
     /**
      * Look up and return any registered {@link Converter} for the specified
      * destination class; if there is no registered Converter, return
-     * <code>null</code>.
+     * {@code null}.
      *
      * @param clazz Class for which to return a registered Converter
-     * @return The registered {@link Converter} or <code>null</code> if not found
+     * @return The registered {@link Converter} or {@code null} if not found
      */
     public Converter lookup(final Class<?> clazz) {
 
@@ -673,11 +673,11 @@
     /**
      * Look up and return any registered {@link Converter} for the specified
      * source and destination class; if there is no registered Converter,
-     * return <code>null</code>.
+     * return {@code null}.
      *
      * @param sourceType Class of the value being converted
      * @param targetType Class of the value to be converted to
-     * @return The registered {@link Converter} or <code>null</code> if not found
+     * @return The registered {@link Converter} or {@code null} if not found
      */
     public Converter lookup(final Class<?> sourceType, final Class<?> targetType) {
 
@@ -719,7 +719,7 @@
 
     /**
      * Register a custom {@link Converter} for the specified destination
-     * <code>Class</code>, replacing any previously registered Converter.
+     * {@code Class}, replacing any previously registered Converter.
      *
      * @param converter Converter to be registered
      * @param clazz Destination class for conversions performed by this
diff --git a/src/main/java/org/apache/commons/beanutils2/ConvertUtilsBean2.java b/src/main/java/org/apache/commons/beanutils2/ConvertUtilsBean2.java
index 1729f7b..f06958e 100644
--- a/src/main/java/org/apache/commons/beanutils2/ConvertUtilsBean2.java
+++ b/src/main/java/org/apache/commons/beanutils2/ConvertUtilsBean2.java
@@ -17,12 +17,12 @@
 package org.apache.commons.beanutils2;
 
 /**
- * {@link ConvertUtilsBean} implementation that delegates <code>convert()</code>
+ * {@link ConvertUtilsBean} implementation that delegates {@code convert()}
  * methods to the new {@link ConvertUtilsBean#convert(Object, Class)} method.
  *
  * <p>
  * To configure this implementation for the current context ClassLoader invoke
- * <code>BeanUtilsBean.setInstance(new BeanUtilsBean2());</code>
+ * {@code BeanUtilsBean.setInstance(new BeanUtilsBean2());}
  * </p>
  *
  * @see BeanUtilsBean2
diff --git a/src/main/java/org/apache/commons/beanutils2/ConvertingWrapDynaBean.java b/src/main/java/org/apache/commons/beanutils2/ConvertingWrapDynaBean.java
index bb7568e..a2c3026 100644
--- a/src/main/java/org/apache/commons/beanutils2/ConvertingWrapDynaBean.java
+++ b/src/main/java/org/apache/commons/beanutils2/ConvertingWrapDynaBean.java
@@ -20,14 +20,14 @@
 import java.lang.reflect.InvocationTargetException;
 
 /**
- * <p>Implementation of <code>DynaBean</code> that wraps a standard JavaBean
+ * <p>Implementation of {@code DynaBean} that wraps a standard JavaBean
  * instance, so that DynaBean APIs can be used to access its properties,
  * though this implementation allows type conversion to occur when properties are set.
  * This means that (say) Strings can be passed in as values in setter methods and
  * this DynaBean will convert them to the correct primitive data types.</p>
  *
  * <p><strong>IMPLEMENTATION NOTE</strong> - This implementation does not
- * support the <code>contains()</code> and <code>remove()</code> methods.</p>
+ * support the {@code contains()</code> and <code>remove()} methods.</p>
  *
  */
 
@@ -36,7 +36,7 @@
     private static final long serialVersionUID = 1L;
 
     /**
-     * Construct a new <code>DynaBean</code> associated with the specified
+     * Construct a new {@code DynaBean} associated with the specified
      * JavaBean instance.
      *
      * @param instance JavaBean instance to be wrapped
diff --git a/src/main/java/org/apache/commons/beanutils2/DefaultBeanIntrospector.java b/src/main/java/org/apache/commons/beanutils2/DefaultBeanIntrospector.java
index 377d83c..8483f9f 100644
--- a/src/main/java/org/apache/commons/beanutils2/DefaultBeanIntrospector.java
+++ b/src/main/java/org/apache/commons/beanutils2/DefaultBeanIntrospector.java
@@ -33,7 +33,7 @@
  * </p>
  * <p>
  * This class implements a default bean introspection algorithm based on the JDK
- * classes in the <code>java.beans</code> package. It discovers properties
+ * classes in the {@code java.beans} package. It discovers properties
  * conforming to the Java Beans specification.
  * </p>
  * <p>
diff --git a/src/main/java/org/apache/commons/beanutils2/DefaultIntrospectionContext.java b/src/main/java/org/apache/commons/beanutils2/DefaultIntrospectionContext.java
index ba446d7..9b56567 100644
--- a/src/main/java/org/apache/commons/beanutils2/DefaultIntrospectionContext.java
+++ b/src/main/java/org/apache/commons/beanutils2/DefaultIntrospectionContext.java
@@ -46,7 +46,7 @@
 
     /**
      *
-     * Creates a new instance of <code>DefaultIntrospectionContext</code> and sets
+     * Creates a new instance of {@code DefaultIntrospectionContext} and sets
      * the current class for introspection.
      *
      * @param cls the current class
diff --git a/src/main/java/org/apache/commons/beanutils2/DynaBean.java b/src/main/java/org/apache/commons/beanutils2/DynaBean.java
index 297cb3e..aff2a77 100644
--- a/src/main/java/org/apache/commons/beanutils2/DynaBean.java
+++ b/src/main/java/org/apache/commons/beanutils2/DynaBean.java
@@ -79,7 +79,7 @@
 
     /**
      * Return the value of a mapped property with the specified name,
-     * or <code>null</code> if there is no value for the specified key.
+     * or {@code null} if there is no value for the specified key.
      *
      * @param name Name of the property whose value is to be retrieved
      * @param key Key of the value to be retrieved
@@ -94,7 +94,7 @@
 
 
     /**
-     * Return the <code>DynaClass</code> instance that describes the set of
+     * Return the {@code DynaClass} instance that describes the set of
      * properties available for this DynaBean.
      *
      * @return The associated DynaClass
diff --git a/src/main/java/org/apache/commons/beanutils2/DynaBeanPropertyMapDecorator.java b/src/main/java/org/apache/commons/beanutils2/DynaBeanPropertyMapDecorator.java
index 073e871..63c2e76 100644
--- a/src/main/java/org/apache/commons/beanutils2/DynaBeanPropertyMapDecorator.java
+++ b/src/main/java/org/apache/commons/beanutils2/DynaBeanPropertyMapDecorator.java
@@ -17,14 +17,14 @@
 package org.apache.commons.beanutils2;
 
 /**
- * <p>Decorates a {@link DynaBean} to provide <code>Map</code> behavior.</p>
+ * <p>Decorates a {@link DynaBean} to provide {@code Map} behavior.</p>
  *
  * <p>The motivation for this implementation is to provide access to {@link DynaBean}
  *    properties in technologies that are unaware of BeanUtils and {@link DynaBean}s -
  *    such as the expression languages of JSTL and JSF.</p>
  *
  * <p>This can be achieved either by wrapping the {@link DynaBean} prior to
- *    providing it to the technology to process or by providing a <code>Map</code>
+ *    providing it to the technology to process or by providing a {@code Map}
  *    accessor method on the DynaBean implementation:</p>
  *    <pre><code>
  *         public Map&lt;String, Object&gt; getMap() {
@@ -32,29 +32,29 @@
  *         }</code></pre>
  *
  * <p>This, for example, could be used in JSTL in the following way to access
- *    a DynaBean's <code>fooProperty</code>:</p>
- *    <ul><li><code>${myDynaBean.<b>map</b>.fooProperty}</code></li></ul>
+ *    a DynaBean's {@code fooProperty}:</p>
+ *    <ul><li>{@code ${myDynaBean.<b>map</b>.fooProperty}}</li></ul>
  *
  * <h3>Usage</h3>
  *
  * <p>To decorate a {@link DynaBean} simply instantiate this class with the
  *    target {@link DynaBean}:</p>
  *
- * <ul><li><code>Map&lt;String, Object&gt; fooMap = new DynaBeanPropertyMapDecorator(fooDynaBean);</code></li></ul>
+ * <ul><li>{@code Map&lt;String, Object&gt; fooMap = new DynaBeanPropertyMapDecorator(fooDynaBean);}</li></ul>
  *
- * <p>The above example creates a <b><i>read only</i></b> <code>Map</code>.
- *    To create  a <code>Map</code> which can be modified, construct a
- *    <code>DynaBeanPropertyMapDecorator</code> with the <b><i>read only</i></b>
- *    attribute set to <code>false</code>:</p>
+ * <p>The above example creates a <b><i>read only</i></b> {@code Map}.
+ *    To create  a {@code Map} which can be modified, construct a
+ *    {@code DynaBeanPropertyMapDecorator} with the <b><i>read only</i></b>
+ *    attribute set to {@code false}:</p>
  *
  * <ul><li><code>Map&lt;String, Object&gt; fooMap =
  *   new DynaBeanPropertyMapDecorator(fooDynaBean, false);</code></li></ul>
  *
  * <h3>Limitations</h3>
- * <p>In this implementation the <code>entrySet()</code>, <code>keySet()</code>
- *    and <code>values()</code> methods create an <b><i>unmodifiable</i></b>
- *    <code>Set</code> and it does not support the Map's <code>clear()</code>
- *    and <code>remove()</code> operations.</p>
+ * <p>In this implementation the {@code entrySet()</code>, <code>keySet()}
+ *    and {@code values()} methods create an <b><i>unmodifiable</i></b>
+ *    {@code Set</code> and it does not support the Map's <code>clear()}
+ *    and {@code remove()} operations.</p>
  *
  * @since BeanUtils 1.9.0
  */
@@ -63,8 +63,8 @@
      * Construct a Map for the specified {@link DynaBean}.
      *
      * @param dynaBean The dyna bean being decorated
-     * @param readOnly <code>true</code> if the Map is read only
-     * otherwise <code>false</code>
+     * @param readOnly {@code true} if the Map is read only
+     * otherwise {@code false}
      * @throws IllegalArgumentException if the {@link DynaBean} is null.
      */
     public DynaBeanPropertyMapDecorator(final DynaBean dynaBean, final boolean readOnly) {
diff --git a/src/main/java/org/apache/commons/beanutils2/DynaProperty.java b/src/main/java/org/apache/commons/beanutils2/DynaProperty.java
index 032a7b2..859ff5e 100644
--- a/src/main/java/org/apache/commons/beanutils2/DynaProperty.java
+++ b/src/main/java/org/apache/commons/beanutils2/DynaProperty.java
@@ -42,7 +42,7 @@
 
 public class DynaProperty implements Serializable {
 
-    // ----------------------------------------------------------- Constants
+    
 
 	private static final long serialVersionUID = -3084907613499830175L;
 	/*
@@ -63,7 +63,7 @@
     private static final int SHORT_TYPE = 8;
 
 
-    // ----------------------------------------------------------- Constructors
+    
 
 
     /**
@@ -96,7 +96,7 @@
     }
 
     /**
-     * Construct an indexed or mapped <code>DynaProperty</code> that supports (pseudo)-introspection
+     * Construct an indexed or mapped {@code DynaProperty} that supports (pseudo)-introspection
      * of the content type.
      *
      * @param name Name of the property being described
@@ -112,7 +112,7 @@
 
     }
 
-    // ------------------------------------------------------------- Properties
+    
 
     /** Property name */
     protected String name = null;
@@ -134,7 +134,7 @@
      * (including java 1.3).
      * Therefore, this field <strong>must not be serialized using the standard methods</strong>.</p>
      *
-     * <p><strong>Please leave this field as <code>transient</code></strong></p>
+     * <p><strong>Please leave this field as {@code transient}</strong></p>
      *
      * @return the property type
      */
@@ -143,31 +143,31 @@
     }
 
 
-    /** The <em>(optional)</em> type of content elements for indexed <code>DynaProperty</code> */
+    /** The <em>(optional)</em> type of content elements for indexed {@code DynaProperty} */
     protected transient Class<?> contentType;
     /**
-     * Gets the <em>(optional)</em> type of the indexed content for <code>DynaProperty</code>'s
+     * Gets the <em>(optional)</em> type of the indexed content for {@code DynaProperty}'s
      * that support this feature.
      *
      * <p>There are issues with serializing primitive class types on certain JVM versions
      * (including java 1.3).
      * Therefore, this field <strong>must not be serialized using the standard methods</strong>.</p>
      *
-     * @return the Class for the content type if this is an indexed <code>DynaProperty</code>
+     * @return the Class for the content type if this is an indexed {@code DynaProperty}
      * and this feature is supported. Otherwise null.
      */
     public Class<?> getContentType() {
         return contentType;
     }
 
-    // --------------------------------------------------------- Public Methods
+    
 
 
     /**
      * Does this property represent an indexed value (ie an array or List)?
      *
-     * @return <code>true</code> if the property is indexed (i.e. is a List or
-     * array), otherwise <code>false</code>
+     * @return {@code true} if the property is indexed (i.e. is a List or
+     * array), otherwise {@code false}
      */
     public boolean isIndexed() {
 
@@ -187,8 +187,8 @@
     /**
      * Does this property represent a mapped value (ie a Map)?
      *
-     * @return <code>true</code> if the property is a Map
-     * otherwise <code>false</code>
+     * @return {@code true} if the property is a Map
+     * otherwise {@code false}
      */
     public boolean isMapped() {
 
@@ -203,8 +203,8 @@
      * Checks this instance against the specified Object for equality. Overrides the
      * default reference test for equality provided by {@link java.lang.Object#equals(Object)}
      * @param obj The object to compare to
-     * @return <code>true</code> if object is a dyna property with the same name
-     * type and content type, otherwise <code>false</code>
+     * @return {@code true} if object is a dyna property with the same name
+     * type and content type, otherwise {@code false}
      * @since 1.8.0
      */
     @Override
@@ -261,7 +261,7 @@
 
     }
 
-    // --------------------------------------------------------- Serialization helper methods
+    
 
     /**
      * Writes this object safely.
diff --git a/src/main/java/org/apache/commons/beanutils2/FluentPropertyBeanIntrospector.java b/src/main/java/org/apache/commons/beanutils2/FluentPropertyBeanIntrospector.java
index bc1810a..6bfa2be 100644
--- a/src/main/java/org/apache/commons/beanutils2/FluentPropertyBeanIntrospector.java
+++ b/src/main/java/org/apache/commons/beanutils2/FluentPropertyBeanIntrospector.java
@@ -27,7 +27,7 @@
 
 /**
  * <p>
- * An implementation of the <code>BeanIntrospector</code> interface which can
+ * An implementation of the {@code BeanIntrospector} interface which can
  * detect write methods for properties used in fluent API scenario.
  * </p>
  * <p>
@@ -51,22 +51,22 @@
  * }
  * </pre>
  *
- * <p>Per default, <code>PropertyUtils</code> does not detect methods like this
+ * <p>Per default, {@code PropertyUtils} does not detect methods like this
  * because, having a non-<b>void</b> return type, they violate the Java Beans
  * specification.
  * </p>
  * <p>
  * This class is more tolerant with regards to the return type of a set method.
  * It basically iterates over all methods of a class and filters them for a
- * configurable prefix (the default prefix is <code>set</code>). It then
- * generates corresponding <code>PropertyDescriptor</code> objects for the
+ * configurable prefix (the default prefix is {@code set}). It then
+ * generates corresponding {@code PropertyDescriptor} objects for the
  * methods found which use these methods as write methods.
  * </p>
  * <p>
  * An instance of this class is intended to collaborate with a
  * {@link DefaultBeanIntrospector} object. So best results are achieved by
  * adding this instance as custom {@code BeanIntrospector} after the
- * <code>DefaultBeanIntrospector</code> object. Then default introspection finds
+ * {@code DefaultBeanIntrospector} object. Then default introspection finds
  * read-only properties because it does not detect the write methods with a
  * non-<b>void</b> return type. {@code FluentPropertyBeanIntrospector}
  * completes the descriptors for these properties by setting the correct write
@@ -87,7 +87,7 @@
 
     /**
      *
-     * Creates a new instance of <code>FluentPropertyBeanIntrospector</code> and
+     * Creates a new instance of {@code FluentPropertyBeanIntrospector} and
      * initializes it with the prefix for write methods used by the classes to
      * be inspected.
      *
@@ -104,7 +104,7 @@
 
     /**
      *
-     * Creates a new instance of <code>FluentPropertyBeanIntrospector</code> and
+     * Creates a new instance of {@code FluentPropertyBeanIntrospector} and
      * sets the default prefix for write methods.
      */
     public FluentPropertyBeanIntrospector() {
diff --git a/src/main/java/org/apache/commons/beanutils2/JDBCDynaClass.java b/src/main/java/org/apache/commons/beanutils2/JDBCDynaClass.java
index dc69113..43b627f 100644
--- a/src/main/java/org/apache/commons/beanutils2/JDBCDynaClass.java
+++ b/src/main/java/org/apache/commons/beanutils2/JDBCDynaClass.java
@@ -38,7 +38,7 @@
 
     private static final long serialVersionUID = 1L;
 
-    // ----------------------------------------------------- Instance Variables
+    
 
     /**
      * <p>Flag defining whether column names should be lower cased when
@@ -61,7 +61,7 @@
      * <p>The set of dynamic properties that are part of this
      * {@link DynaClass}, keyed by the property name.  Individual descriptor
      * instances will be the same instances as those in the
-     * <code>properties</code> list.</p>
+     * {@code properties} list.</p>
      */
     protected Map<String, DynaProperty> propertiesMap = new HashMap<>();
 
@@ -71,12 +71,12 @@
      */
     private Map<String, String> columnNameXref;
 
-    // ------------------------------------------------------ DynaClass Methods
+    
 
     /**
      * <p>Return the name of this DynaClass (analogous to the
-     * <code>getName()</code> method of <code>java.lang.Class</code>, which
-     * allows the same <code>DynaClass</code> implementation class to support
+     * {@code getName()</code> method of <code>java.lang.Class}, which
+     * allows the same {@code DynaClass} implementation class to support
      * different dynamic classes, with different sets of properties.</p>
      */
     @Override
@@ -88,7 +88,7 @@
 
     /**
      * <p>Return a property descriptor for the specified property, if it
-     * exists; otherwise, return <code>null</code>.</p>
+     * exists; otherwise, return {@code null}.</p>
      *
      * @param name Name of the dynamic property for which a descriptor
      *  is requested
@@ -106,7 +106,7 @@
     }
 
     /**
-     * <p>Return an array of <code>ProperyDescriptors</code> for the properties
+     * <p>Return an array of {@code ProperyDescriptors} for the properties
      * currently defined in this DynaClass.  If no properties are defined, a
      * zero-length array will be returned.</p>
      */
@@ -146,7 +146,7 @@
     }
 
     /**
-     * <p>Loads and returns the <code>Class</code> of the given name.
+     * <p>Loads and returns the {@code Class} of the given name.
      * By default, a load from the thread context class loader is attempted.
      * If there is no such class loader, the class loader used to load this
      * class will be utilized.</p>
@@ -230,10 +230,10 @@
 
     /**
      * <p>Introspect the metadata associated with our result set, and populate
-     * the <code>properties</code> and <code>propertiesMap</code> instance
+     * the {@code properties</code> and <code>propertiesMap} instance
      * variables.</p>
      *
-     * @param resultSet The <code>resultSet</code> whose metadata is to
+     * @param resultSet The {@code resultSet} whose metadata is to
      *  be introspected
      *
      * @throws SQLException if an error is encountered processing the
diff --git a/src/main/java/org/apache/commons/beanutils2/LazyDynaBean.java b/src/main/java/org/apache/commons/beanutils2/LazyDynaBean.java
index 339fe7e..1ac1d31 100644
--- a/src/main/java/org/apache/commons/beanutils2/LazyDynaBean.java
+++ b/src/main/java/org/apache/commons/beanutils2/LazyDynaBean.java
@@ -30,28 +30,28 @@
 import org.apache.commons.logging.LogFactory;
 
 /**
- * <p>DynaBean which automatically adds properties to the <code>DynaClass</code>
+ * <p>DynaBean which automatically adds properties to the {@code DynaClass}
  *   and provides <i>Lazy List</i> and <i>Lazy Map</i> features.</p>
  *
  * <p>DynaBeans deal with three types of properties - <i>simple</i>, <i>indexed</i> and <i>mapped</i> and
- *    have the following <code>get()</code> and <code>set()</code> methods for
+ *    have the following {@code get()</code> and <code>set()} methods for
  *    each of these types:</p>
  *    <ul>
- *        <li><i>Simple</i> property methods - <code>get(name)</code> and
- *                          <code>set(name, value)</code></li>
- *        <li><i>Indexed</i> property methods - <code>get(name, index)</code> and
- *                          <code>set(name, index, value)</code></li>
- *        <li><i>Mapped</i> property methods - <code>get(name, key)</code> and
- *                          <code>set(name, key, value)</code></li>
+ *        <li><i>Simple</i> property methods - {@code get(name)} and
+ *                          {@code set(name, value)}</li>
+ *        <li><i>Indexed</i> property methods - {@code get(name, index)} and
+ *                          {@code set(name, index, value)}</li>
+ *        <li><i>Mapped</i> property methods - {@code get(name, key)} and
+ *                          {@code set(name, key, value)}</li>
  *    </ul>
  *
  * <p><b><u>Getting Property Values</u></b></p>
- * <p>Calling any of the <code>get()</code> methods, for a property which
- *    doesn't exist, returns <code>null</code> in this implementation.</p>
+ * <p>Calling any of the {@code get()} methods, for a property which
+ *    doesn't exist, returns {@code null} in this implementation.</p>
  *
  * <p><b><u>Setting Simple Properties</u></b></p>
- *    <p>The <code>LazyDynaBean</code> will automatically add a property to the <code>DynaClass</code>
- *       if it doesn't exist when the <code>set(name, value)</code> method is called.</p>
+ *    <p>The {@code LazyDynaBean</code> will automatically add a property to the <code>DynaClass}
+ *       if it doesn't exist when the {@code set(name, value)} method is called.</p>
  *
  *     <pre><code>
  *         DynaBean myBean = new LazyDynaBean();
@@ -59,13 +59,13 @@
  *     </code></pre>
  *
  * <p><b><u>Setting Indexed Properties</u></b></p>
- *    <p>If the property <b>doesn't</b> exist, the <code>LazyDynaBean</code> will automatically add
- *       a property with an <code>ArrayList</code> type to the <code>DynaClass</code> when
- *       the <code>set(name, index, value)</code> method is called.
- *       It will also instantiate a new <code>ArrayList</code> and automatically <i>grow</i>
- *       the <code>List</code> so that it is big enough to accommodate the index being set.
- *       <code>ArrayList</code> is the default indexed property that LazyDynaBean uses but
- *       this can be easily changed by overriding the <code>defaultIndexedProperty(name)</code>
+ *    <p>If the property <b>doesn't</b> exist, the {@code LazyDynaBean} will automatically add
+ *       a property with an {@code ArrayList</code> type to the <code>DynaClass} when
+ *       the {@code set(name, index, value)} method is called.
+ *       It will also instantiate a new {@code ArrayList} and automatically <i>grow</i>
+ *       the {@code List} so that it is big enough to accommodate the index being set.
+ *       {@code ArrayList} is the default indexed property that LazyDynaBean uses but
+ *       this can be easily changed by overriding the {@code defaultIndexedProperty(name)}
  *       method.</p>
  *
  *     <pre><code>
@@ -74,11 +74,11 @@
  *         myBean.set("myIndexedProperty", 1, "myValue2");
  *     </code></pre>
  *
- *    <p>If the indexed property <b>does</b> exist in the <code>DynaClass</code> but is set to
- *      <code>null</code> in the <code>LazyDynaBean</code>, then it will instantiate a
- *      new <code>List</code> or <code>Array</code> as specified by the property's type
- *      in the <code>DynaClass</code> and automatically <i>grow</i> the <code>List</code>
- *      or <code>Array</code> so that it is big enough to accommodate the index being set.</p>
+ *    <p>If the indexed property <b>does</b> exist in the {@code DynaClass} but is set to
+ *      {@code null</code> in the <code>LazyDynaBean}, then it will instantiate a
+ *      new {@code List</code> or <code>Array} as specified by the property's type
+ *      in the {@code DynaClass</code> and automatically <i>grow</i> the <code>List}
+ *      or {@code Array} so that it is big enough to accommodate the index being set.</p>
  *
  *     <pre><code>
  *         DynaBean myBean = new LazyDynaBean();
@@ -89,21 +89,21 @@
  *     </code></pre>
  *
  * <p><b><u>Setting Mapped Properties</u></b></p>
- *    <p>If the property <b>doesn't</b> exist, the <code>LazyDynaBean</code> will automatically add
- *       a property with a <code>HashMap</code> type to the <code>DynaClass</code> and
- *       instantiate a new <code>HashMap</code> in the DynaBean when the
- *       <code>set(name, key, value)</code> method is called. <code>HashMap</code> is the default
+ *    <p>If the property <b>doesn't</b> exist, the {@code LazyDynaBean} will automatically add
+ *       a property with a {@code HashMap</code> type to the <code>DynaClass} and
+ *       instantiate a new {@code HashMap} in the DynaBean when the
+ *       {@code set(name, key, value)</code> method is called. <code>HashMap} is the default
  *       mapped property that LazyDynaBean uses but this can be easily changed by overriding
- *       the <code>defaultMappedProperty(name)</code> method.</p>
+ *       the {@code defaultMappedProperty(name)} method.</p>
  *
  *     <pre><code>
  *         DynaBean myBean = new LazyDynaBean();
  *         myBean.set("myMappedProperty", "myKey", "myValue");
  *     </code></pre>
  *
- *    <p>If the mapped property <b>does</b> exist in the <code>DynaClass</code> but is set to
- *      <code>null</code> in the <code>LazyDynaBean</code>, then it will instantiate a
- *      new <code>Map</code> as specified by the property's type in the <code>DynaClass</code>.</p>
+ *    <p>If the mapped property <b>does</b> exist in the {@code DynaClass} but is set to
+ *      {@code null</code> in the <code>LazyDynaBean}, then it will instantiate a
+ *      new {@code Map</code> as specified by the property's type in the <code>DynaClass}.</p>
  *
  *     <pre><code>
  *         DynaBean myBean = new LazyDynaBean();
@@ -113,10 +113,10 @@
  *     </code></pre>
  *
  * <p><b><u><i>Restricted</i> DynaClass</u></b></p>
- *    <p><code>MutableDynaClass</code> have a facility to <i>restrict</i> the <code>DynaClass</code>
- *       so that its properties cannot be modified. If the <code>MutableDynaClass</code> is
- *       restricted then calling any of the <code>set()</code> methods for a property which
- *       doesn't exist will result in a <code>IllegalArgumentException</code> being thrown.</p>
+ *    <p>{@code MutableDynaClass</code> have a facility to <i>restrict</i> the <code>DynaClass}
+ *       so that its properties cannot be modified. If the {@code MutableDynaClass} is
+ *       restricted then calling any of the {@code set()} methods for a property which
+ *       doesn't exist will result in a {@code IllegalArgumentException} being thrown.</p>
  *
  * @see LazyDynaClass
  */
@@ -149,7 +149,7 @@
     protected static final Double     Double_ZERO     = Double.valueOf((byte)0);
 
     /**
-     * The <code>MutableDynaClass</code> "base class" that this DynaBean
+     * The {@code MutableDynaClass} "base class" that this DynaBean
      * is associated with.
      */
     protected Map<String, Object> values;
@@ -158,23 +158,23 @@
     private transient Map<String, Object> mapDecorator;
 
     /**
-     * The <code>MutableDynaClass</code> "base class" that this DynaBean
+     * The {@code MutableDynaClass} "base class" that this DynaBean
      * is associated with.
      */
     protected MutableDynaClass dynaClass;
 
 
-    // ------------------- Constructors ----------------------------------
+    
 
     /**
-     * Construct a new <code>LazyDynaBean</code> with a <code>LazyDynaClass</code> instance.
+     * Construct a new {@code LazyDynaBean</code> with a <code>LazyDynaClass} instance.
      */
     public LazyDynaBean() {
         this(new LazyDynaClass());
     }
 
     /**
-     * Construct a new <code>LazyDynaBean</code> with a <code>LazyDynaClass</code> instance.
+     * Construct a new {@code LazyDynaBean</code> with a <code>LazyDynaClass} instance.
      *
      * @param name Name of this DynaBean class
      */
@@ -183,9 +183,9 @@
     }
 
     /**
-     * Construct a new <code>DynaBean</code> associated with the specified
-     * <code>DynaClass</code> instance - if its not a <code>MutableDynaClass</code>
-     * then a new <code>LazyDynaClass</code> is created and the properties copied.
+     * Construct a new {@code DynaBean} associated with the specified
+     * {@code DynaClass</code> instance - if its not a <code>MutableDynaClass}
+     * then a new {@code LazyDynaClass} is created and the properties copied.
      *
      * @param dynaClass The DynaClass we are associated with
      */
@@ -202,15 +202,15 @@
     }
 
 
-    // ------------------- Public Methods ----------------------------------
+    
 
     /**
      * <p>
      * Return a Map representation of this DynaBean.
      * </p>
      * This, for example, could be used in JSTL in the following way to access
-     * a DynaBean's <code>fooProperty</code>:
-     * <ul><li><code>${myDynaBean.<b>map</b>.fooProperty}</code></li></ul>
+     * a DynaBean's {@code fooProperty}:
+     * <ul><li>{@code ${myDynaBean.<b>map</b>.fooProperty}}</li></ul>
      *
      * @return a Map representation of this DynaBean
      */
@@ -256,7 +256,7 @@
 
     }
 
-    // ------------------- DynaBean Methods ----------------------------------
+    
 
     /**
      * Does the specified mapped property contain a value for the specified
@@ -264,8 +264,8 @@
      *
      * @param name Name of the property to check
      * @param key Name of the key to check
-     * @return <code>true</code> if the mapped property contains a value for
-     * the specified key, otherwise <code>false</code>
+     * @return {@code true} if the mapped property contains a value for
+     * the specified key, otherwise {@code false}
      *
      * @throws IllegalArgumentException if no property name is specified
      */
@@ -292,7 +292,7 @@
     /**
      * <p>Return the value of a simple property with the specified name.</p>
      *
-     * <p><strong>N.B.</strong> Returns <code>null</code> if there is no property
+     * <p><strong>N.B.</strong> Returns {@code null} if there is no property
      *  of the specified name.</p>
      *
      * @param name Name of the property whose value is to be retrieved.
@@ -331,7 +331,7 @@
     /**
      * <p>Return the value of an indexed property with the specified name.</p>
      *
-     * <p><strong>N.B.</strong> Returns <code>null</code> if there is no 'indexed'
+     * <p><strong>N.B.</strong> Returns {@code null} if there is no 'indexed'
      * property of the specified name.</p>
      *
      * @param name Name of the property whose value is to be retrieved
@@ -380,7 +380,7 @@
     /**
      * <p>Return the value of a mapped property with the specified name.</p>
      *
-     * <p><strong>N.B.</strong> Returns <code>null</code> if there is no 'mapped'
+     * <p><strong>N.B.</strong> Returns {@code null} if there is no 'mapped'
      * property of the specified name.</p>
      *
      * @param name Name of the property whose value is to be retrieved
@@ -420,7 +420,7 @@
 
 
     /**
-     * Return the <code>DynaClass</code> instance that describes the set of
+     * Return the {@code DynaClass} instance that describes the set of
      * properties available for this DynaBean.
      *
      * @return The associated DynaClass
@@ -609,7 +609,7 @@
 
     }
 
-    // ------------------- protected Methods ----------------------------------
+    
 
     /**
      * Grow the size of an indexed property
@@ -826,7 +826,7 @@
     }
 
     /**
-     * Create a new Instance of a <code>java.lang.Number</code> Property.
+     * Create a new Instance of a {@code java.lang.Number} Property.
      * @param name The name of the property
      * @param type The class of the property
      * @return The new value
@@ -867,11 +867,11 @@
     }
 
     /**
-     * <p>Creates a new <code>ArrayList</code> for an 'indexed' property
+     * <p>Creates a new {@code ArrayList} for an 'indexed' property
      *    which doesn't exist.</p>
      *
-     * <p>This method should be overridden if an alternative <code>List</code>
-     *    or <code>Array</code> implementation is required for 'indexed' properties.</p>
+     * <p>This method should be overridden if an alternative {@code List}
+     *    or {@code Array} implementation is required for 'indexed' properties.</p>
      *
      * @param name Name of the 'indexed property.
      * @return The default value for an indexed property (java.util.ArrayList)
@@ -881,10 +881,10 @@
     }
 
     /**
-     * <p>Creates a new <code>HashMap</code> for a 'mapped' property
+     * <p>Creates a new {@code HashMap} for a 'mapped' property
      *    which doesn't exist.</p>
      *
-     * <p>This method can be overridden if an alternative <code>Map</code>
+     * <p>This method can be overridden if an alternative {@code Map}
      *    implementation is required for 'mapped' properties.</p>
      *
      * @param name Name of the 'mapped property.
@@ -897,8 +897,8 @@
     /**
      * Indicates if there is a property with the specified name.
      * @param name The name of the property to check
-     * @return <code>true</code> if there is a property of the
-     * specified name, otherwise <code>false</code>
+     * @return {@code true} if there is a property of the
+     * specified name, otherwise {@code false}
      */
     protected boolean isDynaProperty(final String name) {
 
@@ -921,8 +921,8 @@
      *
      * @param dest Destination class
      * @param source Source class
-     * @return <code>true</code> if the source class is assignable to the
-     * destination class, otherwise <code>false</code>
+     * @return {@code true} if the source class is assignable to the
+     * destination class, otherwise {@code false}
      */
     protected boolean isAssignable(final Class<?> dest, final Class<?> source) {
 
@@ -942,7 +942,7 @@
     }
 
     /**
-     * <p>Creates a new instance of the <code>Map</code>.</p>
+     * <p>Creates a new instance of the {@code Map}.</p>
      * @return a new Map instance
      */
     protected Map<String, Object> newMap() {
@@ -950,7 +950,7 @@
     }
 
     /**
-     * <p>Returns the <code>Log</code>.
+     * <p>Returns the {@code Log}.
      */
     private Log logger() {
         if (logger == null) {
diff --git a/src/main/java/org/apache/commons/beanutils2/LazyDynaClass.java b/src/main/java/org/apache/commons/beanutils2/LazyDynaClass.java
index 69b2326..935b08c 100644
--- a/src/main/java/org/apache/commons/beanutils2/LazyDynaClass.java
+++ b/src/main/java/org/apache/commons/beanutils2/LazyDynaClass.java
@@ -17,26 +17,26 @@
 package org.apache.commons.beanutils2;
 
 /**
- * <p>DynaClass which implements the <code>MutableDynaClass</code> interface.</p>
+ * <p>DynaClass which implements the {@code MutableDynaClass} interface.</p>
  *
- * <p>A <code>MutableDynaClass</code> is a specialized extension to <code>DynaClass</code>
+ * <p>A {@code MutableDynaClass</code> is a specialized extension to <code>DynaClass}
  *    that allows properties to be added or removed dynamically.</p>
  *
  * <p>This implementation has one slightly unusual default behavior - calling
- *    the <code>getDynaProperty(name)</code> method for a property which doesn't
- *    exist returns a <code>DynaProperty</code> rather than <code>null</code>. The
- *    reason for this is that <code>BeanUtils</code> calls this method to check if
+ *    the {@code getDynaProperty(name)} method for a property which doesn't
+ *    exist returns a {@code DynaProperty</code> rather than <code>null}. The
+ *    reason for this is that {@code BeanUtils} calls this method to check if
  *    a property exists before trying to set the value. This would defeat the object
- *    of the <code>LazyDynaBean</code> which automatically adds missing properties
- *    when any of its <code>set()</code> methods are called. For this reason the
- *    <code>isDynaProperty(name)</code> method has been added to this implementation
+ *    of the {@code LazyDynaBean} which automatically adds missing properties
+ *    when any of its {@code set()} methods are called. For this reason the
+ *    {@code isDynaProperty(name)} method has been added to this implementation
  *    in order to determine if a property actually exists. If the more <i>normal</i>
- *    behavior of returning <code>null</code> is required, then this can be achieved
- *    by calling the <code>setReturnNull(true)</code>.</p>
+ *    behavior of returning {@code null} is required, then this can be achieved
+ *    by calling the {@code setReturnNull(true)}.</p>
  *
- * <p>The <code>add(name, type, readable, writable)</code> method is not implemented
- *    and always throws an <code>UnsupportedOperationException</code>. I believe
- *    this attributes need to be added to the <code>DynaProperty</code> class
+ * <p>The {@code add(name, type, readable, writable)} method is not implemented
+ *    and always throws an {@code UnsupportedOperationException}. I believe
+ *    this attributes need to be added to the {@code DynaProperty} class
  *    in order to control read/write facilities.</p>
  *
  * @see LazyDynaBean
@@ -51,10 +51,10 @@
     protected boolean restricted;
 
     /**
-     * <p>Controls whether the <code>getDynaProperty()</code> method returns
+     * <p>Controls whether the {@code getDynaProperty()} method returns
      * null if a property doesn't exist - or creates a new one.</p>
      *
-     * <p>Default is <code>false</code>.
+     * <p>Default is {@code false}.
      */
     protected boolean returnNull = false;
 
@@ -109,8 +109,8 @@
      * <p>Is this DynaClass currently restricted.</p>
      * <p>If restricted, no changes to the existing registration of
      *  property names, data types, readability, or writeability are allowed.</p>
-     * @return <code>true</code> if this {@link MutableDynaClass} cannot be changed
-     * otherwise <code>false</code>
+     * @return {@code true} if this {@link MutableDynaClass} cannot be changed
+     * otherwise {@code false}
      */
     @Override
     public boolean isRestricted() {
@@ -121,8 +121,8 @@
      * <p>Set whether this DynaClass is currently restricted.</p>
      * <p>If restricted, no changes to the existing registration of
      *  property names, data types, readability, or writeability are allowed.</p>
-     * @param restricted <code>true</code> if this {@link MutableDynaClass} cannot
-     * be changed otherwise <code>false</code>
+     * @param restricted {@code true} if this {@link MutableDynaClass} cannot
+     * be changed otherwise {@code false}
      */
     @Override
     public void setRestricted(final boolean restricted) {
@@ -130,25 +130,25 @@
     }
 
     /**
-     * Should this DynaClass return a <code>null</code> from
-     * the <code>getDynaProperty(name)</code> method if the property
+     * Should this DynaClass return a {@code null} from
+     * the {@code getDynaProperty(name)} method if the property
      * doesn't exist.
      *
-     * @return <code>true</code> if a <code>null</code> {@link DynaProperty}
+     * @return {@code true</code> if a <code>null} {@link DynaProperty}
      * should be returned if the property doesn't exist, otherwise
-     * <code>false</code> if a new {@link DynaProperty} should be created.
+     * {@code false} if a new {@link DynaProperty} should be created.
      */
     public boolean isReturnNull() {
         return returnNull;
     }
 
     /**
-     * Set whether this DynaClass should return a <code>null</code> from
-     * the <code>getDynaProperty(name)</code> method if the property
+     * Set whether this DynaClass should return a {@code null} from
+     * the {@code getDynaProperty(name)} method if the property
      * doesn't exist.
-     * @param returnNull <code>true</code> if a <code>null</code> {@link DynaProperty}
+     * @param returnNull {@code true</code> if a <code>null} {@link DynaProperty}
      * should be returned if the property doesn't exist, otherwise
-     * <code>false</code> if a new {@link DynaProperty} should be created.
+     * {@code false} if a new {@link DynaProperty} should be created.
      */
     public void setReturnNull(final boolean returnNull) {
         this.returnNull = returnNull;
@@ -195,18 +195,18 @@
      * and writeability.</p>
      *
      * <p><strong>N.B.</strong>Support for readable/writeable properties has not been implemented
-     *    and this method always throws a <code>UnsupportedOperationException</code>.</p>
+     *    and this method always throws a {@code UnsupportedOperationException}.</p>
      *
      * <p>I'm not sure the intention of the original authors for this method, but it seems to
-     *    me that readable/writable should be attributes of the <code>DynaProperty</code> class
+     *    me that readable/writable should be attributes of the {@code DynaProperty} class
      *    (which they are not) and is the reason this method has not been implemented.</p>
      *
      * @param name Name of the new dynamic property
      * @param type Data type of the new dynamic property (null for no
      *  restrictions)
-     * @param readable Set to <code>true</code> if this property value
+     * @param readable Set to {@code true} if this property value
      *  should be readable
-     * @param writeable Set to <code>true</code> if this property value
+     * @param writeable Set to {@code true} if this property value
      *  should be writeable
      *
      * @throws UnsupportedOperationException anytime this method is called
@@ -300,18 +300,18 @@
     /**
      * <p>Return a property descriptor for the specified property.</p>
      *
-     * <p>If the property is not found and the <code>returnNull</code> indicator is
-     *    <code>true</code>, this method always returns <code>null</code>.</p>
+     * <p>If the property is not found and the {@code returnNull} indicator is
+     *    {@code true</code>, this method always returns <code>null}.</p>
      *
-     * <p>If the property is not found and the <code>returnNull</code> indicator is
-     *    <code>false</code> a new property descriptor is created and returned (although
+     * <p>If the property is not found and the {@code returnNull} indicator is
+     *    {@code false} a new property descriptor is created and returned (although
      *    its not actually added to the DynaClass's properties). This is the default
      *    behavior.</p>
      *
-     * <p>The reason for not returning a <code>null</code> property descriptor is that
-     *    <code>BeanUtils</code> uses this method to check if a property exists
+     * <p>The reason for not returning a {@code null} property descriptor is that
+     *    {@code BeanUtils} uses this method to check if a property exists
      *    before trying to set it - since these <i>Lazy</i> implementations automatically
-     *    add any new properties when they are set, returning <code>null</code> from
+     *    add any new properties when they are set, returning {@code null} from
      *    this method would defeat their purpose.</p>
      *
      * @param name Name of the dynamic property for which a descriptor
@@ -342,14 +342,14 @@
     /**
      * <p>Indicate whether a property actually exists.</p>
      *
-     * <p><strong>N.B.</strong> Using <code>getDynaProperty(name) == null</code>
+     * <p><strong>N.B.</strong> Using {@code getDynaProperty(name) == null}
      * doesn't work in this implementation because that method might
      * return a DynaProperty if it doesn't exist (depending on the
-     * <code>returnNull</code> indicator).</p>
+     * {@code returnNull} indicator).</p>
      *
      * @param name The name of the property to check
-     * @return <code>true</code> if there is a property of the
-     * specified name, otherwise <code>false</code>
+     * @return {@code true} if there is a property of the
+     * specified name, otherwise {@code false}
      * @throws IllegalArgumentException if no property name is specified
      */
     public boolean isDynaProperty(final String name) {
diff --git a/src/main/java/org/apache/commons/beanutils2/LazyDynaList.java b/src/main/java/org/apache/commons/beanutils2/LazyDynaList.java
index c747fd9..6171427 100644
--- a/src/main/java/org/apache/commons/beanutils2/LazyDynaList.java
+++ b/src/main/java/org/apache/commons/beanutils2/LazyDynaList.java
@@ -27,46 +27,46 @@
  * <p>There are two main purposes for this class:</p>
  *    <ul>
  *        <li>To provide <i>Lazy List</i> behavior - automatically
- *            <i>growing</i> and <i>populating</i> the <code>List</code>
- *            with either <code>DynaBean</code>, <code>java.util.Map</code>
+ *            <i>growing</i> and <i>populating</i> the {@code List}
+ *            with either {@code DynaBean</code>, <code>java.util.Map}
  *            or POJO Beans.</li>
  *        <li>To provide a straight forward way of putting a Collection
  *            or Array into the lazy list <i>and</i> a straight forward
  *            way to get it out again at the end.</li>
  *    </ul>
  *
- * <p>All elements added to the List are stored as <code>DynaBean</code>'s:</p>
+ * <p>All elements added to the List are stored as {@code DynaBean}'s:</p>
  * <ul>
- *    <li><code>java.util.Map</code> elements are "wrapped" in a <code>LazyDynaMap</code>.</li>
- *    <li>POJO Bean elements are "wrapped" in a <code>WrapDynaBean</code>.</li>
- *    <li><code>DynaBean</code>'s are stored un-changed.</li>
+ *    <li>{@code java.util.Map</code> elements are "wrapped" in a <code>LazyDynaMap}.</li>
+ *    <li>POJO Bean elements are "wrapped" in a {@code WrapDynaBean}.</li>
+ *    <li>{@code DynaBean}'s are stored un-changed.</li>
  * </ul>
  *
- * <h2><code>toArray()</code></h2>
- * <p>The <code>toArray()</code> method returns an array of the
- *    elements of the appropriate type. If the <code>LazyDynaList</code>
- *    is populated with <code>java.util.Map</code> objects a
- *    <code>Map[]</code> array is returned.
+ * <h2>{@code toArray()}</h2>
+ * <p>The {@code toArray()} method returns an array of the
+ *    elements of the appropriate type. If the {@code LazyDynaList}
+ *    is populated with {@code java.util.Map} objects a
+ *    {@code Map[]} array is returned.
  *    If the list is populated with POJO Beans an appropriate
- *    array of the POJO Beans is returned. Otherwise a <code>DynaBean[]</code>
+ *    array of the POJO Beans is returned. Otherwise a {@code DynaBean[]}
  *    array is returned.
  * </p>
  *
- * <h2><code>toDynaBeanArray()</code></h2>
- * <p>The <code>toDynaBeanArray()</code> method returns a
- *    <code>DynaBean[]</code> array of the elements in the List.
+ * <h2>{@code toDynaBeanArray()}</h2>
+ * <p>The {@code toDynaBeanArray()} method returns a
+ *    {@code DynaBean[]} array of the elements in the List.
  * </p>
  *
  * <p><strong>N.B.</strong>All the elements in the List must be the
- *    same type. If the <code>DynaClass</code> or <code>Class</code>
- *    of the <code>LazyDynaList</code>'s elements is
+ *    same type. If the {@code DynaClass</code> or <code>Class}
+ *    of the {@code LazyDynaList}'s elements is
  *    not specified, then it will be automatically set to the type
  *    of the first element populated.
  * </p>
  *
  * <h2>Example 1</h2>
- * <p>If you have an array of <code>java.util.Map[]</code> - you can put that into
- *    a <code>LazyDynaList</code>.</p>
+ * <p>If you have an array of {@code java.util.Map[]} - you can put that into
+ *    a {@code LazyDynaList}.</p>
  *
  * <pre><code>
  *    TreeMap[] myArray = .... // your Map[]
@@ -127,18 +127,18 @@
  * </code></pre>
  *
  * <p><strong>N.B.</strong> You may wonder why control the type
- *    using a <code>DynaClass</code> rather than the <code>Class</code>
- *    as in the previous example - the reason is that some <code>DynaBean</code>
+ *    using a {@code DynaClass</code> rather than the <code>Class}
+ *    as in the previous example - the reason is that some {@code DynaBean}
  *    implementations don't have a <i>default</i> empty constructor and
- *    therefore need to be instantiated using the <code>DynaClass.newInstance()</code>
+ *    therefore need to be instantiated using the {@code DynaClass.newInstance()}
  *    method.</p>
  *
  * <h2>Example 4</h2>
  * <p>A slight variation - set the element type using either
- *    the <code>setElementType(Class)</code> method or the
- *    <code>setElementDynaClass(DynaClass)</code> method - then populate
- *    with the normal <code>java.util.List</code> methods(i.e.
- *    <code>add()</code>, <code>addAll()</code> or <code>set()</code>).</p>
+ *    the {@code setElementType(Class)} method or the
+ *    {@code setElementDynaClass(DynaClass)} method - then populate
+ *    with the normal {@code java.util.List} methods(i.e.
+ *    {@code add()</code>, <code>addAll()</code> or <code>set()}).</p>
  *
  * <pre><code>
  *    // Create a new LazyDynaList (100 element capacity)
@@ -187,7 +187,7 @@
     private Class<?> elementDynaBeanType;
 
 
-    // ------------------- Constructors ------------------------------
+    
 
     /**
      * Default Constructor.
@@ -254,7 +254,7 @@
     }
 
 
-    // ------------------- java.util.List Methods --------------------
+    
 
     /**
      * <p>Insert an element at the specified index position.</p>
@@ -481,7 +481,7 @@
     }
 
 
-    // ------------------- Public Methods ----------------------------
+    
 
     /**
      * <p>Converts the List to an DynaBean Array.</p>
@@ -595,7 +595,7 @@
     }
 
 
-    // ------------------- Private Methods ---------------------------
+    
 
     /**
      * <p>Automatically <i>grown</i> the List
diff --git a/src/main/java/org/apache/commons/beanutils2/LazyDynaMap.java b/src/main/java/org/apache/commons/beanutils2/LazyDynaMap.java
index 02c50a7..9ae7f01 100644
--- a/src/main/java/org/apache/commons/beanutils2/LazyDynaMap.java
+++ b/src/main/java/org/apache/commons/beanutils2/LazyDynaMap.java
@@ -19,29 +19,29 @@
 import java.util.Map;
 
 /**
- * <p>Provides a <i>light weight</i> <code>DynaBean</code> facade to a <code>Map</code>
+ * <p>Provides a <i>light weight</i> {@code DynaBean</code> facade to a <code>Map}
  *  with <i>lazy</i> map/list processing.</p>
  *
- * <p>Its a <i>light weight</i> <code>DynaBean</code> implementation because there is no
- *    actual <code>DynaClass</code> associated with this <code>DynaBean</code> - in fact
- *    it implements the <code>DynaClass</code> interface itself providing <i>pseudo</i> DynaClass
- *    behavior from the actual values stored in the <code>Map</code>.</p>
+ * <p>Its a <i>light weight</i> {@code DynaBean} implementation because there is no
+ *    actual {@code DynaClass</code> associated with this <code>DynaBean} - in fact
+ *    it implements the {@code DynaClass} interface itself providing <i>pseudo</i> DynaClass
+ *    behavior from the actual values stored in the {@code Map}.</p>
  *
- * <p>As well providing rhe standard <code>DynaBean</code> access to the <code>Map</code>'s properties
+ * <p>As well providing rhe standard {@code DynaBean</code> access to the <code>Map}'s properties
  *    this class also provides the usual <i>Lazy</i> behavior:</p>
  *    <ul>
- *       <li>Properties don't need to be pre-defined in a <code>DynaClass</code></li>
- *       <li>Indexed properties (<code>Lists</code> or <code>Arrays</code>) are automatically instantiated
+ *       <li>Properties don't need to be pre-defined in a {@code DynaClass}</li>
+ *       <li>Indexed properties ({@code Lists</code> or <code>Arrays}) are automatically instantiated
  *           and <i>grown</i> so that they are large enough to cater for the index being set.</li>
  *       <li>Mapped properties are automatically instantiated.</li>
  *    </ul>
  *
  * <p><b><u><i>Restricted</i> DynaClass</u></b></p>
- *    <p>This class implements the <code>MutableDynaClass</code> interface.
- *       <code>MutableDynaClass</code> have a facility to <i>restrict</i> the <code>DynaClass</code>
- *       so that its properties cannot be modified. If the <code>MutableDynaClass</code> is
- *       restricted then calling any of the <code>set()</code> methods for a property which
- *       doesn't exist will result in a <code>IllegalArgumentException</code> being thrown.</p>
+ *    <p>This class implements the {@code MutableDynaClass} interface.
+ *       {@code MutableDynaClass</code> have a facility to <i>restrict</i> the <code>DynaClass}
+ *       so that its properties cannot be modified. If the {@code MutableDynaClass} is
+ *       restricted then calling any of the {@code set()} methods for a property which
+ *       doesn't exist will result in a {@code IllegalArgumentException} being thrown.</p>
  *
  */
 public class LazyDynaMap extends LazyDynaBean implements MutableDynaClass {
@@ -50,7 +50,7 @@
 
     /**
      * The name of this DynaClass (analogous to the
-     * <code>getName()</code> method of <code>java.lang.Class</code>).
+     * {@code getName()</code> method of <code>java.lang.Class}).
      */
     protected String name;
 
@@ -60,15 +60,15 @@
     protected boolean restricted;
 
     /**
-     * <p>Controls whether the <code>getDynaProperty()</code> method returns
+     * <p>Controls whether the {@code getDynaProperty()} method returns
      * null if a property doesn't exist - or creates a new one.</p>
      *
-     * <p>Default is <code>false</code>.
+     * <p>Default is {@code false}.
      */
     protected boolean returnNull = false;
 
 
-    // ------------------- Constructors ----------------------------------
+    
 
     /**
      * Default Constructor.
@@ -78,7 +78,7 @@
     }
 
     /**
-     * Construct a new <code>LazyDynaMap</code> with the specified name.
+     * Construct a new {@code LazyDynaMap} with the specified name.
      *
      * @param name Name of this DynaBean class
      */
@@ -87,19 +87,19 @@
     }
 
     /**
-     * Construct a new <code>LazyDynaMap</code> with the specified <code>Map</code>.
+     * Construct a new {@code LazyDynaMap</code> with the specified <code>Map}.
      *
-     * @param values The Map backing this <code>LazyDynaMap</code>
+     * @param values The Map backing this {@code LazyDynaMap}
      */
     public LazyDynaMap(final Map<String, Object> values) {
         this(null, values);
     }
 
     /**
-     * Construct a new <code>LazyDynaMap</code> with the specified name and  <code>Map</code>.
+     * Construct a new {@code LazyDynaMap</code> with the specified name and  <code>Map}.
      *
      * @param name Name of this DynaBean class
-     * @param values The Map backing this <code>LazyDynaMap</code>
+     * @param values The Map backing this {@code LazyDynaMap}
      */
     public LazyDynaMap(final String name, final Map<String, Object> values) {
         this.name      = name   == null ? "LazyDynaMap" : name;
@@ -108,7 +108,7 @@
     }
 
     /**
-     * Construct a new <code>LazyDynaMap</code> with the specified properties.
+     * Construct a new {@code LazyDynaMap} with the specified properties.
      *
      * @param properties Property descriptors for the supported properties
      */
@@ -117,7 +117,7 @@
     }
 
     /**
-     * Construct a new <code>LazyDynaMap</code> with the specified name and properties.
+     * Construct a new {@code LazyDynaMap} with the specified name and properties.
      *
      * @param name Name of this DynaBean class
      * @param properties Property descriptors for the supported properties
@@ -132,7 +132,7 @@
     }
 
     /**
-     * Construct a new <code>LazyDynaMap</code> based on an exisiting DynaClass
+     * Construct a new {@code LazyDynaMap} based on an exisiting DynaClass
      *
      * @param dynaClass DynaClass to copy the name and properties from
      */
@@ -140,10 +140,10 @@
         this(dynaClass.getName(), dynaClass.getDynaProperties());
     }
 
-    // ------------------- Public Methods ----------------------------------
+    
 
     /**
-     * Set the Map backing this <code>DynaBean</code>
+     * Set the Map backing this {@code DynaBean}
      *
      * @param values The new Map of values
      */
@@ -152,7 +152,7 @@
     }
 
     /**
-     * Return the underlying Map backing this <code>DynaBean</code>
+     * Return the underlying Map backing this {@code DynaBean}
      * @return the underlying Map
      * @since 1.8.0
      */
@@ -161,7 +161,7 @@
         return values;
     }
 
-    // ------------------- DynaBean Methods ----------------------------------
+    
 
     /**
      * Set the value of a simple property with the specified name.
@@ -181,11 +181,11 @@
 
     }
 
-    // ------------------- DynaClass Methods ----------------------------------
+    
 
     /**
      * Return the name of this DynaClass (analogous to the
-     * <code>getName()</code> method of <code>java.lang.Class</code>)
+     * {@code getName()</code> method of <code>java.lang.Class})
      *
      * @return the name of the DynaClass
      */
@@ -197,18 +197,18 @@
     /**
      * <p>Return a property descriptor for the specified property.</p>
      *
-     * <p>If the property is not found and the <code>returnNull</code> indicator is
-     *    <code>true</code>, this method always returns <code>null</code>.</p>
+     * <p>If the property is not found and the {@code returnNull} indicator is
+     *    {@code true</code>, this method always returns <code>null}.</p>
      *
-     * <p>If the property is not found and the <code>returnNull</code> indicator is
-     *    <code>false</code> a new property descriptor is created and returned (although
+     * <p>If the property is not found and the {@code returnNull} indicator is
+     *    {@code false} a new property descriptor is created and returned (although
      *    its not actually added to the DynaClass's properties). This is the default
      *    behavior.</p>
      *
-     * <p>The reason for not returning a <code>null</code> property descriptor is that
-     *    <code>BeanUtils</code> uses this method to check if a property exists
+     * <p>The reason for not returning a {@code null} property descriptor is that
+     *    {@code BeanUtils} uses this method to check if a property exists
      *    before trying to set it - since these <i>Map</i> implementations automatically
-     *    add any new properties when they are set, returning <code>null</code> from
+     *    add any new properties when they are set, returning {@code null} from
      *    this method would defeat their purpose.</p>
      *
      * @param name Name of the dynamic property for which a descriptor
@@ -240,12 +240,12 @@
     }
 
     /**
-     * <p>Return an array of <code>ProperyDescriptors</code> for the properties
+     * <p>Return an array of {@code ProperyDescriptors} for the properties
      * currently defined in this DynaClass.  If no properties are defined, a
      * zero-length array will be returned.</p>
      *
      * <p><strong>FIXME</strong> - Should we really be implementing
-     * <code>getBeanInfo()</code> instead, which returns property descriptors
+     * {@code getBeanInfo()} instead, which returns property descriptors
      * and a bunch of other stuff?</p>
      * @return the set of properties for this DynaClass
      */
@@ -268,7 +268,7 @@
     /**
      * Instantiate and return a new DynaBean instance, associated
      * with this DynaClass.
-     * @return A new <code>DynaBean</code> instance
+     * @return A new {@code DynaBean} instance
      */
     @Override
     public DynaBean newInstance()  {
@@ -296,15 +296,15 @@
     }
 
 
-    // ------------------- MutableDynaClass Methods ----------------------------------
+    
 
     /**
      * <p>Is this DynaClass currently restricted.</p>
      * <p>If restricted, no changes to the existing registration of
      *  property names, data types, readability, or writeability are allowed.</p>
      *
-     * @return <code>true</code> if this Mutable {@link DynaClass} is restricted,
-     * otherwise <code>false</code>
+     * @return {@code true} if this Mutable {@link DynaClass} is restricted,
+     * otherwise {@code false}
      */
     @Override
     public boolean isRestricted() {
@@ -373,18 +373,18 @@
      * and writeability.</p>
      *
      * <p><strong>N.B.</strong>Support for readable/writeable properties has not been implemented
-     *    and this method always throws a <code>UnsupportedOperationException</code>.</p>
+     *    and this method always throws a {@code UnsupportedOperationException}.</p>
      *
      * <p>I'm not sure the intention of the original authors for this method, but it seems to
-     *    me that readable/writable should be attributes of the <code>DynaProperty</code> class
+     *    me that readable/writable should be attributes of the {@code DynaProperty} class
      *    (which they are not) and is the reason this method has not been implemented.</p>
      *
      * @param name Name of the new dynamic property
      * @param type Data type of the new dynamic property (null for no
      *  restrictions)
-     * @param readable Set to <code>true</code> if this property value
+     * @param readable Set to {@code true} if this property value
      *  should be readable
-     * @param writeable Set to <code>true</code> if this property value
+     * @param writeable Set to {@code true} if this property value
      *  should be writeable
      *
      * @throws UnsupportedOperationException anytime this method is called
@@ -437,48 +437,48 @@
     }
 
 
-    // ------------------- Additional Public Methods ----------------------------------
+    
 
     /**
-     * Should this DynaClass return a <code>null</code> from
-     * the <code>getDynaProperty(name)</code> method if the property
+     * Should this DynaClass return a {@code null} from
+     * the {@code getDynaProperty(name)} method if the property
      * doesn't exist.
      *
-     * @return <code>true</code> if a <code>null</code> {@link DynaProperty}
+     * @return {@code true</code> if a <code>null} {@link DynaProperty}
      * should be returned if the property doesn't exist, otherwise
-     * <code>false</code> if a new {@link DynaProperty} should be created.
+     * {@code false} if a new {@link DynaProperty} should be created.
      */
     public boolean isReturnNull() {
         return returnNull;
     }
 
     /**
-     * Set whether this DynaClass should return a <code>null</code> from
-     * the <code>getDynaProperty(name)</code> method if the property
+     * Set whether this DynaClass should return a {@code null} from
+     * the {@code getDynaProperty(name)} method if the property
      * doesn't exist.
      *
-     * @param returnNull <code>true</code> if a <code>null</code> {@link DynaProperty}
+     * @param returnNull {@code true</code> if a <code>null} {@link DynaProperty}
      * should be returned if the property doesn't exist, otherwise
-     * <code>false</code> if a new {@link DynaProperty} should be created.
+     * {@code false} if a new {@link DynaProperty} should be created.
      */
     public void setReturnNull(final boolean returnNull) {
         this.returnNull = returnNull;
     }
 
 
-    // ------------------- Protected Methods ----------------------------------
+    
 
    /**
      * <p>Indicate whether a property actually exists.</p>
      *
-     * <p><strong>N.B.</strong> Using <code>getDynaProperty(name) == null</code>
+     * <p><strong>N.B.</strong> Using {@code getDynaProperty(name) == null}
      * doesn't work in this implementation because that method might
      * return a DynaProperty if it doesn't exist (depending on the
-     * <code>returnNull</code> indicator).</p>
+     * {@code returnNull} indicator).</p>
      *
      * @param name Name of the dynamic property
-     * @return <code>true</code> if the property exists,
-     * otherwise <code>false</code>
+     * @return {@code true} if the property exists,
+     * otherwise {@code false}
      * @throws IllegalArgumentException if no property name is specified
      */
     @Override
diff --git a/src/main/java/org/apache/commons/beanutils2/MappedPropertyDescriptor.java b/src/main/java/org/apache/commons/beanutils2/MappedPropertyDescriptor.java
index 7248794..6b981f8 100644
--- a/src/main/java/org/apache/commons/beanutils2/MappedPropertyDescriptor.java
+++ b/src/main/java/org/apache/commons/beanutils2/MappedPropertyDescriptor.java
@@ -34,15 +34,15 @@
  * Such property values are typically stored in a Map collection.
  * For this class to work properly, a mapped value must have
  * getter and setter methods of the form
- * <p><code>get<strong>Property</strong>(String key)</code> and
- * <p><code>set<strong>Property</strong>(String key, Object value)</code>,
- * <p>where <code><strong>Property</strong></code> must be replaced
+ * <p>{@code get<strong>Property</strong>(String key)} and
+ * <p>{@code set<strong>Property</strong>(String key, Object value)},
+ * <p>where {@code <strong>Property</strong>} must be replaced
  * by the name of the property.
  * @see java.beans.PropertyDescriptor
  *
  */
 public class MappedPropertyDescriptor extends PropertyDescriptor {
-    // ----------------------------------------------------- Instance Variables
+    
 
     /**
      * The underlying data type of the property we are describing.
@@ -64,7 +64,7 @@
      */
     private static final Class<?>[] STRING_CLASS_PARAMETER = new Class[]{String.class};
 
-    // ----------------------------------------------------------- Constructors
+    
 
     /**
      * Constructs a MappedPropertyDescriptor for a property that follows
@@ -211,7 +211,7 @@
         findMappedPropertyType();
     }
 
-    // -------------------------------------------------------- Public Methods
+    
 
     /**
      * Gets the Class object for the property values.
@@ -273,7 +273,7 @@
         findMappedPropertyType();
     }
 
-    // ------------------------------------------------------- Private Methods
+    
 
     /**
      * Introspect our bean class to identify the corresponding getter
diff --git a/src/main/java/org/apache/commons/beanutils2/MethodUtils.java b/src/main/java/org/apache/commons/beanutils2/MethodUtils.java
index 78680a8..4725641 100644
--- a/src/main/java/org/apache/commons/beanutils2/MethodUtils.java
+++ b/src/main/java/org/apache/commons/beanutils2/MethodUtils.java
@@ -38,10 +38,10 @@
  * <h4>Accessing Public Methods In A Default Access Superclass</h4>
  * <p>There is an issue when invoking public methods contained in a default access superclass.
  * Reflection locates these methods fine and correctly assigns them as public.
- * However, an <code>IllegalAccessException</code> is thrown if the method is invoked.</p>
+ * However, an {@code IllegalAccessException} is thrown if the method is invoked.</p>
  *
- * <p><code>MethodUtils</code> contains a workaround for this situation.
- * It will attempt to call <code>setAccessible</code> on this method.
+ * <p>{@code MethodUtils} contains a workaround for this situation.
+ * It will attempt to call {@code setAccessible} on this method.
  * If this call succeeds, then the method can be invoked as normal.
  * This call will only succeed when the application has sufficient security privileges.
  * If this call fails then a warning will be logged and the method may fail.</p>
@@ -50,7 +50,7 @@
 
 public class MethodUtils {
 
-    // --------------------------------------------------------- Private Methods
+    
 
     /**
      * Only log warning about accessibility work around once.
@@ -103,14 +103,14 @@
     private static final Map<MethodDescriptor, Reference<Method>> cache = Collections
             .synchronizedMap(new WeakHashMap<MethodDescriptor, Reference<Method>>());
 
-    // --------------------------------------------------------- Public Methods
+    
 
     /**
      * Set whether methods should be cached for greater performance or not,
-     * default is <code>true</code>.
+     * default is {@code true}.
      *
-     * @param cacheMethods <code>true</code> if methods should be
-     * cached for greater performance, otherwise <code>false</code>
+     * @param cacheMethods {@code true} if methods should be
+     * cached for greater performance, otherwise {@code false}
      * @since 1.8.0
      */
     public static synchronized void setCacheMethods(final boolean cacheMethods) {
@@ -135,13 +135,13 @@
      * <p>Invoke a named method whose parameter type matches the object type.</p>
      *
      * <p>The behavior of this method is less deterministic
-     * than <code>invokeExactMethod()</code>.
+     * than {@code invokeExactMethod()}.
      * It loops through all methods with names that match
      * and then executes the first it finds with compatible parameters.</p>
      *
      * <p>This method supports calls to methods taking primitive parameters
-     * via passing in wrapping classes. So, for example, a <code>Boolean</code> class
-     * would match a <code>boolean</code> primitive.</p>
+     * via passing in wrapping classes. So, for example, a {@code Boolean} class
+     * would match a {@code boolean} primitive.</p>
      *
      * <p> This is a convenient wrapper for
      * {@link #invokeMethod(Object object,String methodName,Object [] args)}.
@@ -182,8 +182,8 @@
      * and then executes the first it finds with compatible parameters.</p>
      *
      * <p>This method supports calls to methods taking primitive parameters
-     * via passing in wrapping classes. So, for example, a <code>Boolean</code> class
-     * would match a <code>boolean</code> primitive.</p>
+     * via passing in wrapping classes. So, for example, a {@code Boolean} class
+     * would match a {@code boolean} primitive.</p>
      *
      * <p> This is a convenient wrapper for
      * {@link #invokeMethod(Object object,String methodName,Object [] args,Class[] parameterTypes)}.
@@ -232,8 +232,8 @@
      * and then executes the first it finds with compatible parameters.</p>
      *
      * <p>This method supports calls to methods taking primitive parameters
-     * via passing in wrapping classes. So, for example, a <code>Boolean</code> class
-     * would match a <code>boolean</code> primitive.</p>
+     * via passing in wrapping classes. So, for example, a {@code Boolean} class
+     * would match a {@code boolean} primitive.</p>
      *
      *
      * @param object invoke method on this object
@@ -317,7 +317,7 @@
      * types.</p>
      *
      * <p> This uses reflection to invoke the method obtained from a call to
-     * <code>getAccessibleMethod()</code>.</p>
+     * {@code getAccessibleMethod()}.</p>
      *
      * @param object invoke method on this object
      * @param methodName get method with this name
@@ -357,7 +357,7 @@
      * types given.</p>
      *
      * <p>This uses reflection to invoke the method obtained from a call to
-     * <code>getAccessibleMethod()</code>.</p>
+     * {@code getAccessibleMethod()}.</p>
      *
      * @param object invoke method on this object
      * @param methodName get method with this name
@@ -460,8 +460,8 @@
      * and then executes the first it finds with compatible parameters.</p>
      *
      * <p>This method supports calls to methods taking primitive parameters
-     * via passing in wrapping classes. So, for example, a <code>Boolean</code> class
-     * would match a <code>boolean</code> primitive.</p>
+     * via passing in wrapping classes. So, for example, a {@code Boolean} class
+     * would match a {@code boolean} primitive.</p>
      *
      * <p> This is a convenient wrapper for
      * {@link #invokeStaticMethod(Class objectClass,String methodName,Object [] args)}.
@@ -503,8 +503,8 @@
      * and then executes the first it finds with compatible parameters.</p>
      *
      * <p>This method supports calls to methods taking primitive parameters
-     * via passing in wrapping classes. So, for example, a <code>Boolean</code> class
-     * would match a <code>boolean</code> primitive.</p>
+     * via passing in wrapping classes. So, for example, a {@code Boolean} class
+     * would match a {@code boolean} primitive.</p>
      *
      * <p> This is a convenient wrapper for
      * {@link #invokeStaticMethod(Class objectClass,String methodName,Object [] args,Class[] parameterTypes)}.
@@ -554,8 +554,8 @@
      * and then executes the first it finds with compatible parameters.</p>
      *
      * <p>This method supports calls to methods taking primitive parameters
-     * via passing in wrapping classes. So, for example, a <code>Boolean</code> class
-     * would match a <code>boolean</code> primitive.</p>
+     * via passing in wrapping classes. So, for example, a {@code Boolean} class
+     * would match a {@code boolean} primitive.</p>
      *
      *
      * @param objectClass invoke static method on this class
@@ -687,8 +687,8 @@
     /**
      * <p>Return an accessible method (that is, one that can be invoked via
      * reflection) with given name and a single parameter.  If no such method
-     * can be found, return <code>null</code>.
-     * Basically, a convenience wrapper that constructs a <code>Class</code>
+     * can be found, return {@code null}.
+     * Basically, a convenience wrapper that constructs a {@code Class}
      * array for you.</p>
      *
      * @param clazz get method from this class
@@ -709,7 +709,7 @@
     /**
      * <p>Return an accessible method (that is, one that can be invoked via
      * reflection) with given name and parameters.  If no such method
-     * can be found, return <code>null</code>.
+     * can be found, return {@code null}.
      * This is just a convenient wrapper for
      * {@link #getAccessibleMethod(Method method)}.</p>
      *
@@ -743,7 +743,7 @@
     /**
      * <p>Return an accessible method (that is, one that can be invoked via
      * reflection) that implements the specified Method.  If no such method
-     * can be found, return <code>null</code>.</p>
+     * can be found, return {@code null}.</p>
      *
      * @param method The method that we wish to call
      * @return The accessible method
@@ -763,7 +763,7 @@
     /**
      * <p>Return an accessible method (that is, one that can be invoked via
      * reflection) that implements the specified Method.  If no such method
-     * can be found, return <code>null</code>.</p>
+     * can be found, return {@code null}.</p>
      *
      * @param clazz The class of the object
      * @param method The method that we wish to call
@@ -821,12 +821,12 @@
     }
 
 
-    // -------------------------------------------------------- Private Methods
+    
 
     /**
      * <p>Return an accessible method (that is, one that can be invoked via
      * reflection) by scanning through the superclasses. If no such method
-     * can be found, return <code>null</code>.</p>
+     * can be found, return {@code null}.</p>
      *
      * @param clazz Class to be checked
      * @param methodName Method name of the method we wish to call
@@ -853,7 +853,7 @@
      * <p>Return an accessible method (that is, one that can be invoked via
      * reflection) that implements the specified method, by scanning through
      * all implemented interfaces and subinterfaces.  If no such method
-     * can be found, return <code>null</code>.</p>
+     * can be found, return {@code null}.</p>
      *
      * <p> There isn't any good reason why this method must be private.
      * It is because there doesn't seem any reason why other classes should
@@ -925,7 +925,7 @@
      * #invokeMethod(Object object,String methodName,Object [] args,Class[] parameterTypes)}.
      *
      * <p>This method can match primitive parameter by passing in wrapper classes.
-     * For example, a <code>Boolean</code> will match a primitive <code>boolean</code>
+     * For example, a {@code Boolean</code> will match a primitive <code>boolean}
      * parameter.
      *
      * @param clazz find method in this class
@@ -1153,13 +1153,13 @@
      * <p>Determine whether a type can be used as a parameter in a method invocation.
      * This method handles primitive conversions correctly.</p>
      *
-     * <p>In order words, it will match a <code>Boolean</code> to a <code>boolean</code>,
-     * a <code>Long</code> to a <code>long</code>,
-     * a <code>Float</code> to a <code>float</code>,
-     * a <code>Integer</code> to a <code>int</code>,
-     * and a <code>Double</code> to a <code>double</code>.
+     * <p>In order words, it will match a {@code Boolean</code> to a <code>boolean},
+     * a {@code Long</code> to a <code>long},
+     * a {@code Float</code> to a <code>float},
+     * a {@code Integer</code> to a <code>int},
+     * and a {@code Double</code> to a <code>double}.
      * Now logic widening matches are allowed.
-     * For example, a <code>Long</code> will not match a <code>int</code>.
+     * For example, a {@code Long</code> will not match a <code>int}.
      *
      * @param parameterType the type of parameter accepted by the method
      * @param parameterization the type of parameter being tested
@@ -1186,7 +1186,7 @@
 
     /**
      * Gets the wrapper object class for the given primitive type class.
-     * For example, passing <code>boolean.class</code> returns <code>Boolean.class</code>
+     * For example, passing {@code boolean.class</code> returns <code>Boolean.class}
      * @param primitiveType the primitive type class for which a match is to be found
      * @return the wrapper type associated with the given primitive
      * or null if no match is found
@@ -1217,7 +1217,7 @@
 
     /**
      * Gets the class for the primitive type corresponding to the primitive wrapper class given.
-     * For example, an instance of <code>Boolean.class</code> returns a <code>boolean.class</code>.
+     * For example, an instance of {@code Boolean.class</code> returns a <code>boolean.class}.
      * @param wrapperType the
      * @return the primitive type class corresponding to the given wrapper class,
      * null if no match is found
diff --git a/src/main/java/org/apache/commons/beanutils2/MutableDynaClass.java b/src/main/java/org/apache/commons/beanutils2/MutableDynaClass.java
index d7bb812..1b6635c 100644
--- a/src/main/java/org/apache/commons/beanutils2/MutableDynaClass.java
+++ b/src/main/java/org/apache/commons/beanutils2/MutableDynaClass.java
@@ -22,7 +22,7 @@
 
 
 /**
- * <p>A specialized extension to <code>DynaClass</code> that allows properties
+ * <p>A specialized extension to {@code DynaClass} that allows properties
  * to be added or removed dynamically.</p>
  *
  * <p><strong>WARNING</strong> - No guarantees that this will be in the final
@@ -69,9 +69,9 @@
      * @param name Name of the new dynamic property
      * @param type Data type of the new dynamic property (null for no
      *  restrictions)
-     * @param readable Set to <code>true</code> if this property value
+     * @param readable Set to {@code true} if this property value
      *  should be readable
-     * @param writeable Set to <code>true</code> if this property value
+     * @param writeable Set to {@code true} if this property value
      *  should be writeable
      *
      * @throws IllegalArgumentException if name is null
@@ -87,8 +87,8 @@
      * existing registration of property names, data types, readability, or
      * writeability are allowed.
      *
-     * @return <code>true</code> if this Mutable {@link DynaClass} is restricted,
-     * otherwise <code>false</code>
+     * @return {@code true} if this Mutable {@link DynaClass} is restricted,
+     * otherwise {@code false}
      */
     public boolean isRestricted();
 
diff --git a/src/main/java/org/apache/commons/beanutils2/NestedNullException.java b/src/main/java/org/apache/commons/beanutils2/NestedNullException.java
index faa012f..c91e4c5 100644
--- a/src/main/java/org/apache/commons/beanutils2/NestedNullException.java
+++ b/src/main/java/org/apache/commons/beanutils2/NestedNullException.java
@@ -28,17 +28,17 @@
 
     private static final long serialVersionUID = 1L;
 
-    // --------------------------------------------------------- Constructors
+    
 
     /**
-     * Constructs a <code>NestedNullException</code> without a detail message.
+     * Constructs a {@code NestedNullException} without a detail message.
      */
     public NestedNullException() {
         super();
     }
 
     /**
-     * Constructs a <code>NestedNullException</code> without a detail message.
+     * Constructs a {@code NestedNullException} without a detail message.
      *
      * @param message the detail message explaining this exception
      */
diff --git a/src/main/java/org/apache/commons/beanutils2/PropertyUtils.java b/src/main/java/org/apache/commons/beanutils2/PropertyUtils.java
index a18178c..1066e0f 100644
--- a/src/main/java/org/apache/commons/beanutils2/PropertyUtils.java
+++ b/src/main/java/org/apache/commons/beanutils2/PropertyUtils.java
@@ -28,7 +28,7 @@
  * <p>Utility methods for using Java Reflection APIs to facilitate generic
  * property getter and setter operations on Java objects.</p>
  *
- * <p>The implementations for these methods are provided by <code>PropertyUtilsBean</code>.
+ * <p>The implementations for these methods are provided by {@code PropertyUtilsBean}.
  * For more details see {@link PropertyUtilsBean}.</p>
  *
  * @see PropertyUtilsBean
@@ -38,18 +38,18 @@
 public class PropertyUtils {
 
 
-    // ----------------------------------------------------- Manifest Constants
+    
 
 
 
 
 
-    // ------------------------------------------------------- Static Variables
+    
 
 
 
 
-    // --------------------------------------------------------- Public Methods
+    
 
 
     /**
@@ -57,7 +57,7 @@
      * loaded by any class loaders.  This is useful in cases where class
      * loaders are thrown away to implement class reloading.
      *
-     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
+     * <p>For more details see {@code PropertyUtilsBean}.</p>
      *
      * @see PropertyUtilsBean#clearDescriptors
      */
@@ -78,10 +78,10 @@
     }
 
     /**
-     * Adds a <code>BeanIntrospector</code>. This object is invoked when the
+     * Adds a {@code BeanIntrospector}. This object is invoked when the
      * property descriptors of a class need to be obtained.
      *
-     * @param introspector the <code>BeanIntrospector</code> to be added (must
+     * @param introspector the {@code BeanIntrospector} to be added (must
      *        not be <b>null</b>
      * @throws IllegalArgumentException if the argument is <b>null</b>
      * @since 1.9
@@ -91,10 +91,10 @@
     }
 
     /**
-     * Removes the specified <code>BeanIntrospector</code>.
+     * Removes the specified {@code BeanIntrospector}.
      *
-     * @param introspector the <code>BeanIntrospector</code> to be removed
-     * @return <b>true</b> if the <code>BeanIntrospector</code> existed and
+     * @param introspector the {@code BeanIntrospector} to be removed
+     * @return <b>true</b> if the {@code BeanIntrospector} existed and
      *         could be removed, <b>false</b> otherwise
      * @since 1.9
      */
@@ -107,17 +107,17 @@
      * <p>Copy property values from the "origin" bean to the "destination" bean
      * for all cases where the property names are the same (even though the
      * actual getter and setter methods might have been customized via
-     * <code>BeanInfo</code> classes).</p>
+     * {@code BeanInfo} classes).</p>
      *
-     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
+     * <p>For more details see {@code PropertyUtilsBean}.</p>
      *
      * @param dest Destination bean whose properties are modified
      * @param orig Origin bean whose properties are retrieved
      *
      * @throws IllegalAccessException if the caller does not have
      *  access to the property accessor method
-     * @throws IllegalArgumentException if the <code>dest</code> or
-     *  <code>orig</code> argument is null
+     * @throws IllegalArgumentException if the {@code dest} or
+     *  {@code orig} argument is null
      * @throws InvocationTargetException if the property accessor method
      *  throws an exception
      * @throws NoSuchMethodException if an accessor method for this
@@ -136,14 +136,14 @@
      * <p>Return the entire set of properties for which the specified bean
      * provides a read method.</p>
      *
-     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
+     * <p>For more details see {@code PropertyUtilsBean}.</p>
      *
      * @param bean Bean whose properties are to be extracted
      * @return The set of properties for the bean
      *
      * @throws IllegalAccessException if the caller does not have
      *  access to the property accessor method
-     * @throws IllegalArgumentException if <code>bean</code> is null
+     * @throws IllegalArgumentException if {@code bean} is null
      * @throws InvocationTargetException if the property accessor method
      *  throws an exception
      * @throws NoSuchMethodException if an accessor method for this
@@ -163,10 +163,10 @@
      * <p>Return the value of the specified indexed property of the specified
      * bean, with no type conversions.</p>
      *
-     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
+     * <p>For more details see {@code PropertyUtilsBean}.</p>
      *
      * @param bean Bean whose property is to be extracted
-     * @param name <code>propertyname[index]</code> of the property value
+     * @param name {@code propertyname[index]} of the property value
      *  to be extracted
      * @return the indexed property value
      *
@@ -174,8 +174,8 @@
      *  is outside the valid range for the underlying property
      * @throws IllegalAccessException if the caller does not have
      *  access to the property accessor method
-     * @throws IllegalArgumentException if <code>bean</code> or
-     *  <code>name</code> is null
+     * @throws IllegalArgumentException if {@code bean} or
+     *  {@code name} is null
      * @throws InvocationTargetException if the property accessor method
      *  throws an exception
      * @throws NoSuchMethodException if an accessor method for this
@@ -195,7 +195,7 @@
      * <p>Return the value of the specified indexed property of the specified
      * bean, with no type conversions.</p>
      *
-     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
+     * <p>For more details see {@code PropertyUtilsBean}.</p>
      *
      * @param bean Bean whose property is to be extracted
      * @param name Simple property name of the property value to be extracted
@@ -206,8 +206,8 @@
      *  is outside the valid range for the underlying property
      * @throws IllegalAccessException if the caller does not have
      *  access to the property accessor method
-     * @throws IllegalArgumentException if <code>bean</code> or
-     *  <code>name</code> is null
+     * @throws IllegalArgumentException if {@code bean} or
+     *  {@code name} is null
      * @throws InvocationTargetException if the property accessor method
      *  throws an exception
      * @throws NoSuchMethodException if an accessor method for this
@@ -227,10 +227,10 @@
      * <p>Return the value of the specified mapped property of the
      * specified bean, with no type conversions.</p>
      *
-     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
+     * <p>For more details see {@code PropertyUtilsBean}.</p>
      *
      * @param bean Bean whose property is to be extracted
-     * @param name <code>propertyname(key)</code> of the property value
+     * @param name {@code propertyname(key)} of the property value
      *  to be extracted
      * @return the mapped property value
      *
@@ -255,7 +255,7 @@
      * <p>Return the value of the specified mapped property of the specified
      * bean, with no type conversions.</p>
      *
-     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
+     * <p>For more details see {@code PropertyUtilsBean}.</p>
      *
      * @param bean Bean whose property is to be extracted
      * @param name Mapped property name of the property value to be extracted
@@ -283,7 +283,7 @@
     /**
      * <p>Return the mapped property descriptors for this bean class.</p>
      *
-     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
+     * <p>For more details see {@code PropertyUtilsBean}.</p>
      *
      * @param beanClass Bean class to be introspected
      * @return the mapped property descriptors
@@ -300,7 +300,7 @@
      * <p>Return the value of the (possibly nested) property of the specified
      * name, for the specified bean, with no type conversions.</p>
      *
-     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
+     * <p>For more details see {@code PropertyUtilsBean}.</p>
      *
      * @param bean Bean whose property is to be extracted
      * @param name Possibly nested name of the property to be extracted
@@ -308,8 +308,8 @@
      *
      * @throws IllegalAccessException if the caller does not have
      *  access to the property accessor method
-     * @throws IllegalArgumentException if <code>bean</code> or
-     *  <code>name</code> is null
+     * @throws IllegalArgumentException if {@code bean} or
+     *  {@code name} is null
      * @throws NestedNullException if a nested reference to a
      *  property returns null
      * @throws InvocationTargetException
@@ -332,7 +332,7 @@
      * no matter which property reference format is used, with no
      * type conversions.</p>
      *
-     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
+     * <p>For more details see {@code PropertyUtilsBean}.</p>
      *
      * @param bean Bean whose property is to be extracted
      * @param name Possibly indexed and/or nested name of the property
@@ -341,8 +341,8 @@
      *
      * @throws IllegalAccessException if the caller does not have
      *  access to the property accessor method
-     * @throws IllegalArgumentException if <code>bean</code> or
-     *  <code>name</code> is null
+     * @throws IllegalArgumentException if {@code bean} or
+     *  {@code name} is null
      * @throws InvocationTargetException if the property accessor method
      *  throws an exception
      * @throws NoSuchMethodException if an accessor method for this
@@ -360,10 +360,10 @@
 
     /**
      * <p>Retrieve the property descriptor for the specified property of the
-     * specified bean, or return <code>null</code> if there is no such
+     * specified bean, or return {@code null} if there is no such
      * descriptor.</p>
      *
-     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
+     * <p>For more details see {@code PropertyUtilsBean}.</p>
      *
      * @param bean Bean for which a property descriptor is requested
      * @param name Possibly indexed and/or nested name of the property for
@@ -372,8 +372,8 @@
      *
      * @throws IllegalAccessException if the caller does not have
      *  access to the property accessor method
-     * @throws IllegalArgumentException if <code>bean</code> or
-     *  <code>name</code> is null
+     * @throws IllegalArgumentException if {@code bean} or
+     *  {@code name} is null
      * @throws IllegalArgumentException if a nested reference to a
      *  property returns null
      * @throws InvocationTargetException if the property accessor method
@@ -397,11 +397,11 @@
      * introspecting and caching them the first time a particular bean class
      * is encountered.</p>
      *
-     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
+     * <p>For more details see {@code PropertyUtilsBean}.</p>
      *
      * @param beanClass Bean class for which property descriptors are requested
      * @return the property descriptors
-     * @throws IllegalArgumentException if <code>beanClass</code> is null
+     * @throws IllegalArgumentException if {@code beanClass} is null
      * @see PropertyUtilsBean#getPropertyDescriptors(Class)
      */
     public static PropertyDescriptor[]
@@ -417,11 +417,11 @@
      * introspecting and caching them the first time a particular bean class
      * is encountered.</p>
      *
-     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
+     * <p>For more details see {@code PropertyUtilsBean}.</p>
      *
      * @param bean Bean for which property descriptors are requested
      * @return the property descriptors
-     * @throws IllegalArgumentException if <code>bean</code> is null
+     * @throws IllegalArgumentException if {@code bean} is null
      * @see PropertyUtilsBean#getPropertyDescriptors(Object)
      */
     public static PropertyDescriptor[] getPropertyDescriptors(final Object bean) {
@@ -435,7 +435,7 @@
      * <p>Return the Java Class representing the property editor class that has
      * been registered for this property (if any).</p>
      *
-     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
+     * <p>For more details see {@code PropertyUtilsBean}.</p>
      *
      * @param bean Bean for which a property descriptor is requested
      * @param name Possibly indexed and/or nested name of the property for
@@ -444,8 +444,8 @@
      *
      * @throws IllegalAccessException if the caller does not have
      *  access to the property accessor method
-     * @throws IllegalArgumentException if <code>bean</code> or
-     *  <code>name</code> is null
+     * @throws IllegalArgumentException if {@code bean} or
+     *  {@code name} is null
      * @throws IllegalArgumentException if a nested reference to a
      *  property returns null
      * @throws InvocationTargetException if the property accessor method
@@ -465,10 +465,10 @@
 
     /**
      * <p>Return the Java Class representing the property type of the specified
-     * property, or <code>null</code> if there is no such property for the
+     * property, or {@code null} if there is no such property for the
      * specified bean.</p>
      *
-     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
+     * <p>For more details see {@code PropertyUtilsBean}.</p>
      *
      * @param bean Bean for which a property descriptor is requested
      * @param name Possibly indexed and/or nested name of the property for
@@ -477,8 +477,8 @@
      *
      * @throws IllegalAccessException if the caller does not have
      *  access to the property accessor method
-     * @throws IllegalArgumentException if <code>bean</code> or
-     *  <code>name</code> is null
+     * @throws IllegalArgumentException if {@code bean} or
+     *  {@code name} is null
      * @throws IllegalArgumentException if a nested reference to a
      *  property returns null
      * @throws InvocationTargetException if the property accessor method
@@ -497,9 +497,9 @@
 
     /**
      * <p>Return an accessible property getter method for this property,
-     * if there is one; otherwise return <code>null</code>.</p>
+     * if there is one; otherwise return {@code null}.</p>
      *
-     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
+     * <p>For more details see {@code PropertyUtilsBean}.</p>
      *
      * @param descriptor Property descriptor to return a getter for
      * @return The read method
@@ -516,7 +516,7 @@
      * <p>Return the value of the specified simple property of the specified
      * bean, with no type conversions.</p>
      *
-     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
+     * <p>For more details see {@code PropertyUtilsBean}.</p>
      *
      * @param bean Bean whose property is to be extracted
      * @param name Name of the property to be extracted
@@ -524,8 +524,8 @@
      *
      * @throws IllegalAccessException if the caller does not have
      *  access to the property accessor method
-     * @throws IllegalArgumentException if <code>bean</code> or
-     *  <code>name</code> is null
+     * @throws IllegalArgumentException if {@code bean} or
+     *  {@code name} is null
      * @throws IllegalArgumentException if the property name
      *  is nested or indexed
      * @throws InvocationTargetException if the property accessor method
@@ -545,9 +545,9 @@
 
     /**
      * <p>Return an accessible property setter method for this property,
-     * if there is one; otherwise return <code>null</code>.</p>
+     * if there is one; otherwise return {@code null}.</p>
      *
-     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
+     * <p>For more details see {@code PropertyUtilsBean}.</p>
      *
      * @param descriptor Property descriptor to return a setter for
      * @return The write method
@@ -561,19 +561,19 @@
 
 
     /**
-     * <p>Return <code>true</code> if the specified property name identifies
+     * <p>Return {@code true} if the specified property name identifies
      * a readable property on the specified bean; otherwise, return
-     * <code>false</code>.</p>
+     * {@code false}.</p>
      *
-     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
+     * <p>For more details see {@code PropertyUtilsBean}.</p>
      *
      * @param bean Bean to be examined (may be a {@link DynaBean}
      * @param name Property name to be evaluated
-     * @return <code>true</code> if the property is readable,
-     * otherwise <code>false</code>
+     * @return {@code true} if the property is readable,
+     * otherwise {@code false}
      *
-     * @throws IllegalArgumentException if <code>bean</code>
-     *  or <code>name</code> is <code>null</code>
+     * @throws IllegalArgumentException if {@code bean}
+     *  or {@code name</code> is <code>null}
      * @see PropertyUtilsBean#isReadable
      * @since BeanUtils 1.6
      */
@@ -584,19 +584,19 @@
 
 
     /**
-     * <p>Return <code>true</code> if the specified property name identifies
+     * <p>Return {@code true} if the specified property name identifies
      * a writeable property on the specified bean; otherwise, return
-     * <code>false</code>.</p>
+     * {@code false}.</p>
      *
-     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
+     * <p>For more details see {@code PropertyUtilsBean}.</p>
      *
      * @param bean Bean to be examined (may be a {@link DynaBean}
      * @param name Property name to be evaluated
-     * @return <code>true</code> if the property is writeable,
-     * otherwise <code>false</code>
+     * @return {@code true} if the property is writeable,
+     * otherwise {@code false}
      *
-     * @throws IllegalArgumentException if <code>bean</code>
-     *  or <code>name</code> is <code>null</code>
+     * @throws IllegalArgumentException if {@code bean}
+     *  or {@code name</code> is <code>null}
      * @see PropertyUtilsBean#isWriteable
      * @since BeanUtils 1.6
      */
@@ -610,10 +610,10 @@
      * <p>Sets the value of the specified indexed property of the specified
      * bean, with no type conversions.</p>
      *
-     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
+     * <p>For more details see {@code PropertyUtilsBean}.</p>
      *
      * @param bean Bean whose property is to be modified
-     * @param name <code>propertyname[index]</code> of the property value
+     * @param name {@code propertyname[index]} of the property value
      *  to be modified
      * @param value Value to which the specified property element
      *  should be set
@@ -622,8 +622,8 @@
      *  is outside the valid range for the underlying property
      * @throws IllegalAccessException if the caller does not have
      *  access to the property accessor method
-     * @throws IllegalArgumentException if <code>bean</code> or
-     *  <code>name</code> is null
+     * @throws IllegalArgumentException if {@code bean} or
+     *  {@code name} is null
      * @throws InvocationTargetException if the property accessor method
      *  throws an exception
      * @throws NoSuchMethodException if an accessor method for this
@@ -644,7 +644,7 @@
      * <p>Sets the value of the specified indexed property of the specified
      * bean, with no type conversions.</p>
      *
-     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
+     * <p>For more details see {@code PropertyUtilsBean}.</p>
      *
      * @param bean Bean whose property is to be set
      * @param name Simple property name of the property value to be set
@@ -655,8 +655,8 @@
      *  is outside the valid range for the underlying property
      * @throws IllegalAccessException if the caller does not have
      *  access to the property accessor method
-     * @throws IllegalArgumentException if <code>bean</code> or
-     *  <code>name</code> is null
+     * @throws IllegalArgumentException if {@code bean} or
+     *  {@code name} is null
      * @throws InvocationTargetException if the property accessor method
      *  throws an exception
      * @throws NoSuchMethodException if an accessor method for this
@@ -676,10 +676,10 @@
      * <p>Sets the value of the specified mapped property of the
      * specified bean, with no type conversions.</p>
      *
-     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
+     * <p>For more details see {@code PropertyUtilsBean}.</p>
      *
      * @param bean Bean whose property is to be set
-     * @param name <code>propertyname(key)</code> of the property value
+     * @param name {@code propertyname(key)} of the property value
      *  to be set
      * @param value The property value to be set
      *
@@ -704,7 +704,7 @@
      * <p>Sets the value of the specified mapped property of the specified
      * bean, with no type conversions.</p>
      *
-     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
+     * <p>For more details see {@code PropertyUtilsBean}.</p>
      *
      * @param bean Bean whose property is to be set
      * @param name Mapped property name of the property value to be set
@@ -732,7 +732,7 @@
      * <p>Sets the value of the (possibly nested) property of the specified
      * name, for the specified bean, with no type conversions.</p>
      *
-     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
+     * <p>For more details see {@code PropertyUtilsBean}.</p>
      *
      * @param bean Bean whose property is to be modified
      * @param name Possibly nested name of the property to be modified
@@ -740,8 +740,8 @@
      *
      * @throws IllegalAccessException if the caller does not have
      *  access to the property accessor method
-     * @throws IllegalArgumentException if <code>bean</code> or
-     *  <code>name</code> is null
+     * @throws IllegalArgumentException if {@code bean} or
+     *  {@code name} is null
      * @throws IllegalArgumentException if a nested reference to a
      *  property returns null
      * @throws InvocationTargetException if the property accessor method
@@ -764,7 +764,7 @@
      * no matter which property reference format is used, with no
      * type conversions.</p>
      *
-     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
+     * <p>For more details see {@code PropertyUtilsBean}.</p>
      *
      * @param bean Bean whose property is to be modified
      * @param name Possibly indexed and/or nested name of the property
@@ -773,8 +773,8 @@
      *
      * @throws IllegalAccessException if the caller does not have
      *  access to the property accessor method
-     * @throws IllegalArgumentException if <code>bean</code> or
-     *  <code>name</code> is null
+     * @throws IllegalArgumentException if {@code bean} or
+     *  {@code name} is null
      * @throws InvocationTargetException if the property accessor method
      *  throws an exception
      * @throws NoSuchMethodException if an accessor method for this
@@ -794,7 +794,7 @@
      * <p>Set the value of the specified simple property of the specified bean,
      * with no type conversions.</p>
      *
-     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
+     * <p>For more details see {@code PropertyUtilsBean}.</p>
      *
      * @param bean Bean whose property is to be modified
      * @param name Name of the property to be modified
@@ -802,8 +802,8 @@
      *
      * @throws IllegalAccessException if the caller does not have
      *  access to the property accessor method
-     * @throws IllegalArgumentException if <code>bean</code> or
-     *  <code>name</code> is null
+     * @throws IllegalArgumentException if {@code bean} or
+     *  {@code name} is null
      * @throws IllegalArgumentException if the property name is
      *  nested or indexed
      * @throws InvocationTargetException if the property accessor method
diff --git a/src/main/java/org/apache/commons/beanutils2/PropertyUtilsBean.java b/src/main/java/org/apache/commons/beanutils2/PropertyUtilsBean.java
index d8eece0..a5004b3 100644
--- a/src/main/java/org/apache/commons/beanutils2/PropertyUtilsBean.java
+++ b/src/main/java/org/apache/commons/beanutils2/PropertyUtilsBean.java
@@ -40,14 +40,14 @@
 /**
  * Utility methods for using Java Reflection APIs to facilitate generic
  * property getter and setter operations on Java objects.  Much of this
- * code was originally included in <code>BeanUtils</code>, but has been
+ * code was originally included in {@code BeanUtils}, but has been
  * separated because of the volume of code involved.
  * <p>
  * In general, the objects that are examined and modified using these
  * methods are expected to conform to the property getter and setter method
  * naming conventions described in the JavaBeans Specification (Version 1.0.1).
  * No data type conversions are performed, and there are no usage of any
- * <code>PropertyEditor</code> classes that have been registered, although
+ * {@code PropertyEditor} classes that have been registered, although
  * a convenient way to access the registered classes themselves is included.
  * <p>
  * For the purposes of this class, five formats for referencing a particular
@@ -56,31 +56,31 @@
  * and how they are resolved is now (since BeanUtils 1.8.0) controlled by
  * the configured {@link Resolver} implementation:
  * <ul>
- * <li><strong>Simple (<code>name</code>)</strong> - The specified
- *     <code>name</code> identifies an individual property of a particular
+ * <li><strong>Simple ({@code name})</strong> - The specified
+ *     {@code name} identifies an individual property of a particular
  *     JavaBean.  The name of the actual getter or setter method to be used
  *     is determined using standard JavaBeans instrospection, so that (unless
- *     overridden by a <code>BeanInfo</code> class, a property named "xyz"
- *     will have a getter method named <code>getXyz()</code> or (for boolean
- *     properties only) <code>isXyz()</code>, and a setter method named
- *     <code>setXyz()</code>.</li>
- * <li><strong>Nested (<code>name1.name2.name3</code>)</strong> The first
+ *     overridden by a {@code BeanInfo} class, a property named "xyz"
+ *     will have a getter method named {@code getXyz()} or (for boolean
+ *     properties only) {@code isXyz()}, and a setter method named
+ *     {@code setXyz()}.</li>
+ * <li><strong>Nested ({@code name1.name2.name3})</strong> The first
  *     name element is used to select a property getter, as for simple
  *     references above.  The object returned for this property is then
  *     consulted, using the same approach, for a property getter for a
- *     property named <code>name2</code>, and so on.  The property value that
+ *     property named {@code name2}, and so on.  The property value that
  *     is ultimately retrieved or modified is the one identified by the
  *     last name element.</li>
- * <li><strong>Indexed (<code>name[index]</code>)</strong> - The underlying
+ * <li><strong>Indexed ({@code name[index]})</strong> - The underlying
  *     property value is assumed to be an array, or this JavaBean is assumed
  *     to have indexed property getter and setter methods.  The appropriate
- *     (zero-relative) entry in the array is selected.  <code>List</code>
+ *     (zero-relative) entry in the array is selected.  {@code List}
  *     objects are now also supported for read/write.  You simply need to define
- *     a getter that returns the <code>List</code></li>
- * <li><strong>Mapped (<code>name(key)</code>)</strong> - The JavaBean
+ *     a getter that returns the {@code List}</li>
+ * <li><strong>Mapped ({@code name(key)})</strong> - The JavaBean
  *     is assumed to have an property getter and setter methods with an
- *     additional attribute of type <code>java.lang.String</code>.</li>
- * <li><strong>Combined (<code>name1.name2[index].name3(key)</code>)</strong> -
+ *     additional attribute of type {@code java.lang.String}.</li>
+ * <li><strong>Combined ({@code name1.name2[index].name3(key)})</strong> -
  *     Combining mapped, nested, and indexed references is also
  *     supported.</li>
  * </ul>
@@ -94,7 +94,7 @@
 
     private Resolver resolver = new DefaultResolver();
 
-    // --------------------------------------------------------- Class Methods
+    
 
     /**
      * Return the PropertyUtils bean instance.
@@ -104,7 +104,7 @@
         return BeanUtilsBean.getInstance().getPropertyUtils();
     }
 
-    // --------------------------------------------------------- Variables
+    
 
     /**
      * The cache of PropertyDescriptor arrays for beans we have already
@@ -122,7 +122,7 @@
     /** The list with BeanIntrospector objects. */
     private final List<BeanIntrospector> introspectors;
 
-    // ---------------------------------------------------------- Constructors
+    
 
     /** Base constructor */
     public PropertyUtilsBean() {
@@ -135,7 +135,7 @@
     }
 
 
-    // --------------------------------------------------------- Public Methods
+    
 
 
     /**
@@ -189,10 +189,10 @@
     }
 
     /**
-     * Adds a <code>BeanIntrospector</code>. This object is invoked when the
+     * Adds a {@code BeanIntrospector}. This object is invoked when the
      * property descriptors of a class need to be obtained.
      *
-     * @param introspector the <code>BeanIntrospector</code> to be added (must
+     * @param introspector the {@code BeanIntrospector} to be added (must
      *        not be <b>null</b>
      * @throws IllegalArgumentException if the argument is <b>null</b>
      * @since 1.9
@@ -206,10 +206,10 @@
     }
 
     /**
-     * Removes the specified <code>BeanIntrospector</code>.
+     * Removes the specified {@code BeanIntrospector}.
      *
-     * @param introspector the <code>BeanIntrospector</code> to be removed
-     * @return <b>true</b> if the <code>BeanIntrospector</code> existed and
+     * @param introspector the {@code BeanIntrospector} to be removed
+     * @return <b>true</b> if the {@code BeanIntrospector} existed and
      *         could be removed, <b>false</b> otherwise
      * @since 1.9
      */
@@ -235,12 +235,12 @@
      * <p>Copy property values from the "origin" bean to the "destination" bean
      * for all cases where the property names are the same (even though the
      * actual getter and setter methods might have been customized via
-     * <code>BeanInfo</code> classes).  No conversions are performed on the
+     * {@code BeanInfo} classes).  No conversions are performed on the
      * actual property values -- it is assumed that the values retrieved from
      * the origin bean are assignment-compatible with the types expected by
      * the destination bean.</p>
      *
-     * <p>If the origin "bean" is actually a <code>Map</code>, it is assumed
+     * <p>If the origin "bean" is actually a {@code Map}, it is assumed
      * to contain String-valued <strong>simple</strong> property names as the keys, pointing
      * at the corresponding property values that will be set in the destination
      * bean.<strong>Note</strong> that this method is intended to perform
@@ -255,8 +255,8 @@
      *
      * @throws IllegalAccessException if the caller does not have
      *  access to the property accessor method
-     * @throws IllegalArgumentException if the <code>dest</code> or
-     *  <code>orig</code> argument is null
+     * @throws IllegalArgumentException if the {@code dest} or
+     *  {@code orig} argument is null
      * @throws InvocationTargetException if the property accessor method
      *  throws an exception
      * @throws NoSuchMethodException if an accessor method for this
@@ -340,7 +340,7 @@
      * <p>Return the entire set of properties for which the specified bean
      * provides a read method.  This map contains the unconverted property
      * values for all properties for which a read method is provided
-     * (i.e. where the <code>getReadMethod()</code> returns non-null).</p>
+     * (i.e. where the {@code getReadMethod()} returns non-null).</p>
      *
      * <p><strong>FIXME</strong> - Does not account for mapped properties.</p>
      *
@@ -349,7 +349,7 @@
      *
      * @throws IllegalAccessException if the caller does not have
      *  access to the property accessor method
-     * @throws IllegalArgumentException if <code>bean</code> is null
+     * @throws IllegalArgumentException if {@code bean} is null
      * @throws InvocationTargetException if the property accessor method
      *  throws an exception
      * @throws NoSuchMethodException if an accessor method for this
@@ -389,12 +389,12 @@
      * Return the value of the specified indexed property of the specified
      * bean, with no type conversions.  The zero-relative index of the
      * required value must be included (in square brackets) as a suffix to
-     * the property name, or <code>IllegalArgumentException</code> will be
+     * the property name, or {@code IllegalArgumentException} will be
      * thrown.  In addition to supporting the JavaBeans specification, this
-     * method has been extended to support <code>List</code> objects as well.
+     * method has been extended to support {@code List} objects as well.
      *
      * @param bean Bean whose property is to be extracted
-     * @param name <code>propertyname[index]</code> of the property value
+     * @param name {@code propertyname[index]} of the property value
      *  to be extracted
      * @return the indexed property value
      *
@@ -402,8 +402,8 @@
      *  is outside the valid range for the underlying array or List
      * @throws IllegalAccessException if the caller does not have
      *  access to the property accessor method
-     * @throws IllegalArgumentException if <code>bean</code> or
-     *  <code>name</code> is null
+     * @throws IllegalArgumentException if {@code bean} or
+     *  {@code name} is null
      * @throws InvocationTargetException if the property accessor method
      *  throws an exception
      * @throws NoSuchMethodException if an accessor method for this
@@ -448,7 +448,7 @@
      * Return the value of the specified indexed property of the specified
      * bean, with no type conversions.  In addition to supporting the JavaBeans
      * specification, this method has been extended to support
-     * <code>List</code> objects as well.
+     * {@code List} objects as well.
      *
      * @param bean Bean whose property is to be extracted
      * @param name Simple property name of the property value to be extracted
@@ -459,8 +459,8 @@
      *  is outside the valid range for the underlying property
      * @throws IllegalAccessException if the caller does not have
      *  access to the property accessor method
-     * @throws IllegalArgumentException if <code>bean</code> or
-     *  <code>name</code> is null
+     * @throws IllegalArgumentException if {@code bean} or
+     *  {@code name} is null
      * @throws InvocationTargetException if the property accessor method
      *  throws an exception
      * @throws NoSuchMethodException if an accessor method for this
@@ -559,11 +559,11 @@
      * Return the value of the specified mapped property of the
      * specified bean, with no type conversions.  The key of the
      * required value must be included (in brackets) as a suffix to
-     * the property name, or <code>IllegalArgumentException</code> will be
+     * the property name, or {@code IllegalArgumentException} will be
      * thrown.
      *
      * @param bean Bean whose property is to be extracted
-     * @param name <code>propertyname(key)</code> of the property value
+     * @param name {@code propertyname(key)} of the property value
      *  to be extracted
      * @return the mapped property value
      *
@@ -744,8 +744,8 @@
      *
      * @throws IllegalAccessException if the caller does not have
      *  access to the property accessor method
-     * @throws IllegalArgumentException if <code>bean</code> or
-     *  <code>name</code> is null
+     * @throws IllegalArgumentException if {@code bean} or
+     *  {@code name} is null
      * @throws NestedNullException if a nested reference to a
      *  property returns null
      * @throws InvocationTargetException
@@ -859,8 +859,8 @@
      *
      * @throws IllegalAccessException if the caller does not have
      *  access to the property accessor method
-     * @throws IllegalArgumentException if <code>bean</code> or
-     *  <code>name</code> is null
+     * @throws IllegalArgumentException if {@code bean} or
+     *  {@code name} is null
      * @throws InvocationTargetException if the property accessor method
      *  throws an exception
      * @throws NoSuchMethodException if an accessor method for this
@@ -877,7 +877,7 @@
 
     /**
      * <p>Retrieve the property descriptor for the specified property of the
-     * specified bean, or return <code>null</code> if there is no such
+     * specified bean, or return {@code null} if there is no such
      * descriptor.  This method resolves indexed and nested property
      * references in the same manner as other methods in this class, except
      * that if the last (or only) name element is indexed, the descriptor
@@ -896,8 +896,8 @@
      *
      * @throws IllegalAccessException if the caller does not have
      *  access to the property accessor method
-     * @throws IllegalArgumentException if <code>bean</code> or
-     *  <code>name</code> is null
+     * @throws IllegalArgumentException if {@code bean} or
+     *  {@code name} is null
      * @throws IllegalArgumentException if a nested reference to a
      *  property returns null
      * @throws InvocationTargetException if the property accessor method
@@ -982,7 +982,7 @@
      * @param beanClass Bean class for which property descriptors are requested
      * @return the property descriptors
      *
-     * @throws IllegalArgumentException if <code>beanClass</code> is null
+     * @throws IllegalArgumentException if {@code beanClass} is null
      */
     public PropertyDescriptor[]
             getPropertyDescriptors(final Class<?> beanClass) {
@@ -1001,7 +1001,7 @@
      * @param bean Bean for which property descriptors are requested
      * @return the property descriptors
      *
-     * @throws IllegalArgumentException if <code>bean</code> is null
+     * @throws IllegalArgumentException if {@code bean} is null
      */
     public PropertyDescriptor[] getPropertyDescriptors(final Object bean) {
 
@@ -1016,11 +1016,11 @@
     /**
      * <p>Return the Java Class repesenting the property editor class that has
      * been registered for this property (if any).  This method follows the
-     * same name resolution rules used by <code>getPropertyDescriptor()</code>,
+     * same name resolution rules used by {@code getPropertyDescriptor()},
      * so if the last element of a name reference is indexed, the property
      * editor for the underlying property's class is returned.</p>
      *
-     * <p>Note that <code>null</code> will be returned if there is no property,
+     * <p>Note that {@code null} will be returned if there is no property,
      * or if there is no registered property editor class.  Because this
      * return value is ambiguous, you should determine the existence of the
      * property itself by other means.</p>
@@ -1034,8 +1034,8 @@
      *
      * @throws IllegalAccessException if the caller does not have
      *  access to the property accessor method
-     * @throws IllegalArgumentException if <code>bean</code> or
-     *  <code>name</code> is null
+     * @throws IllegalArgumentException if {@code bean} or
+     *  {@code name} is null
      * @throws IllegalArgumentException if a nested reference to a
      *  property returns null
      * @throws InvocationTargetException if the property accessor method
@@ -1067,14 +1067,14 @@
 
     /**
      * Return the Java Class representing the property type of the specified
-     * property, or <code>null</code> if there is no such property for the
+     * property, or {@code null} if there is no such property for the
      * specified bean.  This method follows the same name resolution rules
-     * used by <code>getPropertyDescriptor()</code>, so if the last element
+     * used by {@code getPropertyDescriptor()}, so if the last element
      * of a name reference is indexed, the type of the property itself will
      * be returned.  If the last (or only) element has no property with the
-     * specified name, <code>null</code> is returned.
+     * specified name, {@code null} is returned.
      * <p>
-     * If the property is an indexed property (e.g. <code>String[]</code>),
+     * If the property is an indexed property (e.g. {@code String[]}),
      * this method will return the type of the items within that array.
      * Note that from Java 8 and newer, this method do not support
      * such index types from items within an Collection, and will
@@ -1088,8 +1088,8 @@
      *
      * @throws IllegalAccessException if the caller does not have
      *  access to the property accessor method
-     * @throws IllegalArgumentException if <code>bean</code> or
-     *  <code>name</code> is null
+     * @throws IllegalArgumentException if {@code bean} or
+     *  {@code name} is null
      * @throws IllegalArgumentException if a nested reference to a
      *  property returns null
      * @throws InvocationTargetException if the property accessor method
@@ -1161,7 +1161,7 @@
 
     /**
      * <p>Return an accessible property getter method for this property,
-     * if there is one; otherwise return <code>null</code>.</p>
+     * if there is one; otherwise return {@code null}.</p>
      *
      * <p><strong>FIXME</strong> - Does not work with DynaBeans.</p>
      *
@@ -1177,7 +1177,7 @@
 
     /**
      * <p>Return an accessible property getter method for this property,
-     * if there is one; otherwise return <code>null</code>.</p>
+     * if there is one; otherwise return {@code null}.</p>
      *
      * <p><strong>FIXME</strong> - Does not work with DynaBeans.</p>
      *
@@ -1200,8 +1200,8 @@
      *
      * @throws IllegalAccessException if the caller does not have
      *  access to the property accessor method
-     * @throws IllegalArgumentException if <code>bean</code> or
-     *  <code>name</code> is null
+     * @throws IllegalArgumentException if {@code bean} or
+     *  {@code name} is null
      * @throws IllegalArgumentException if the property name
      *  is nested or indexed
      * @throws InvocationTargetException if the property accessor method
@@ -1270,7 +1270,7 @@
 
     /**
      * <p>Return an accessible property setter method for this property,
-     * if there is one; otherwise return <code>null</code>.</p>
+     * if there is one; otherwise return {@code null}.</p>
      *
      * <p><em>Note:</em> This method does not work correctly with custom bean
      * introspection under certain circumstances. It may return {@code null}
@@ -1291,7 +1291,7 @@
 
     /**
      * <p>Return an accessible property setter method for this property,
-     * if there is one; otherwise return <code>null</code>.</p>
+     * if there is one; otherwise return {@code null}.</p>
      *
      * <p><strong>FIXME</strong> - Does not work with DynaBeans.</p>
      *
@@ -1308,17 +1308,17 @@
 
 
     /**
-     * <p>Return <code>true</code> if the specified property name identifies
+     * <p>Return {@code true} if the specified property name identifies
      * a readable property on the specified bean; otherwise, return
-     * <code>false</code>.
+     * {@code false}.
      *
      * @param bean Bean to be examined (may be a {@link DynaBean}
      * @param name Property name to be evaluated
-     * @return <code>true</code> if the property is readable,
-     * otherwise <code>false</code>
+     * @return {@code true} if the property is readable,
+     * otherwise {@code false}
      *
-     * @throws IllegalArgumentException if <code>bean</code>
-     *  or <code>name</code> is <code>null</code>
+     * @throws IllegalArgumentException if {@code bean}
+     *  or {@code name</code> is <code>null}
      *
      * @since BeanUtils 1.6
      */
@@ -1397,17 +1397,17 @@
 
 
     /**
-     * <p>Return <code>true</code> if the specified property name identifies
+     * <p>Return {@code true} if the specified property name identifies
      * a writeable property on the specified bean; otherwise, return
-     * <code>false</code>.
+     * {@code false}.
      *
      * @param bean Bean to be examined (may be a {@link DynaBean}
      * @param name Property name to be evaluated
-     * @return <code>true</code> if the property is writeable,
-     * otherwise <code>false</code>
+     * @return {@code true} if the property is writeable,
+     * otherwise {@code false}
      *
-     * @throws IllegalArgumentException if <code>bean</code>
-     *  or <code>name</code> is <code>null</code>
+     * @throws IllegalArgumentException if {@code bean}
+     *  or {@code name</code> is <code>null}
      *
      * @since BeanUtils 1.6
      */
@@ -1489,12 +1489,12 @@
      * Set the value of the specified indexed property of the specified
      * bean, with no type conversions.  The zero-relative index of the
      * required value must be included (in square brackets) as a suffix to
-     * the property name, or <code>IllegalArgumentException</code> will be
+     * the property name, or {@code IllegalArgumentException} will be
      * thrown.  In addition to supporting the JavaBeans specification, this
-     * method has been extended to support <code>List</code> objects as well.
+     * method has been extended to support {@code List} objects as well.
      *
      * @param bean Bean whose property is to be modified
-     * @param name <code>propertyname[index]</code> of the property value
+     * @param name {@code propertyname[index]} of the property value
      *  to be modified
      * @param value Value to which the specified property element
      *  should be set
@@ -1503,8 +1503,8 @@
      *  is outside the valid range for the underlying property
      * @throws IllegalAccessException if the caller does not have
      *  access to the property accessor method
-     * @throws IllegalArgumentException if <code>bean</code> or
-     *  <code>name</code> is null
+     * @throws IllegalArgumentException if {@code bean} or
+     *  {@code name} is null
      * @throws InvocationTargetException if the property accessor method
      *  throws an exception
      * @throws NoSuchMethodException if an accessor method for this
@@ -1549,7 +1549,7 @@
      * Set the value of the specified indexed property of the specified
      * bean, with no type conversions.  In addition to supporting the JavaBeans
      * specification, this method has been extended to support
-     * <code>List</code> objects as well.
+     * {@code List} objects as well.
      *
      * @param bean Bean whose property is to be set
      * @param name Simple property name of the property value to be set
@@ -1560,8 +1560,8 @@
      *  is outside the valid range for the underlying property
      * @throws IllegalAccessException if the caller does not have
      *  access to the property accessor method
-     * @throws IllegalArgumentException if <code>bean</code> or
-     *  <code>name</code> is null
+     * @throws IllegalArgumentException if {@code bean} or
+     *  {@code name} is null
      * @throws InvocationTargetException if the property accessor method
      *  throws an exception
      * @throws NoSuchMethodException if an accessor method for this
@@ -1672,11 +1672,11 @@
      * Set the value of the specified mapped property of the
      * specified bean, with no type conversions.  The key of the
      * value to set must be included (in brackets) as a suffix to
-     * the property name, or <code>IllegalArgumentException</code> will be
+     * the property name, or {@code IllegalArgumentException} will be
      * thrown.
      *
      * @param bean Bean whose property is to be set
-     * @param name <code>propertyname(key)</code> of the property value
+     * @param name {@code propertyname(key)} of the property value
      *  to be set
      * @param value The property value to be set
      *
@@ -1842,8 +1842,8 @@
      *
      * @throws IllegalAccessException if the caller does not have
      *  access to the property accessor method
-     * @throws IllegalArgumentException if <code>bean</code> or
-     *  <code>name</code> is null
+     * @throws IllegalArgumentException if {@code bean} or
+     *  {@code name} is null
      * @throws IllegalArgumentException if a nested reference to a
      *  property returns null
      * @throws InvocationTargetException if the property accessor method
@@ -1989,8 +1989,8 @@
      *
      * @throws IllegalAccessException if the caller does not have
      *  access to the property accessor method
-     * @throws IllegalArgumentException if <code>bean</code> or
-     *  <code>name</code> is null
+     * @throws IllegalArgumentException if {@code bean} or
+     *  {@code name} is null
      * @throws InvocationTargetException if the property accessor method
      *  throws an exception
      * @throws NoSuchMethodException if an accessor method for this
@@ -2015,8 +2015,8 @@
      *
      * @throws IllegalAccessException if the caller does not have
      *  access to the property accessor method
-     * @throws IllegalArgumentException if <code>bean</code> or
-     *  <code>name</code> is null
+     * @throws IllegalArgumentException if {@code bean} or
+     *  {@code name} is null
      * @throws IllegalArgumentException if the property name is
      *  nested or indexed
      * @throws InvocationTargetException if the property accessor method
diff --git a/src/main/java/org/apache/commons/beanutils2/ResultSetDynaClass.java b/src/main/java/org/apache/commons/beanutils2/ResultSetDynaClass.java
index 5418a0a..cbba54e 100644
--- a/src/main/java/org/apache/commons/beanutils2/ResultSetDynaClass.java
+++ b/src/main/java/org/apache/commons/beanutils2/ResultSetDynaClass.java
@@ -25,8 +25,8 @@
 
 
 /**
- * <p>Implementation of <code>DynaClass</code> for DynaBeans that wrap the
- * <code>java.sql.Row</code> objects of a <code>java.sql.ResultSet</code>.
+ * <p>Implementation of {@code DynaClass} for DynaBeans that wrap the
+ * {@code java.sql.Row</code> objects of a <code>java.sql.ResultSet}.
  * The normal usage pattern is something like:</p>
  * <pre>
  *   ResultSet rs = ...;
@@ -44,8 +44,8 @@
  * for portability).</p>
  *
  * <p><strong>WARNING</strong> - Any {@link DynaBean} instance returned by
- * this class, or from the <code>Iterator</code> returned by the
- * <code>iterator()</code> method, is directly linked to the row that the
+ * this class, or from the {@code Iterator} returned by the
+ * {@code iterator()} method, is directly linked to the row that the
  * underlying result set is currently positioned at.  This has the following
  * implications:</p>
  * <ul>
@@ -83,17 +83,17 @@
 
     private static final long serialVersionUID = 1L;
 
-    // ----------------------------------------------------------- Constructors
+    
 
     /**
      * <p>Construct a new ResultSetDynaClass for the specified
-     * <code>ResultSet</code>.  The property names corresponding
+     * {@code ResultSet}.  The property names corresponding
      * to column names in the result set will be lower cased.</p>
      *
      * @param resultSet The result set to be wrapped
      *
-     * @throws NullPointerException if <code>resultSet</code>
-     *  is <code>null</code>
+     * @throws NullPointerException if {@code resultSet}
+     *  is {@code null}
      * @throws SQLException if the metadata for this result set
      *  cannot be introspected
      */
@@ -106,12 +106,12 @@
 
     /**
      * <p>Construct a new ResultSetDynaClass for the specified
-     * <code>ResultSet</code>.  The property names corresponding
+     * {@code ResultSet}.  The property names corresponding
      * to the column names in the result set will be lower cased or not,
-     * depending on the specified <code>lowerCase</code> value.</p>
+     * depending on the specified {@code lowerCase} value.</p>
      *
-     * <p><strong>WARNING</strong> - If you specify <code>false</code>
-     * for <code>lowerCase</code>, the returned property names will
+     * <p><strong>WARNING</strong> - If you specify {@code false}
+     * for {@code lowerCase}, the returned property names will
      * exactly match the column names returned by your JDBC driver.
      * Because different drivers might return column names in different
      * cases, the property names seen by your application will vary
@@ -120,8 +120,8 @@
      * @param resultSet The result set to be wrapped
      * @param lowerCase Should property names be lower cased?
      *
-     * @throws NullPointerException if <code>resultSet</code>
-     *  is <code>null</code>
+     * @throws NullPointerException if {@code resultSet}
+     *  is {@code null}
      * @throws SQLException if the metadata for this result set
      *  cannot be introspected
      */
@@ -135,12 +135,12 @@
 
     /**
      * <p>Construct a new ResultSetDynaClass for the specified
-     * <code>ResultSet</code>.  The property names corresponding
+     * {@code ResultSet}.  The property names corresponding
      * to the column names in the result set will be lower cased or not,
-     * depending on the specified <code>lowerCase</code> value.</p>
+     * depending on the specified {@code lowerCase} value.</p>
      *
-     * <p><strong>WARNING</strong> - If you specify <code>false</code>
-     * for <code>lowerCase</code>, the returned property names will
+     * <p><strong>WARNING</strong> - If you specify {@code false}
+     * for {@code lowerCase}, the returned property names will
      * exactly match the column names returned by your JDBC driver.
      * Because different drivers might return column names in different
      * cases, the property names seen by your application will vary
@@ -150,8 +150,8 @@
      * @param lowerCase Should property names be lower cased?
      * @param useColumnLabel true if the column label should be used, otherwise false
      *
-     * @throws NullPointerException if <code>resultSet</code>
-     *  is <code>null</code>
+     * @throws NullPointerException if {@code resultSet}
+     *  is {@code null}
      * @throws SQLException if the metadata for this result set
      *  cannot be introspected
      * @since 1.8.3
@@ -170,24 +170,24 @@
     }
 
 
-    // ----------------------------------------------------- Instance Variables
+    
 
 
     /**
-     * <p>The <code>ResultSet</code> we are wrapping.</p>
+     * <p>The {@code ResultSet} we are wrapping.</p>
      */
     protected ResultSet resultSet = null;
 
 
-    // --------------------------------------------------------- Public Methods
+    
 
 
     /**
-     * <p>Return an <code>Iterator</code> of {@link DynaBean} instances for
-     * each row of the wrapped <code>ResultSet</code>, in "forward" order.
+     * <p>Return an {@code Iterator} of {@link DynaBean} instances for
+     * each row of the wrapped {@code ResultSet}, in "forward" order.
      * Unless the underlying result set supports scrolling, this method
      * should be called only once.</p>
-     * @return An <code>Iterator</code> of {@link DynaBean} instances
+     * @return An {@code Iterator} of {@link DynaBean} instances
      */
     public Iterator<DynaBean> iterator() {
 
@@ -209,7 +209,7 @@
         return getObject(getResultSet(), name);
     }
 
-    // -------------------------------------------------------- Package Methods
+    
 
 
     /**
@@ -222,7 +222,7 @@
     }
 
 
-    // ------------------------------------------------------ Protected Methods
+    
 
     /**
      * <p>Loads the class of the given name which by default uses the class loader used
diff --git a/src/main/java/org/apache/commons/beanutils2/ResultSetIterator.java b/src/main/java/org/apache/commons/beanutils2/ResultSetIterator.java
index 7e55378..8f538b3 100644
--- a/src/main/java/org/apache/commons/beanutils2/ResultSetIterator.java
+++ b/src/main/java/org/apache/commons/beanutils2/ResultSetIterator.java
@@ -25,8 +25,8 @@
 
 
 /**
- * <p>Implementation of <code>java.util.Iterator</code> returned by the
- * <code>iterator()</code> method of {@link ResultSetDynaClass}.  Each
+ * <p>Implementation of {@code java.util.Iterator} returned by the
+ * {@code iterator()} method of {@link ResultSetDynaClass}.  Each
  * object returned by this iterator will be a {@link DynaBean} that
  * represents a single row from the result set being wrapped.</p>
  *
@@ -35,11 +35,11 @@
 public class ResultSetIterator implements DynaBean, Iterator<DynaBean> {
 
 
-    // ------------------------------------------------------------ Constructor
+    
 
 
     /**
-     * <p>Construct an <code>Iterator</code> for the result set being wrapped
+     * <p>Construct an {@code Iterator} for the result set being wrapped
      * by the specified {@link ResultSetDynaClass}.</p>
      *
      * @param dynaClass The {@link ResultSetDynaClass} wrapping the
@@ -52,7 +52,7 @@
     }
 
 
-    // ----------------------------------------------------- Instance Variables
+    
 
 
 
@@ -76,7 +76,7 @@
     protected boolean eof = false;
 
 
-    // ------------------------------------------------------- DynaBean Methods
+    
 
 
     /**
@@ -85,8 +85,8 @@
      *
      * @param name Name of the property to check
      * @param key Name of the key to check
-     * @return <code>true</code> if the mapped property contains a value for
-     * the specified key, otherwise <code>false</code>
+     * @return {@code true} if the mapped property contains a value for
+     * the specified key, otherwise {@code false}
      *
      * @throws IllegalArgumentException if there is no property
      *  of the specified name
@@ -152,7 +152,7 @@
 
     /**
      * Return the value of a mapped property with the specified name,
-     * or <code>null</code> if there is no value for the specified key.
+     * or {@code null} if there is no value for the specified key.
      *
      * @param name Name of the property whose value is to be retrieved
      * @param key Key of the value to be retrieved
@@ -173,7 +173,7 @@
 
 
     /**
-     * Return the <code>DynaClass</code> instance that describes the set of
+     * Return the {@code DynaClass} instance that describes the set of
      * properties available for this DynaBean.
      *
      * @return The associated DynaClass
@@ -283,14 +283,14 @@
     }
 
 
-    // ------------------------------------------------------- Iterator Methods
+    
 
 
     /**
-     * <p>Return <code>true</code> if the iteration has more elements.</p>
+     * <p>Return {@code true} if the iteration has more elements.</p>
      *
-     * @return <code>true</code> if the result set has another
-     * row, otherwise <code>false</code>
+     * @return {@code true} if the result set has another
+     * row, otherwise {@code false}
      */
     @Override
     public boolean hasNext() {
@@ -339,7 +339,7 @@
     }
 
 
-    // ------------------------------------------------------ Protected Methods
+    
 
 
     /**
diff --git a/src/main/java/org/apache/commons/beanutils2/RowSetDynaClass.java b/src/main/java/org/apache/commons/beanutils2/RowSetDynaClass.java
index ce88ba0..72c992d 100644
--- a/src/main/java/org/apache/commons/beanutils2/RowSetDynaClass.java
+++ b/src/main/java/org/apache/commons/beanutils2/RowSetDynaClass.java
@@ -28,9 +28,9 @@
 /**
  * <p>Implementation of {@link DynaClass} that creates an in-memory collection
  * of {@link DynaBean}s representing the results of an SQL query.  Once the
- * {@link DynaClass} instance has been created, the JDBC <code>ResultSet</code>
- * and <code>Statement</code> on which it is based can be closed, and the
- * underlying <code>Connection</code> can be returned to its connection pool
+ * {@link DynaClass} instance has been created, the JDBC {@code ResultSet}
+ * and {@code Statement} on which it is based can be closed, and the
+ * underlying {@code Connection} can be returned to its connection pool
  * (if you are using one).</p>
  *
  * <p>The normal usage pattern is something like:</p>
@@ -49,14 +49,14 @@
  * <p>Each column in the result set will be represented as a {@link DynaBean}
  * property of the corresponding name (optionally forced to lower case
  * for portability).  There will be one {@link DynaBean} in the
- * <code>List</code> returned by <code>getRows()</code> for each
- * row in the original <code>ResultSet</code>.</p>
+ * {@code List</code> returned by <code>getRows()} for each
+ * row in the original {@code ResultSet}.</p>
  *
  * <p>In general, instances of {@link RowSetDynaClass} can be serialized
  * and deserialized, which will automatically include the list of
  * {@link DynaBean}s representing the data content.  The only exception
  * to this rule would be when the underlying property values that were
- * copied from the <code>ResultSet</code> originally cannot themselves
+ * copied from the {@code ResultSet} originally cannot themselves
  * be serialized.  Therefore, a {@link RowSetDynaClass} makes a very
  * convenient mechanism for transporting data sets to remote Java-based
  * application components.</p>
@@ -67,34 +67,34 @@
 
     private static final long serialVersionUID = 1L;
 
-    // ----------------------------------------------------- Instance variables
+    
 
     /**
      * <p>Limits the size of the returned list.  The call to
-     * <code>getRows()</code> will return at most limit number of rows.
+     * {@code getRows()} will return at most limit number of rows.
      * If less than or equal to 0, does not limit the size of the result.
      */
     protected int limit = -1;
 
     /**
      * <p>The list of {@link DynaBean}s representing the contents of
-     * the original <code>ResultSet</code> on which this
+     * the original {@code ResultSet} on which this
      * {@link RowSetDynaClass} was based.</p>
      */
     protected List<DynaBean> rows = new ArrayList<>();
 
-    // ----------------------------------------------------------- Constructors
+    
 
 
     /**
      * <p>Construct a new {@link RowSetDynaClass} for the specified
-     * <code>ResultSet</code>.  The property names corresponding
+     * {@code ResultSet}.  The property names corresponding
      * to column names in the result set will be lower cased.</p>
      *
      * @param resultSet The result set to be wrapped
      *
-     * @throws NullPointerException if <code>resultSet</code>
-     *  is <code>null</code>
+     * @throws NullPointerException if {@code resultSet}
+     *  is {@code null}
      * @throws SQLException if the metadata for this result set
      *  cannot be introspected
      */
@@ -106,17 +106,17 @@
 
     /**
      * <p>Construct a new {@link RowSetDynaClass} for the specified
-     * <code>ResultSet</code>.  The property names corresponding
+     * {@code ResultSet}.  The property names corresponding
      * to column names in the result set will be lower cased.</p>
      *
-     * If <code>limit</code> is not less than 0, max <code>limit</code>
+     * If {@code limit</code> is not less than 0, max <code>limit}
      * number of rows will be copied into the list.
      *
      * @param resultSet The result set to be wrapped
      * @param limit The maximum for the size of the result.
      *
-     * @throws NullPointerException if <code>resultSet</code>
-     *  is <code>null</code>
+     * @throws NullPointerException if {@code resultSet}
+     *  is {@code null}
      * @throws SQLException if the metadata for this result set
      *  cannot be introspected
      */
@@ -129,19 +129,19 @@
 
     /**
      * <p>Construct a new {@link RowSetDynaClass} for the specified
-     * <code>ResultSet</code>.  The property names corresponding
+     * {@code ResultSet}.  The property names corresponding
      * to the column names in the result set will be lower cased or not,
-     * depending on the specified <code>lowerCase</code> value.</p>
+     * depending on the specified {@code lowerCase} value.</p>
      *
-     * If <code>limit</code> is not less than 0, max <code>limit</code>
+     * If {@code limit</code> is not less than 0, max <code>limit}
      * number of rows will be copied into the resultset.
      *
      *
      * @param resultSet The result set to be wrapped
      * @param lowerCase Should property names be lower cased?
      *
-     * @throws NullPointerException if <code>resultSet</code>
-     *  is <code>null</code>
+     * @throws NullPointerException if {@code resultSet}
+     *  is {@code null}
      * @throws SQLException if the metadata for this result set
      *  cannot be introspected
      */
@@ -153,12 +153,12 @@
 
     /**
      * <p>Construct a new {@link RowSetDynaClass} for the specified
-     * <code>ResultSet</code>.  The property names corresponding
+     * {@code ResultSet}.  The property names corresponding
      * to the column names in the result set will be lower cased or not,
-     * depending on the specified <code>lowerCase</code> value.</p>
+     * depending on the specified {@code lowerCase} value.</p>
      *
-     * <p><strong>WARNING</strong> - If you specify <code>false</code>
-     * for <code>lowerCase</code>, the returned property names will
+     * <p><strong>WARNING</strong> - If you specify {@code false}
+     * for {@code lowerCase}, the returned property names will
      * exactly match the column names returned by your JDBC driver.
      * Because different drivers might return column names in different
      * cases, the property names seen by your application will vary
@@ -166,10 +166,10 @@
      *
      * @param resultSet The result set to be wrapped
      * @param lowerCase Should property names be lower cased?
-     * @param limit Maximum limit for the <code>List</code> of {@link DynaBean}
+     * @param limit Maximum limit for the {@code List} of {@link DynaBean}
      *
-     * @throws NullPointerException if <code>resultSet</code>
-     *  is <code>null</code>
+     * @throws NullPointerException if {@code resultSet}
+     *  is {@code null}
      * @throws SQLException if the metadata for this result set
      *  cannot be introspected
      */
@@ -182,12 +182,12 @@
 
     /**
      * <p>Construct a new {@link RowSetDynaClass} for the specified
-     * <code>ResultSet</code>.  The property names corresponding
+     * {@code ResultSet}.  The property names corresponding
      * to the column names in the result set will be lower cased or not,
-     * depending on the specified <code>lowerCase</code> value.</p>
+     * depending on the specified {@code lowerCase} value.</p>
      *
-     * <p><strong>WARNING</strong> - If you specify <code>false</code>
-     * for <code>lowerCase</code>, the returned property names will
+     * <p><strong>WARNING</strong> - If you specify {@code false}
+     * for {@code lowerCase}, the returned property names will
      * exactly match the column names returned by your JDBC driver.
      * Because different drivers might return column names in different
      * cases, the property names seen by your application will vary
@@ -197,8 +197,8 @@
      * @param lowerCase Should property names be lower cased?
      * @param useColumnLabel true if the column label should be used, otherwise false
      *
-     * @throws NullPointerException if <code>resultSet</code>
-     *  is <code>null</code>
+     * @throws NullPointerException if {@code resultSet}
+     *  is {@code null}
      * @throws SQLException if the metadata for this result set
      *  cannot be introspected
      * @since 1.8.3
@@ -211,12 +211,12 @@
 
     /**
      * <p>Construct a new {@link RowSetDynaClass} for the specified
-     * <code>ResultSet</code>.  The property names corresponding
+     * {@code ResultSet}.  The property names corresponding
      * to the column names in the result set will be lower cased or not,
-     * depending on the specified <code>lowerCase</code> value.</p>
+     * depending on the specified {@code lowerCase} value.</p>
      *
-     * <p><strong>WARNING</strong> - If you specify <code>false</code>
-     * for <code>lowerCase</code>, the returned property names will
+     * <p><strong>WARNING</strong> - If you specify {@code false}
+     * for {@code lowerCase}, the returned property names will
      * exactly match the column names returned by your JDBC driver.
      * Because different drivers might return column names in different
      * cases, the property names seen by your application will vary
@@ -224,11 +224,11 @@
      *
      * @param resultSet The result set to be wrapped
      * @param lowerCase Should property names be lower cased?
-     * @param limit Maximum limit for the <code>List</code> of {@link DynaBean}
+     * @param limit Maximum limit for the {@code List} of {@link DynaBean}
      * @param useColumnLabel true if the column label should be used, otherwise false
      *
-     * @throws NullPointerException if <code>resultSet</code>
-     *  is <code>null</code>
+     * @throws NullPointerException if {@code resultSet}
+     *  is {@code null}
      * @throws SQLException if the metadata for this result set
      *  cannot be introspected
      * @since 1.8.3
@@ -248,9 +248,9 @@
     }
 
     /**
-     * <p>Return a <code>List</code> containing the {@link DynaBean}s that
-     * represent the contents of each <code>Row</code> from the
-     * <code>ResultSet</code> that was the basis of this
+     * <p>Return a {@code List} containing the {@link DynaBean}s that
+     * represent the contents of each {@code Row} from the
+     * {@code ResultSet} that was the basis of this
      * {@link RowSetDynaClass} instance.  These {@link DynaBean}s are
      * disconnected from the database itself, so there is no problem with
      * modifying the contents of the list, or the values of the properties
@@ -258,7 +258,7 @@
      * responsibility to persist any such changes back to the database,
      * if it so desires.</p>
      *
-     * @return A <code>List</code> of {@link DynaBean} instances
+     * @return A {@code List} of {@link DynaBean} instances
      */
     public List<DynaBean> getRows() {
 
@@ -267,16 +267,16 @@
     }
 
 
-    // ------------------------------------------------------ Protected Methods
+    
 
 
     /**
      * <p>Copy the column values for each row in the specified
-     * <code>ResultSet</code> into a newly created {@link DynaBean}, and add
+     * {@code ResultSet} into a newly created {@link DynaBean}, and add
      * this bean to the list of {@link DynaBean}s that will later by
-     * returned by a call to <code>getRows()</code>.</p>
+     * returned by a call to {@code getRows()}.</p>
      *
-     * @param resultSet The <code>ResultSet</code> whose data is to be
+     * @param resultSet The {@code ResultSet} whose data is to be
      *  copied
      *
      * @throws SQLException if an error is encountered copying the data
@@ -301,7 +301,7 @@
      * <p>Create and return a new {@link DynaBean} instance to be used for
      * representing a row in the underlying result set.</p>
      *
-     * @return A new <code>DynaBean</code> instance
+     * @return A new {@code DynaBean} instance
      */
     protected DynaBean createDynaBean() {
 
diff --git a/src/main/java/org/apache/commons/beanutils2/WeakFastHashMap.java b/src/main/java/org/apache/commons/beanutils2/WeakFastHashMap.java
index 5c16de3..f9a993b 100644
--- a/src/main/java/org/apache/commons/beanutils2/WeakFastHashMap.java
+++ b/src/main/java/org/apache/commons/beanutils2/WeakFastHashMap.java
@@ -25,7 +25,7 @@
 import java.util.WeakHashMap;
 
 /**
- * <p>A customized implementation of <code>java.util.HashMap</code> designed
+ * <p>A customized implementation of {@code java.util.HashMap} designed
  * to operate in a multi-threaded environment where the large majority of
  * method calls are read-only, instead of structural changes.  When operating
  * in "fast" mode, read calls are non-synchronized and write calls perform the
@@ -38,12 +38,12 @@
  * <p>When first created, objects of this class default to "slow" mode, where
  * all accesses of any type are synchronized but no cloning takes place.  This
  * is appropriate for initially populating the collection, followed by a switch
- * to "fast" mode (by calling <code>setFast(true)</code>) after initialization
+ * to "fast" mode (by calling {@code setFast(true)}) after initialization
  * is complete.</p>
  *
  * <p><strong>NOTE</strong>: If you are creating and accessing a
- * <code>HashMap</code> only within a single thread, you should use
- * <code>java.util.HashMap</code> directly (with no synchronization), for
+ * {@code HashMap} only within a single thread, you should use
+ * {@code java.util.HashMap} directly (with no synchronization), for
  * maximum performance.</p>
  *
  * <p><strong>NOTE</strong>: <i>This class is not cross-platform.
@@ -75,7 +75,7 @@
     private boolean fast = false;
 
     // Constructors
-    // ----------------------------------------------------------------------
+    
 
     /**
      * Construct an empty map.
@@ -118,7 +118,7 @@
 
 
     // Property access
-    // ----------------------------------------------------------------------
+    
 
     /**
      *  Returns true if this map is operating in fast mode.
@@ -140,15 +140,15 @@
 
 
     // Map access
-    // ----------------------------------------------------------------------
+    
     // These methods can forward straight to the wrapped Map in 'fast' mode.
     // (because they are query methods)
 
     /**
      * Return the value to which this map maps the specified key.  Returns
-     * <code>null</code> if the map contains no mapping for this key, or if
-     * there is a mapping with a value of <code>null</code>.  Use the
-     * <code>containsKey()</code> method to disambiguate these cases.
+     * {@code null} if the map contains no mapping for this key, or if
+     * there is a mapping with a value of {@code null}.  Use the
+     * {@code containsKey()} method to disambiguate these cases.
      *
      * @param key  the key whose value is to be returned
      * @return the value mapped to that key, or null
@@ -179,7 +179,7 @@
     }
 
     /**
-     * Return <code>true</code> if this map contains no mappings.
+     * Return {@code true} if this map contains no mappings.
      *
      * @return is the map currently empty
      */
@@ -194,7 +194,7 @@
     }
 
     /**
-     * Return <code>true</code> if this map contains a mapping for the
+     * Return {@code true} if this map contains a mapping for the
      * specified key.
      *
      * @param key  the key to be searched for
@@ -211,7 +211,7 @@
     }
 
     /**
-     * Return <code>true</code> if this map contains one or more keys mapping
+     * Return {@code true} if this map contains one or more keys mapping
      * to the specified value.
      *
      * @param value  the value to be searched for
@@ -228,7 +228,7 @@
     }
 
     // Map modification
-    // ----------------------------------------------------------------------
+    
     // These methods perform special behavior in 'fast' mode.
     // The map is cloned, updated and then assigned back.
     // See the comments at the top as to why this won't always work.
@@ -317,13 +317,13 @@
     }
 
     // Basic object methods
-    // ----------------------------------------------------------------------
+    
 
     /**
      * Compare the specified object with this list for equality.  This
      * implementation uses exactly the code that is used to define the
      * list equals function in the documentation for the
-     * <code>Map.equals</code> method.
+     * {@code Map.equals} method.
      *
      * @param o  the object to be compared to this list
      * @return true if the two maps are equal
@@ -383,7 +383,7 @@
     /**
      * Return the hash code value for this map.  This implementation uses
      * exactly the code that is used to define the list hash function in the
-     * documentation for the <code>Map.hashCode</code> method.
+     * documentation for the {@code Map.hashCode} method.
      *
      * @return suitable integer hash code
      */
@@ -406,7 +406,7 @@
     }
 
     /**
-     * Return a shallow copy of this <code>FastHashMap</code> instance.
+     * Return a shallow copy of this {@code FastHashMap} instance.
      * The keys and values themselves are not copied.
      *
      * @return a clone of this map
@@ -426,11 +426,11 @@
     }
 
     // Map views
-    // ----------------------------------------------------------------------
+    
 
     /**
      * Return a collection view of the mappings contained in this map.  Each
-     * element in the returned collection is a <code>Map.Entry</code>.
+     * element in the returned collection is a {@code Map.Entry}.
      * @return the set of map Map entries
      */
     @Override
@@ -457,7 +457,7 @@
     }
 
     // Abstractions on Map creations (for subclasses such as WeakFastHashMap)
-    // ----------------------------------------------------------------------
+    
 
     protected Map<K, V> createMap() {
         return new WeakHashMap<>();
@@ -480,7 +480,7 @@
     }
 
     // Map view inner classes
-    // ----------------------------------------------------------------------
+    
 
     /**
      * Abstract collection implementation shared by keySet(), values() and entrySet().
diff --git a/src/main/java/org/apache/commons/beanutils2/WrapDynaBean.java b/src/main/java/org/apache/commons/beanutils2/WrapDynaBean.java
index e353d28..9edbade 100644
--- a/src/main/java/org/apache/commons/beanutils2/WrapDynaBean.java
+++ b/src/main/java/org/apache/commons/beanutils2/WrapDynaBean.java
@@ -23,12 +23,12 @@
 
 
 /**
- * <p>Implementation of <code>DynaBean</code> that wraps a standard JavaBean
+ * <p>Implementation of {@code DynaBean} that wraps a standard JavaBean
  * instance, so that DynaBean APIs can be used to access its properties.</p>
  *
  * <p>
  * The most common use cases for this class involve wrapping an existing java bean.
- * (This makes it different from the typical use cases for other <code>DynaBean</code>'s.)
+ * (This makes it different from the typical use cases for other {@code DynaBean}'s.)
  * For example:
  * </p>
  * <pre><code>
@@ -39,7 +39,7 @@
  * </code></pre>
  *
  * <p><strong>IMPLEMENTATION NOTE</strong> - This implementation does not
- * support the <code>contains()</code> and <code>remove()</code> methods.</p>
+ * support the {@code contains()</code> and <code>remove()} methods.</p>
  *
  */
 
@@ -47,10 +47,10 @@
 
     private static final long serialVersionUID = 1L;
 
-    // ---------------------------------------------------------- Constructors
+    
 
     /**
-     * Construct a new <code>DynaBean</code> associated with the specified
+     * Construct a new {@code DynaBean} associated with the specified
      * JavaBean instance.
      *
      * @param instance JavaBean instance to be wrapped
@@ -79,11 +79,11 @@
 
     }
 
-    // ---------------------------------------------------- Instance Variables
+    
 
 
     /**
-     * The <code>DynaClass</code> "base class" that this DynaBean
+     * The {@code DynaClass} "base class" that this DynaBean
      * is associated with.
      */
     protected transient WrapDynaClass dynaClass = null;
@@ -95,7 +95,7 @@
     protected Object instance = null;
 
 
-    // ------------------------------------------------------ DynaBean Methods
+    
 
 
     /**
@@ -104,8 +104,8 @@
      *
      * @param name Name of the property to check
      * @param key Name of the key to check
-     * @return <code>true</code> if the mapped property contains a value for
-     * the specified key, otherwise <code>false</code>
+     * @return {@code true} if the mapped property contains a value for
+     * the specified key, otherwise {@code false}
      *
      * @throws IllegalArgumentException if there is no property
      *  of the specified name
@@ -190,7 +190,7 @@
 
     /**
      * Return the value of a mapped property with the specified name,
-     * or <code>null</code> if there is no value for the specified key.
+     * or {@code null} if there is no value for the specified key.
      *
      * @param name Name of the property whose value is to be retrieved
      * @param key Key of the value to be retrieved
@@ -223,7 +223,7 @@
 
 
     /**
-     * Return the <code>DynaClass</code> instance that describes the set of
+     * Return the {@code DynaClass} instance that describes the set of
      * properties available for this DynaBean.
      * @return The associated DynaClass
      */
@@ -366,17 +366,17 @@
      * For most common use cases,
      * this object should already be known
      * and this method safely be ignored.
-     * But some creators of frameworks using <code>DynaBean</code>'s may
+     * But some creators of frameworks using {@code DynaBean}'s may
      * find this useful.
      *
-     * @return the java bean Object wrapped by this <code>DynaBean</code>
+     * @return the java bean Object wrapped by this {@code DynaBean}
      */
     public Object getInstance() {
         return instance;
     }
 
 
-    // ------------------------------------------------------ Protected Methods
+    
 
 
     /**
diff --git a/src/main/java/org/apache/commons/beanutils2/WrapDynaClass.java b/src/main/java/org/apache/commons/beanutils2/WrapDynaClass.java
index 2d298b4..63e932e 100644
--- a/src/main/java/org/apache/commons/beanutils2/WrapDynaClass.java
+++ b/src/main/java/org/apache/commons/beanutils2/WrapDynaClass.java
@@ -45,13 +45,13 @@
 public class WrapDynaClass implements DynaClass {
 
 
-    // ----------------------------------------------------------- Constructors
+    
 
 
     /**
      * Construct a new WrapDynaClass for the specified JavaBean class.  This
      * constructor is private; WrapDynaClass instances will be created as
-     * needed via calls to the <code>createDynaClass(Class)</code> method.
+     * needed via calls to the {@code createDynaClass(Class)} method.
      *
      * @param beanClass JavaBean class to be introspected around
      * @param propUtils the {@code PropertyUtilsBean} associated with this class
@@ -66,7 +66,7 @@
     }
 
 
-    // ----------------------------------------------------- Instance Variables
+    
 
     /**
      * Name of the JavaBean class represented by this WrapDynaClass.
@@ -90,7 +90,7 @@
     /**
      * The set of PropertyDescriptors for this bean class, keyed by the
      * property name.  Individual descriptor instances will be the same
-     * instances as those in the <code>descriptors</code> list.
+     * instances as those in the {@code descriptors} list.
      */
     protected HashMap<String, PropertyDescriptor> descriptorsMap = new HashMap<>();
 
@@ -104,12 +104,12 @@
     /**
      * The set of dynamic properties that are part of this DynaClass,
      * keyed by the property name.  Individual descriptor instances will
-     * be the same instances as those in the <code>properties</code> list.
+     * be the same instances as those in the {@code properties} list.
      */
     protected HashMap<String, DynaProperty> propertiesMap = new HashMap<>();
 
 
-    // ------------------------------------------------------- Static Variables
+    
 
 
     private static final ContextClassLoaderLocal<Map<CacheKey, WrapDynaClass>> CLASSLOADER_CACHE =
@@ -133,7 +133,7 @@
 
 
 
-    // ------------------------------------------------------ DynaClass Methods
+    
 
     /**
      * Return the class of the underlying wrapped bean.
@@ -163,7 +163,7 @@
 
     /**
      * Return a property descriptor for the specified property, if it exists;
-     * otherwise, return <code>null</code>.
+     * otherwise, return {@code null}.
      *
      * @param name Name of the dynamic property for which a descriptor
      *  is requested
@@ -184,12 +184,12 @@
 
 
     /**
-     * <p>Return an array of <code>ProperyDescriptors</code> for the properties
+     * <p>Return an array of {@code ProperyDescriptors} for the properties
      * currently defined in this DynaClass.  If no properties are defined, a
      * zero-length array will be returned.</p>
      *
      * <p><strong>FIXME</strong> - Should we really be implementing
-     * <code>getBeanInfo()</code> instead, which returns property descriptors
+     * {@code getBeanInfo()} instead, which returns property descriptors
      * and a bunch of other stuff?</p>
      *
      * @return the set of properties for this DynaClass
@@ -210,17 +210,17 @@
      *
      * <p><strong>NOTE</strong> - Most common use cases should not need to use
      * this method. It is usually better to create new
-     * <code>WrapDynaBean</code> instances by calling its constructor.
+     * {@code WrapDynaBean} instances by calling its constructor.
      * For example:</p>
      * <pre><code>
      *   Object javaBean = ...;
      *   DynaBean wrapper = new WrapDynaBean(javaBean);
      * </code></pre>
      * <p>
-     * (This method is needed for some kinds of <code>DynaBean</code> framework.)
+     * (This method is needed for some kinds of {@code DynaBean} framework.)
      * </p>
      *
-     * @return A new <code>DynaBean</code> instance
+     * @return A new {@code DynaBean} instance
      * @throws IllegalAccessException if the Class or the appropriate
      *  constructor is not accessible
      * @throws InstantiationException if this Class represents an abstract
@@ -236,12 +236,12 @@
     }
 
 
-    // --------------------------------------------------------- Public Methods
+    
 
 
     /**
      * Return the PropertyDescriptor for the specified property name, if any;
-     * otherwise return <code>null</code>.
+     * otherwise return {@code null}.
      *
      * @param name Name of the property to be retrieved
      * @return The descriptor for the specified property
@@ -253,7 +253,7 @@
     }
 
 
-    // --------------------------------------------------------- Static Methods
+    
 
 
     /**
@@ -267,7 +267,7 @@
 
 
     /**
-     * Create (if necessary) and return a new <code>WrapDynaClass</code>
+     * Create (if necessary) and return a new {@code WrapDynaClass}
      * instance for the specified bean class.
      *
      * @param beanClass Bean class for which a WrapDynaClass is requested
@@ -306,7 +306,7 @@
     }
 
 
-    // ------------------------------------------------------ Protected Methods
+    
 
     /**
      * Returns the {@code PropertyUtilsBean} instance associated with this class. This
diff --git a/src/main/java/org/apache/commons/beanutils2/converters/AbstractConverter.java b/src/main/java/org/apache/commons/beanutils2/converters/AbstractConverter.java
index 1b5fe82..d94461e 100644
--- a/src/main/java/org/apache/commons/beanutils2/converters/AbstractConverter.java
+++ b/src/main/java/org/apache/commons/beanutils2/converters/AbstractConverter.java
@@ -36,13 +36,13 @@
  * conversion error occurs.
  * <p>
  * Implementations should provide conversion to the specified
- * type and from the specified type to a <code>String</code> value
+ * type and from the specified type to a {@code String} value
  * by implementing the following methods:
  * <ul>
- *     <li><code>convertToString(value)</code> - convert to a String
- *        (default implementation uses the objects <code>toString()</code>
+ *     <li>{@code convertToString(value)} - convert to a String
+ *        (default implementation uses the objects {@code toString()}
  *        method).</li>
- *     <li><code>convertToType(Class, value)</code> - convert
+ *     <li>{@code convertToType(Class, value)} - convert
  *         to the specified type</li>
  * </ul>
  * <p>
@@ -80,11 +80,11 @@
      */
     private Object defaultValue = null;
 
-    // ----------------------------------------------------------- Constructors
+    
 
     /**
      * Construct a <i>Converter</i> that throws a
-     * <code>ConversionException</code> if an error occurs.
+     * {@code ConversionException} if an error occurs.
      */
     public AbstractConverter() {
     }
@@ -101,14 +101,14 @@
         setDefaultValue(defaultValue);
     }
 
-    // --------------------------------------------------------- Public Methods
+    
 
     /**
      * Indicates whether a default value will be returned or exception
      * thrown in the event of a conversion error.
      *
-     * @return <code>true</code> if a default value will be returned for
-     * conversion errors or <code>false</code> if a {@link ConversionException}
+     * @return {@code true} if a default value will be returned for
+     * conversion errors or {@code false} if a {@link ConversionException}
      * will be thrown.
      */
     public boolean isUseDefault() {
@@ -183,7 +183,7 @@
      * Convert the input object into a String.
      * <p>
      * <b>N.B.</b>This implementation simply uses the value's
-     * <code>toString()</code> method and should be overridden if a
+     * {@code toString()} method and should be overridden if a
      * more sophisticated mechanism for <i>conversion to a String</i>
      * is required.
      *
@@ -200,7 +200,7 @@
      * specified type.
      * <p>
      * Typical implementations will provide a minimum of
-     * <code>String --&gt; type</code> conversion.
+     * {@code String --&gt; type} conversion.
      *
      * @param <T> Target type of the conversion.
      * @param type Data type to which this value should be converted.
@@ -249,7 +249,7 @@
      * @param <T> Target type of the conversion.
      * @param type Data type to which this value should be converted.
      * @param value The input value to be converted
-     * @param cause The exception thrown by the <code>convert</code> method
+     * @param cause The exception thrown by the {@code convert} method
      * @return The default value.
      * @throws ConversionException if no default value has been
      * specified for this {@link Converter}.
@@ -336,7 +336,7 @@
      * Set the default value, converting as required.
      * <p>
      * If the default value is different from the type the
-     * <code>Converter</code> handles, it will be converted
+     * {@code Converter} handles, it will be converted
      * to the handled type.
      *
      * @param defaultValue The default value to be returned
@@ -359,9 +359,9 @@
     }
 
     /**
-     * Return the default type this <code>Converter</code> handles.
+     * Return the default type this {@code Converter} handles.
      *
-     * @return The default type this <code>Converter</code> handles.
+     * @return The default type this {@code Converter} handles.
      */
     protected abstract Class<?> getDefaultType();
 
@@ -388,7 +388,7 @@
         return toString(getClass()) + "[UseDefault=" + useDefault + "]";
     }
 
-    // ----------------------------------------------------------- Package Methods
+    
 
     /**
      * Accessor method for Log instance.
@@ -408,8 +408,8 @@
     }
 
     /**
-     * Provide a String representation of a <code>java.lang.Class</code>.
-     * @param type The <code>java.lang.Class</code>.
+     * Provide a String representation of a {@code java.lang.Class}.
+     * @param type The {@code java.lang.Class}.
      * @return The String representation.
      */
     String toString(final Class<?> type) {
diff --git a/src/main/java/org/apache/commons/beanutils2/converters/ArrayConverter.java b/src/main/java/org/apache/commons/beanutils2/converters/ArrayConverter.java
index 6b94a34..7437a81 100644
--- a/src/main/java/org/apache/commons/beanutils2/converters/ArrayConverter.java
+++ b/src/main/java/org/apache/commons/beanutils2/converters/ArrayConverter.java
@@ -34,7 +34,7 @@
  * to and from <b>array</b> objects.
  * <p>
  * Can be configured to either return a <i>default value</i> or throw a
- * <code>ConversionException</code> if a conversion error occurs.
+ * {@code ConversionException} if a conversion error occurs.
  * <p>
  * The main features of this implementation are:
  * <ul>
@@ -50,11 +50,11 @@
  *     <li><b>Delimited Lists</b> - can Convert <b>to</b> and <b>from</b> a
  *         delimited list in String format.</li>
  *     <li><b>Conversion to String</b> - converts an array to a
- *         <code>String</code> in one of two ways: as a <i>delimited list</i>
+ *         {@code String} in one of two ways: as a <i>delimited list</i>
  *         or by converting the first element in the array to a String - this
  *         is controlled by the {@link ArrayConverter#setOnlyFirstToString(boolean)}
  *         parameter.</li>
- *     <li><b>Multi Dimensional Arrays</b> - it is possible to convert a <code>String</code>
+ *     <li><b>Multi Dimensional Arrays</b> - it is possible to convert a {@code String}
  *         to a multi-dimensional arrays, by embedding {@link ArrayConverter}
  *         within each other - see example below.</li>
  *     <li><b>Default Value</b>
@@ -70,11 +70,11 @@
  *                 value</i>. The <i>defaultSize</i> parameter controls the
  *                 <i>default value</i> in the following way:
  *                 <ul>
- *                    <li><i>defaultSize &lt; 0</i> - default is <code>null</code></li>
+ *                    <li><i>defaultSize &lt; 0</i> - default is {@code null}</li>
  *                    <li><i>defaultSize = 0</i> - default is an array of length zero</li>
  *                    <li><i>defaultSize &gt; 0</i> - default is an array with a
- *                           length specified by <code>defaultSize</code> (N.B. elements
- *                           in the array will be <code>null</code>)</li>
+ *                           length specified by {@code defaultSize} (N.B. elements
+ *                           in the array will be {@code null})</li>
  *                 </ul>
  *             </li>
  *         </ul>
@@ -82,24 +82,24 @@
  * </ul>
  *
  * <h3>Parsing Delimited Lists</h3>
- * This implementation can convert a delimited list in <code>String</code> format
+ * This implementation can convert a delimited list in {@code String} format
  * into an array of the appropriate type. By default, it uses a comma as the delimiter
  * but the following methods can be used to configure parsing:
  * <ul>
- *     <li><code>setDelimiter(char)</code> - allows the character used as
+ *     <li>{@code setDelimiter(char)} - allows the character used as
  *         the delimiter to be configured [default is a comma].</li>
- *     <li><code>setAllowedChars(char[])</code> - adds additional characters
+ *     <li>{@code setAllowedChars(char[])} - adds additional characters
  *         (to the default alphabetic/numeric) to those considered to be
  *         valid token characters.
  * </ul>
  *
  * <h3>Multi Dimensional Arrays</h3>
- * It is possible to convert a <code>String</code> to mulit-dimensional arrays by using
+ * It is possible to convert a {@code String} to mulit-dimensional arrays by using
  * {@link ArrayConverter} as the element {@link Converter}
  * within another {@link ArrayConverter}.
  * <p>
  * For example, the following code demonstrates how to construct a {@link Converter}
- * to convert a delimited <code>String</code> into a two dimensional integer array:
+ * to convert a delimited {@code String} into a two dimensional integer array:
  * </p>
  * <pre>
  *    // Construct an Integer Converter
@@ -135,15 +135,15 @@
     private char[] allowedChars = new char[] {'.', '-'};
     private boolean onlyFirstToString = true;
 
-    // ----------------------------------------------------------- Constructors
+    
 
     /**
-     * Construct an <b>array</b> <code>Converter</code> with the specified
-     * <b>component</b> <code>Converter</code> that throws a
-     * <code>ConversionException</code> if an error occurs.
+     * Construct an <b>array</b> {@code Converter} with the specified
+     * <b>component</b> {@code Converter} that throws a
+     * {@code ConversionException} if an error occurs.
      *
      * @param defaultType The default array type this
-     *  <code>Converter</code> handles
+     *  {@code Converter} handles
      * @param elementConverter Converter used to convert
      *  individual array elements.
      */
@@ -163,16 +163,16 @@
     }
 
     /**
-     * Construct an <b>array</b> <code>Converter</code> with the specified
-     * <b>component</b> <code>Converter</code> that returns a default
-     * array of the specified size (or <code>null</code>) if an error occurs.
+     * Construct an <b>array</b> {@code Converter} with the specified
+     * <b>component</b> {@code Converter} that returns a default
+     * array of the specified size (or {@code null}) if an error occurs.
      *
      * @param defaultType The default array type this
-     *  <code>Converter</code> handles
+     *  {@code Converter} handles
      * @param elementConverter Converter used to convert
      *  individual array elements.
      * @param defaultSize Specifies the size of the default array value or if less
-     *  than zero indicates that a <code>null</code> default value should be used.
+     *  than zero indicates that a {@code null} default value should be used.
      */
     public ArrayConverter(final Class<?> defaultType, final Converter elementConverter, final int defaultSize) {
         this(defaultType, elementConverter);
@@ -207,19 +207,19 @@
      * Indicates whether converting to a String should create
      * a delimited list or just convert the first value.
      *
-     * @param onlyFirstToString <code>true</code> converts only
-     * the first value in the array to a String, <code>false</code>
+     * @param onlyFirstToString {@code true} converts only
+     * the first value in the array to a String, {@code false}
      * converts all values in the array into a delimited list (default
-     * is <code>true</code>
+     * is {@code true}
      */
     public void setOnlyFirstToString(final boolean onlyFirstToString) {
         this.onlyFirstToString = onlyFirstToString;
     }
 
     /**
-     * Return the default type this <code>Converter</code> handles.
+     * Return the default type this {@code Converter} handles.
      *
-     * @return The default type this <code>Converter</code> handles.
+     * @return The default type this {@code Converter} handles.
      */
     @Override
     protected Class<?> getDefaultType() {
@@ -412,7 +412,7 @@
 
     /**
      * <p>Parse an incoming String of the form similar to an array initializer
-     * in the Java language into a <code>List</code> individual Strings
+     * in the Java language into a {@code List} individual Strings
      * for each element, according to the following rules.</p>
      * <ul>
      * <li>The string is expected to be a comma-separated list of values.</li>
@@ -427,10 +427,10 @@
      * @param value String value to be parsed
      * @return List of parsed elements.
      *
-     * @throws ConversionException if the syntax of <code>value</code>
+     * @throws ConversionException if the syntax of {@code value}
      *  is not syntactically valid
-     * @throws NullPointerException if <code>value</code>
-     *  is <code>null</code>
+     * @throws NullPointerException if {@code value}
+     *  is {@code null}
      */
     private List<String> parseElements(final Class<?> type, String value) {
 
diff --git a/src/main/java/org/apache/commons/beanutils2/converters/BigDecimalConverter.java b/src/main/java/org/apache/commons/beanutils2/converters/BigDecimalConverter.java
index 8abd569..bb1b6f7 100644
--- a/src/main/java/org/apache/commons/beanutils2/converters/BigDecimalConverter.java
+++ b/src/main/java/org/apache/commons/beanutils2/converters/BigDecimalConverter.java
@@ -28,7 +28,7 @@
  * documentation for further details.
  * <p>
  * Can be configured to either return a <i>default value</i> or throw a
- * <code>ConversionException</code> if a conversion error occurs.
+ * {@code ConversionException} if a conversion error occurs.
  *
  * @since 1.3
  */
@@ -36,7 +36,7 @@
 
     /**
      * Construct a <b>java.math.BigDecimal</b> <i>Converter</i> that throws
-     * a <code>ConversionException</code> if an error occurs.
+     * a {@code ConversionException} if an error occurs.
      */
     public BigDecimalConverter() {
         super(true);
@@ -55,9 +55,9 @@
     }
 
     /**
-     * Return the default type this <code>Converter</code> handles.
+     * Return the default type this {@code Converter} handles.
      *
-     * @return The default type this <code>Converter</code> handles.
+     * @return The default type this {@code Converter} handles.
      * @since 1.8.0
      */
     @Override
diff --git a/src/main/java/org/apache/commons/beanutils2/converters/BigIntegerConverter.java b/src/main/java/org/apache/commons/beanutils2/converters/BigIntegerConverter.java
index 36ef532..835eec4 100644
--- a/src/main/java/org/apache/commons/beanutils2/converters/BigIntegerConverter.java
+++ b/src/main/java/org/apache/commons/beanutils2/converters/BigIntegerConverter.java
@@ -28,7 +28,7 @@
  * documentation for further details.
  * <p>
  * Can be configured to either return a <i>default value</i> or throw a
- * <code>ConversionException</code> if a conversion error occurs.
+ * {@code ConversionException} if a conversion error occurs.
  *
  * @since 1.3
  */
@@ -36,7 +36,7 @@
 
     /**
      * Construct a <b>java.math.BigInteger</b> <i>Converter</i> that throws
-     * a <code>ConversionException</code> if an error occurs.
+     * a {@code ConversionException} if an error occurs.
      */
     public BigIntegerConverter() {
         super(false);
@@ -55,9 +55,9 @@
     }
 
     /**
-     * Return the default type this <code>Converter</code> handles.
+     * Return the default type this {@code Converter} handles.
      *
-     * @return The default type this <code>Converter</code> handles.
+     * @return The default type this {@code Converter} handles.
      * @since 1.8.0
      */
     @Override
diff --git a/src/main/java/org/apache/commons/beanutils2/converters/BooleanConverter.java b/src/main/java/org/apache/commons/beanutils2/converters/BooleanConverter.java
index ce28ca4..2935755 100644
--- a/src/main/java/org/apache/commons/beanutils2/converters/BooleanConverter.java
+++ b/src/main/java/org/apache/commons/beanutils2/converters/BooleanConverter.java
@@ -23,7 +23,7 @@
  * handles conversion to and from <b>java.lang.Boolean</b> objects.
  * <p>
  * Can be configured to either return a <i>default value</i> or throw a
- * <code>ConversionException</code> if a conversion error occurs.
+ * {@code ConversionException} if a conversion error occurs.
  * </p>
  * <p>
  * By default any object whose string representation is one of the values
@@ -46,7 +46,7 @@
 public final class BooleanConverter extends AbstractConverter {
 
 
-    // ----------------------------------------------------------- Constructors
+    
 
 
     /**
@@ -131,13 +131,13 @@
     }
 
 
-    // ----------------------------------------------------- Static Variables
+    
 
 
 
 
 
-    // ----------------------------------------------------- Instance Variables
+    
 
     /**
      * The set of strings that are known to map to Boolean.TRUE.
@@ -149,12 +149,12 @@
      */
     private String[] falseStrings = {"false", "no", "n", "off", "0"};
 
-    // --------------------------------------------------------- Protected Methods
+    
 
     /**
-     * Return the default type this <code>Converter</code> handles.
+     * Return the default type this {@code Converter} handles.
      *
-     * @return The default type this <code>Converter</code> handles.
+     * @return The default type this {@code Converter} handles.
      * @since 1.8.0
      */
     @Override
diff --git a/src/main/java/org/apache/commons/beanutils2/converters/ByteConverter.java b/src/main/java/org/apache/commons/beanutils2/converters/ByteConverter.java
index 5c8ddf2..a4df873 100644
--- a/src/main/java/org/apache/commons/beanutils2/converters/ByteConverter.java
+++ b/src/main/java/org/apache/commons/beanutils2/converters/ByteConverter.java
@@ -26,7 +26,7 @@
  * documentation for further details.
  * <p>
  * Can be configured to either return a <i>default value</i> or throw a
- * <code>ConversionException</code> if a conversion error occurs.
+ * {@code ConversionException} if a conversion error occurs.
  *
  * @since 1.3
  */
@@ -34,7 +34,7 @@
 
     /**
      * Construct a <b>java.lang.Byte</b> <i>Converter</i> that throws
-     * a <code>ConversionException</code> if an error occurs.
+     * a {@code ConversionException} if an error occurs.
      */
     public ByteConverter() {
         super(false);
@@ -53,9 +53,9 @@
     }
 
     /**
-     * Return the default type this <code>Converter</code> handles.
+     * Return the default type this {@code Converter} handles.
      *
-     * @return The default type this <code>Converter</code> handles.
+     * @return The default type this {@code Converter} handles.
      * @since 1.8.0
      */
     @Override
diff --git a/src/main/java/org/apache/commons/beanutils2/converters/CalendarConverter.java b/src/main/java/org/apache/commons/beanutils2/converters/CalendarConverter.java
index 1e88ac4..b2fdf9d 100644
--- a/src/main/java/org/apache/commons/beanutils2/converters/CalendarConverter.java
+++ b/src/main/java/org/apache/commons/beanutils2/converters/CalendarConverter.java
@@ -28,7 +28,7 @@
  * See the {@link DateTimeConverter} documentation for further details.
  * <p>
  * Can be configured to either return a <i>default value</i> or throw a
- * <code>ConversionException</code> if a conversion error occurs.
+ * {@code ConversionException} if a conversion error occurs.
  *
  * @since 1.8.0
  */
@@ -36,7 +36,7 @@
 
     /**
      * Construct a <b>java.util.Calendar</b> <i>Converter</i> that throws
-     * a <code>ConversionException</code> if an error occurs.
+     * a {@code ConversionException} if an error occurs.
      */
     public CalendarConverter() {
         super();
@@ -55,9 +55,9 @@
     }
 
     /**
-     * Return the default type this <code>Converter</code> handles.
+     * Return the default type this {@code Converter} handles.
      *
-     * @return The default type this <code>Converter</code> handles.
+     * @return The default type this {@code Converter} handles.
      */
     @Override
     protected Class<?> getDefaultType() {
diff --git a/src/main/java/org/apache/commons/beanutils2/converters/CharacterConverter.java b/src/main/java/org/apache/commons/beanutils2/converters/CharacterConverter.java
index 4aef77c..7ede90c 100644
--- a/src/main/java/org/apache/commons/beanutils2/converters/CharacterConverter.java
+++ b/src/main/java/org/apache/commons/beanutils2/converters/CharacterConverter.java
@@ -22,7 +22,7 @@
  * to and from <b>java.lang.Character</b> objects.
  * <p>
  * Can be configured to either return a <i>default value</i> or throw a
- * <code>ConversionException</code> if a conversion error occurs.
+ * {@code ConversionException} if a conversion error occurs.
  *
  * @since 1.3
  */
@@ -30,7 +30,7 @@
 
     /**
      * Construct a <b>java.lang.Character</b> <i>Converter</i> that throws
-     * a <code>ConversionException</code> if an error occurs.
+     * a {@code ConversionException} if an error occurs.
      */
     public CharacterConverter() {
         super();
@@ -49,9 +49,9 @@
     }
 
     /**
-     * Return the default type this <code>Converter</code> handles.
+     * Return the default type this {@code Converter} handles.
      *
-     * @return The default type this <code>Converter</code> handles.
+     * @return The default type this {@code Converter} handles.
      * @since 1.8.0
      */
     @Override
diff --git a/src/main/java/org/apache/commons/beanutils2/converters/ClassConverter.java b/src/main/java/org/apache/commons/beanutils2/converters/ClassConverter.java
index 67a6b1c..7f4a59c 100644
--- a/src/main/java/org/apache/commons/beanutils2/converters/ClassConverter.java
+++ b/src/main/java/org/apache/commons/beanutils2/converters/ClassConverter.java
@@ -25,7 +25,7 @@
  * will be used.
  * <p>
  * Can be configured to either return a <i>default value</i> or throw a
- * <code>ConversionException</code> if a conversion error occurs.
+ * {@code ConversionException} if a conversion error occurs.
  *
  * @since 1.4
  */
@@ -33,7 +33,7 @@
 
     /**
      * Construct a <b>java.lang.Class</b> <i>Converter</i> that throws
-     * a <code>ConversionException</code> if an error occurs.
+     * a {@code ConversionException} if an error occurs.
      */
     public ClassConverter() {
         super();
@@ -52,9 +52,9 @@
     }
 
     /**
-     * Return the default type this <code>Converter</code> handles.
+     * Return the default type this {@code Converter} handles.
      *
-     * @return The default type this <code>Converter</code> handles.
+     * @return The default type this {@code Converter} handles.
      * @since 1.8.0
      */
     @Override
diff --git a/src/main/java/org/apache/commons/beanutils2/converters/DateConverter.java b/src/main/java/org/apache/commons/beanutils2/converters/DateConverter.java
index 9d4910d..86daae3 100644
--- a/src/main/java/org/apache/commons/beanutils2/converters/DateConverter.java
+++ b/src/main/java/org/apache/commons/beanutils2/converters/DateConverter.java
@@ -28,7 +28,7 @@
  * See the {@link DateTimeConverter} documentation for further details.
  * <p>
  * Can be configured to either return a <i>default value</i> or throw a
- * <code>ConversionException</code> if a conversion error occurs.
+ * {@code ConversionException} if a conversion error occurs.
  *
  * @since 1.8.0
  */
@@ -36,7 +36,7 @@
 
     /**
      * Construct a <b>java.util.Date</b> <i>Converter</i> that throws
-     * a <code>ConversionException</code> if an error occurs.
+     * a {@code ConversionException} if an error occurs.
      */
     public DateConverter() {
         super();
@@ -55,9 +55,9 @@
     }
 
     /**
-     * Return the default type this <code>Converter</code> handles.
+     * Return the default type this {@code Converter} handles.
      *
-     * @return The default type this <code>Converter</code> handles.
+     * @return The default type this {@code Converter} handles.
      */
     @Override
     protected Class<?> getDefaultType() {
diff --git a/src/main/java/org/apache/commons/beanutils2/converters/DateTimeConverter.java b/src/main/java/org/apache/commons/beanutils2/converters/DateTimeConverter.java
index fee6110..3e94de1 100644
--- a/src/main/java/org/apache/commons/beanutils2/converters/DateTimeConverter.java
+++ b/src/main/java/org/apache/commons/beanutils2/converters/DateTimeConverter.java
@@ -39,15 +39,15 @@
  * This implementation handles conversion for the following
  * <i>date/time</i> types.
  * <ul>
- *     <li><code>java.util.Date</code></li>
- *     <li><code>java.util.Calendar</code></li>
- *     <li><code>java.time.LocalDate</code></li>
- *     <li><code>java.time.LocalDateTime</code></li>
- *     <li><code>java.time.OffsetDateTime</code></li>
- *     <li><code>java.time.ZonedDateTime</code></li>
- *     <li><code>java.sql.Date</code></li>
- *     <li><code>java.sql.Time</code></li>
- *     <li><code>java.sql.Timestamp</code></li>
+ *     <li>{@code java.util.Date}</li>
+ *     <li>{@code java.util.Calendar}</li>
+ *     <li>{@code java.time.LocalDate}</li>
+ *     <li>{@code java.time.LocalDateTime}</li>
+ *     <li>{@code java.time.OffsetDateTime}</li>
+ *     <li>{@code java.time.ZonedDateTime}</li>
+ *     <li>{@code java.sql.Date}</li>
+ *     <li>{@code java.sql.Time}</li>
+ *     <li>{@code java.sql.Timestamp}</li>
  * </ul>
  *
  * <h3>String Conversions (to and from)</h3>
@@ -56,31 +56,31 @@
  * <ul>
  *    <li>Using the SHORT date format for the default Locale, configure using:
  *        <ul>
- *           <li><code>setUseLocaleFormat(true)</code></li>
+ *           <li>{@code setUseLocaleFormat(true)}</li>
  *        </ul>
  *    </li>
  *    <li>Using the SHORT date format for a specified Locale, configure using:
  *        <ul>
- *           <li><code>setLocale(Locale)</code></li>
+ *           <li>{@code setLocale(Locale)}</li>
  *        </ul>
  *    </li>
  *    <li>Using the specified date pattern(s) for the default Locale, configure using:
  *        <ul>
- *           <li>Either <code>setPattern(String)</code> or
- *                      <code>setPatterns(String[])</code></li>
+ *           <li>Either {@code setPattern(String)} or
+ *                      {@code setPatterns(String[])}</li>
  *        </ul>
  *    </li>
  *    <li>Using the specified date pattern(s) for a specified Locale, configure using:
  *        <ul>
- *           <li><code>setPattern(String)</code> or
- *                    <code>setPatterns(String[]) and...</code></li>
- *           <li><code>setLocale(Locale)</code></li>
+ *           <li>{@code setPattern(String)} or
+ *                    {@code setPatterns(String[]) and...}</li>
+ *           <li>{@code setLocale(Locale)}</li>
  *        </ul>
  *    </li>
  *    <li>If none of the above are configured the
- *        <code>toDate(String)</code> method is used to convert
+ *        {@code toDate(String)} method is used to convert
  *        from String to Date and the Dates's
- *        <code>toString()</code> method used to convert from
+ *        {@code toString()} method used to convert from
  *        Date to String.</li>
  * </ul>
  *
@@ -99,11 +99,11 @@
     private boolean useLocaleFormat;
 
 
-    // ----------------------------------------------------------- Constructors
+    
 
     /**
      * Construct a Date/Time <i>Converter</i> that throws a
-     * <code>ConversionException</code> if an error occurs.
+     * {@code ConversionException} if an error occurs.
      */
     public DateTimeConverter() {
         super();
@@ -122,13 +122,13 @@
     }
 
 
-    // --------------------------------------------------------- Public Methods
+    
 
     /**
      * Indicate whether conversion should use a format/pattern or not.
      *
-     * @param useLocaleFormat <code>true</code> if the format
-     * for the locale should be used, otherwise <code>false</code>
+     * @param useLocaleFormat {@code true} if the format
+     * for the locale should be used, otherwise {@code false}
      */
     public void setUseLocaleFormat(final boolean useLocaleFormat) {
         this.useLocaleFormat = useLocaleFormat;
@@ -136,7 +136,7 @@
 
     /**
      * Return the Time Zone to use when converting dates
-     * (or <code>null</code> if none specified.
+     * (or {@code null} if none specified.
      *
      * @return The Time Zone.
      */
@@ -155,7 +155,7 @@
 
     /**
      * Return the Locale for the <i>Converter</i>
-     * (or <code>null</code> if none specified).
+     * (or {@code null} if none specified).
      *
      * @return The locale to use for conversion
      */
@@ -175,7 +175,7 @@
 
     /**
      * Set a date format pattern to use to convert
-     * dates to/from a <code>java.lang.String</code>.
+     * dates to/from a {@code java.lang.String}.
      *
      * @see SimpleDateFormat
      * @param pattern The format pattern.
@@ -186,8 +186,8 @@
 
     /**
      * Return the date format patterns used to convert
-     * dates to/from a <code>java.lang.String</code>
-     * (or <code>null</code> if none specified).
+     * dates to/from a {@code java.lang.String}
+     * (or {@code null} if none specified).
      *
      * @see SimpleDateFormat
      * @return Array of format patterns.
@@ -198,7 +198,7 @@
 
     /**
      * Set the date format patterns to use to convert
-     * dates to/from a <code>java.lang.String</code>.
+     * dates to/from a {@code java.lang.String}.
      *
      * @see SimpleDateFormat
      * @param patterns Array of format patterns.
@@ -218,15 +218,15 @@
         setUseLocaleFormat(true);
     }
 
-    // ------------------------------------------------------ Protected Methods
+    
 
     /**
      * Convert an input Date/Calendar object into a String.
      * <p>
      * <b>N.B.</b>If the converter has been configured to with
-     * one or more patterns (using <code>setPatterns()</code>), then
+     * one or more patterns (using {@code setPatterns()}), then
      * the first pattern will be used to format the date into a String.
-     * Otherwise the default <code>DateFormat</code> for the default locale
+     * Otherwise the default {@code DateFormat} for the default locale
      * (and <i>style</i> if configured) will be used.
      *
      * @param value The input value to be converted
@@ -282,25 +282,25 @@
      * This method handles conversions between the following
      * types:
      * <ul>
-     *     <li><code>java.util.Date</code></li>
-     *     <li><code>java.util.Calendar</code></li>
-     *     <li><code>java.time.LocalDate</code></li>
-     *     <li><code>java.time.LocalDateTime</code></li>
-     *     <li><code>java.time.OffsetDateTime</code></li>
-     *     <li><code>java.time.ZonedDateTime</code></li>
-     *     <li><code>java.sql.Date</code></li>
-     *     <li><code>java.sql.Time</code></li>
-     *     <li><code>java.sql.Timestamp</code></li>
+     *     <li>{@code java.util.Date}</li>
+     *     <li>{@code java.util.Calendar}</li>
+     *     <li>{@code java.time.LocalDate}</li>
+     *     <li>{@code java.time.LocalDateTime}</li>
+     *     <li>{@code java.time.OffsetDateTime}</li>
+     *     <li>{@code java.time.ZonedDateTime}</li>
+     *     <li>{@code java.sql.Date}</li>
+     *     <li>{@code java.sql.Time}</li>
+     *     <li>{@code java.sql.Timestamp}</li>
      * </ul>
      *
-     * It also handles conversion from a <code>String</code> to
+     * It also handles conversion from a {@code String} to
      * any of the above types.
      * <p>
      *
-     * For <code>String</code> conversion, if the converter has been configured
-     * with one or more patterns (using <code>setPatterns()</code>), then
+     * For {@code String} conversion, if the converter has been configured
+     * with one or more patterns (using {@code setPatterns()}), then
      * the conversion is attempted with each of the specified patterns.
-     * Otherwise the default <code>DateFormat</code> for the default locale
+     * Otherwise the default {@code DateFormat} for the default locale
      * (and <i>style</i> if configured) will be used.
      *
      * @param <T> The desired target type of the conversion.
@@ -317,14 +317,14 @@
         // Handle java.sql.Timestamp
         if (value instanceof java.sql.Timestamp) {
 
-            // ---------------------- JDK 1.3 Fix ----------------------
+            
             // N.B. Prior to JDK 1.4 the Timestamp's getTime() method
             //      didn't include the milliseconds. The following code
             //      ensures it works consistently across JDK versions
             final java.sql.Timestamp timestamp = (java.sql.Timestamp)value;
             long timeInMillis = ((timestamp.getTime() / 1000) * 1000);
             timeInMillis += timestamp.getNanos() / 1000000;
-            // ---------------------- JDK 1.3 Fix ----------------------
+            
             return toDate(targetType, timeInMillis);
         }
 
@@ -403,14 +403,14 @@
      *
      * This method handles conversion to the following types:
      * <ul>
-     *     <li><code>java.util.Date</code></li>
-     *     <li><code>java.util.Calendar</code></li>
-     *     <li><code>java.time.LocalDate</code></li>
-     *     <li><code>java.time.LocalDateTime</code></li>
-     *     <li><code>java.time.ZonedDateTime</code></li>
-     *     <li><code>java.sql.Date</code></li>
-     *     <li><code>java.sql.Time</code></li>
-     *     <li><code>java.sql.Timestamp</code></li>
+     *     <li>{@code java.util.Date}</li>
+     *     <li>{@code java.util.Calendar}</li>
+     *     <li>{@code java.time.LocalDate}</li>
+     *     <li>{@code java.time.LocalDateTime}</li>
+     *     <li>{@code java.time.ZonedDateTime}</li>
+     *     <li>{@code java.sql.Date}</li>
+     *     <li>{@code java.sql.Time}</li>
+     *     <li>{@code java.sql.Timestamp}</li>
      * </ul>
      *
      * @param <T> The target type
@@ -494,14 +494,14 @@
      * <p>
      * This method handles conversion from a String to the following types:
      * <ul>
-     *     <li><code>java.sql.Date</code></li>
-     *     <li><code>java.sql.Time</code></li>
-     *     <li><code>java.sql.Timestamp</code></li>
+     *     <li>{@code java.sql.Date}</li>
+     *     <li>{@code java.sql.Time}</li>
+     *     <li>{@code java.sql.Timestamp}</li>
      * </ul>
      * <p>
      * <strong>N.B.</strong> No default String conversion
-     * mechanism is provided for <code>java.util.Date</code>
-     * and <code>java.util.Calendar</code> type.
+     * mechanism is provided for {@code java.util.Date}
+     * and {@code java.util.Calendar} type.
      *
      * @param <T> The target type
      * @param type The date type to convert to
@@ -550,7 +550,7 @@
     }
 
     /**
-     * Return a <code>DateFormat</code> for the Locale.
+     * Return a {@code DateFormat} for the Locale.
      * @param locale The Locale to create the Format with (may be null)
      * @param timeZone The Time Zone create the Format with (may be null)
      *
@@ -614,8 +614,8 @@
     }
 
     /**
-     * Parse a String into a <code>Calendar</code> object
-     * using the specified <code>DateFormat</code>.
+     * Parse a String into a {@code Calendar} object
+     * using the specified {@code DateFormat}.
      *
      * @param sourceType The type of the value being converted
      * @param targetType The type to convert the value to
@@ -675,7 +675,7 @@
     }
 
     /**
-     * Log the <code>DateFormat</code> creation.
+     * Log the {@code DateFormat} creation.
      * @param action The action the format is being used for
      * @param format The Date format
      */
@@ -708,9 +708,9 @@
     }
 
     /**
-     * Gets the <code>java.time.ZoneId</code> from the <code>java.util.Timezone</code>
+     * Gets the {@code java.time.ZoneId</code> from the <code>java.util.Timezone}
      * set or use the system default if no time zone is set.
-     * @return the <code>ZoneId</code>
+     * @return the {@code ZoneId}
      */
     private ZoneId getZoneId() {
     	return timeZone == null ? ZoneId.systemDefault() : timeZone.toZoneId();
diff --git a/src/main/java/org/apache/commons/beanutils2/converters/DoubleConverter.java b/src/main/java/org/apache/commons/beanutils2/converters/DoubleConverter.java
index 5a87a54..1a8de78 100644
--- a/src/main/java/org/apache/commons/beanutils2/converters/DoubleConverter.java
+++ b/src/main/java/org/apache/commons/beanutils2/converters/DoubleConverter.java
@@ -26,7 +26,7 @@
  * documentation for further details.
  * <p>
  * Can be configured to either return a <i>default value</i> or throw a
- * <code>ConversionException</code> if a conversion error occurs.
+ * {@code ConversionException} if a conversion error occurs.
  *
  * @since 1.3
  */
@@ -34,7 +34,7 @@
 
     /**
      * Construct a <b>java.lang.Double</b> <i>Converter</i> that throws
-     * a <code>ConversionException</code> if an error occurs.
+     * a {@code ConversionException} if an error occurs.
      */
     public DoubleConverter() {
         super(true);
@@ -53,9 +53,9 @@
     }
 
     /**
-     * Return the default type this <code>Converter</code> handles.
+     * Return the default type this {@code Converter} handles.
      *
-     * @return The default type this <code>Converter</code> handles.
+     * @return The default type this {@code Converter} handles.
      * @since 1.8.0
      */
     @Override
diff --git a/src/main/java/org/apache/commons/beanutils2/converters/DurationConverter.java b/src/main/java/org/apache/commons/beanutils2/converters/DurationConverter.java
index a593585..ea7866c 100644
--- a/src/main/java/org/apache/commons/beanutils2/converters/DurationConverter.java
+++ b/src/main/java/org/apache/commons/beanutils2/converters/DurationConverter.java
@@ -23,7 +23,7 @@
  * to and from <b>java.time.Duration</b> objects.
  * <p>
  * Can be configured to either return a <i>default value</i> or throw a
- * <code>ConversionException</code> if a conversion error occurs.
+ * {@code ConversionException} if a conversion error occurs.
  * </p>
  *
  * @since 2.0
@@ -33,7 +33,7 @@
 
     /**
      * Construct a <b>java.time.Duration</b> <i>Converter</i> that throws
-     * a <code>ConversionException</code> if an error occurs.
+     * a {@code ConversionException} if an error occurs.
      */
     public DurationConverter() {
         super();
@@ -52,9 +52,9 @@
     }
 
     /**
-     * Return the default type this <code>Converter</code> handles.
+     * Return the default type this {@code Converter} handles.
      *
-     * @return The default type this <code>Converter</code> handles.
+     * @return The default type this {@code Converter} handles.
      * @since 2.0
      */
     @Override
diff --git a/src/main/java/org/apache/commons/beanutils2/converters/FileConverter.java b/src/main/java/org/apache/commons/beanutils2/converters/FileConverter.java
index 28a222d..7189070 100644
--- a/src/main/java/org/apache/commons/beanutils2/converters/FileConverter.java
+++ b/src/main/java/org/apache/commons/beanutils2/converters/FileConverter.java
@@ -23,7 +23,7 @@
  * to and from <b>java.io.File</b> objects.
  * <p>
  * Can be configured to either return a <i>default value</i> or throw a
- * <code>ConversionException</code> if a conversion error occurs.
+ * {@code ConversionException} if a conversion error occurs.
  *
  * @since 1.6
  */
@@ -31,7 +31,7 @@
 
     /**
      * Construct a <b>java.io.File</b> <i>Converter</i> that throws
-     * a <code>ConversionException</code> if an error occurs.
+     * a {@code ConversionException} if an error occurs.
      */
     public FileConverter() {
         super();
@@ -50,9 +50,9 @@
     }
 
     /**
-     * Return the default type this <code>Converter</code> handles.
+     * Return the default type this {@code Converter} handles.
      *
-     * @return The default type this <code>Converter</code> handles.
+     * @return The default type this {@code Converter} handles.
      * @since 1.8.0
      */
     @Override
diff --git a/src/main/java/org/apache/commons/beanutils2/converters/FloatConverter.java b/src/main/java/org/apache/commons/beanutils2/converters/FloatConverter.java
index 0ea73f3..5735436 100644
--- a/src/main/java/org/apache/commons/beanutils2/converters/FloatConverter.java
+++ b/src/main/java/org/apache/commons/beanutils2/converters/FloatConverter.java
@@ -26,7 +26,7 @@
  * documentation for further details.
  * <p>
  * Can be configured to either return a <i>default value</i> or throw a
- * <code>ConversionException</code> if a conversion error occurs.
+ * {@code ConversionException} if a conversion error occurs.
  *
  * @since 1.3
  */
@@ -34,7 +34,7 @@
 
     /**
      * Construct a <b>java.lang.Float</b> <i>Converter</i> that throws
-     * a <code>ConversionException</code> if an error occurs.
+     * a {@code ConversionException} if an error occurs.
      */
     public FloatConverter() {
         super(true);
@@ -53,9 +53,9 @@
     }
 
     /**
-     * Return the default type this <code>Converter</code> handles.
+     * Return the default type this {@code Converter} handles.
      *
-     * @return The default type this <code>Converter</code> handles.
+     * @return The default type this {@code Converter} handles.
      * @since 1.8.0
      */
     @Override
diff --git a/src/main/java/org/apache/commons/beanutils2/converters/IntegerConverter.java b/src/main/java/org/apache/commons/beanutils2/converters/IntegerConverter.java
index f53bafd..da51a3f 100644
--- a/src/main/java/org/apache/commons/beanutils2/converters/IntegerConverter.java
+++ b/src/main/java/org/apache/commons/beanutils2/converters/IntegerConverter.java
@@ -26,7 +26,7 @@
  * documentation for further details.
  * <p>
  * Can be configured to either return a <i>default value</i> or throw a
- * <code>ConversionException</code> if a conversion error occurs.
+ * {@code ConversionException} if a conversion error occurs.
  *
  * @since 1.3
  */
@@ -34,7 +34,7 @@
 
     /**
      * Construct a <b>java.lang.Integer</b> <i>Converter</i> that throws
-     * a <code>ConversionException</code> if an error occurs.
+     * a {@code ConversionException} if an error occurs.
      */
     public IntegerConverter() {
         super(false);
@@ -53,9 +53,9 @@
     }
 
     /**
-     * Return the default type this <code>Converter</code> handles.
+     * Return the default type this {@code Converter} handles.
      *
-     * @return The default type this <code>Converter</code> handles.
+     * @return The default type this {@code Converter} handles.
      * @since 1.8.0
      */
     @Override
diff --git a/src/main/java/org/apache/commons/beanutils2/converters/LocalDateConverter.java b/src/main/java/org/apache/commons/beanutils2/converters/LocalDateConverter.java
index b58c981..e37fdea 100644
--- a/src/main/java/org/apache/commons/beanutils2/converters/LocalDateConverter.java
+++ b/src/main/java/org/apache/commons/beanutils2/converters/LocalDateConverter.java
@@ -29,7 +29,7 @@
  * </p>
  * <p>
  * Can be configured to either return a <i>default value</i> or throw a
- * <code>ConversionException</code> if a conversion error occurs.
+ * {@code ConversionException} if a conversion error occurs.
  * </p>
  *
  * @since 2.0
@@ -39,7 +39,7 @@
 
     /**
      * Construct a <b>java.time.LocalDate</b> <i>Converter</i> that throws
-     * a <code>ConversionException</code> if an error occurs.
+     * a {@code ConversionException} if an error occurs.
      */
     public LocalDateConverter() {
         super();
@@ -58,9 +58,9 @@
     }
 
     /**
-     * Return the default type this <code>Converter</code> handles.
+     * Return the default type this {@code Converter} handles.
      *
-     * @return The default type this <code>Converter</code> handles.
+     * @return The default type this {@code Converter} handles.
      */
     @Override
     protected Class<?> getDefaultType() {
diff --git a/src/main/java/org/apache/commons/beanutils2/converters/LocalDateTimeConverter.java b/src/main/java/org/apache/commons/beanutils2/converters/LocalDateTimeConverter.java
index 3be8a52..2c355e5 100644
--- a/src/main/java/org/apache/commons/beanutils2/converters/LocalDateTimeConverter.java
+++ b/src/main/java/org/apache/commons/beanutils2/converters/LocalDateTimeConverter.java
@@ -29,7 +29,7 @@
  * </p>
  * <p>
  * Can be configured to either return a <i>default value</i> or throw a
- * <code>ConversionException</code> if a conversion error occurs.
+ * {@code ConversionException} if a conversion error occurs.
  * </p>
  *
  * @since 2.0
@@ -39,7 +39,7 @@
 
     /**
      * Construct a <b>java.time.LocalDateTime</b> <i>Converter</i> that throws
-     * a <code>ConversionException</code> if an error occurs.
+     * a {@code ConversionException} if an error occurs.
      */
     public LocalDateTimeConverter() {
         super();
@@ -58,9 +58,9 @@
     }
 
     /**
-     * Return the default type this <code>Converter</code> handles.
+     * Return the default type this {@code Converter} handles.
      *
-     * @return The default type this <code>Converter</code> handles.
+     * @return The default type this {@code Converter} handles.
      */
     @Override
     protected Class<?> getDefaultType() {
diff --git a/src/main/java/org/apache/commons/beanutils2/converters/LocalTimeConverter.java b/src/main/java/org/apache/commons/beanutils2/converters/LocalTimeConverter.java
index d62333a..176d299 100644
--- a/src/main/java/org/apache/commons/beanutils2/converters/LocalTimeConverter.java
+++ b/src/main/java/org/apache/commons/beanutils2/converters/LocalTimeConverter.java
@@ -23,7 +23,7 @@
  * to and from <b>java.time.LocalTime</b> objects.
  * <p>
  * Can be configured to either return a <i>default value</i> or throw a
- * <code>ConversionException</code> if a conversion error occurs.
+ * {@code ConversionException} if a conversion error occurs.
  * </p>
  *
  * @since 2.0
@@ -33,7 +33,7 @@
 
     /**
      * Construct a <b>java.time.LocalTime</b> <i>Converter</i> that throws
-     * a <code>ConversionException</code> if an error occurs.
+     * a {@code ConversionException} if an error occurs.
      */
     public LocalTimeConverter() {
         super();
@@ -52,9 +52,9 @@
     }
 
     /**
-     * Return the default type this <code>Converter</code> handles.
+     * Return the default type this {@code Converter} handles.
      *
-     * @return The default type this <code>Converter</code> handles.
+     * @return The default type this {@code Converter} handles.
      * @since 2.0
      */
     @Override
diff --git a/src/main/java/org/apache/commons/beanutils2/converters/LongConverter.java b/src/main/java/org/apache/commons/beanutils2/converters/LongConverter.java
index 90df29f..bcac3bb 100644
--- a/src/main/java/org/apache/commons/beanutils2/converters/LongConverter.java
+++ b/src/main/java/org/apache/commons/beanutils2/converters/LongConverter.java
@@ -26,7 +26,7 @@
  * documentation for further details.
  * <p>
  * Can be configured to either return a <i>default value</i> or throw a
- * <code>ConversionException</code> if a conversion error occurs.
+ * {@code ConversionException} if a conversion error occurs.
  *
  * @since 1.3
  */
@@ -34,7 +34,7 @@
 
     /**
      * Construct a <b>java.lang.Long</b> <i>Converter</i> that throws
-     * a <code>ConversionException</code> if an error occurs.
+     * a {@code ConversionException} if an error occurs.
      */
     public LongConverter() {
         super(false);
@@ -53,9 +53,9 @@
     }
 
     /**
-     * Return the default type this <code>Converter</code> handles.
+     * Return the default type this {@code Converter} handles.
      *
-     * @return The default type this <code>Converter</code> handles.
+     * @return The default type this {@code Converter} handles.
      * @since 1.8.0
      */
     @Override
diff --git a/src/main/java/org/apache/commons/beanutils2/converters/MonthDayConverter.java b/src/main/java/org/apache/commons/beanutils2/converters/MonthDayConverter.java
index e3258d5..b9b342a 100644
--- a/src/main/java/org/apache/commons/beanutils2/converters/MonthDayConverter.java
+++ b/src/main/java/org/apache/commons/beanutils2/converters/MonthDayConverter.java
@@ -23,7 +23,7 @@
  * to and from <b>java.time.MonthDay</b> objects.
  * <p>
  * Can be configured to either return a <i>default value</i> or throw a
- * <code>ConversionException</code> if a conversion error occurs.
+ * {@code ConversionException} if a conversion error occurs.
  * </p>
  *
  * @since 2.0
@@ -33,7 +33,7 @@
 
     /**
      * Construct a <b>java.time.MonthDay</b> <i>Converter</i> that throws
-     * a <code>ConversionException</code> if an error occurs.
+     * a {@code ConversionException} if an error occurs.
      */
     public MonthDayConverter() {
         super();
@@ -52,9 +52,9 @@
     }
 
     /**
-     * Return the default type this <code>Converter</code> handles.
+     * Return the default type this {@code Converter} handles.
      *
-     * @return The default type this <code>Converter</code> handles.
+     * @return The default type this {@code Converter} handles.
      * @since 2.0
      */
     @Override
diff --git a/src/main/java/org/apache/commons/beanutils2/converters/NumberConverter.java b/src/main/java/org/apache/commons/beanutils2/converters/NumberConverter.java
index b7c8da2..8ac56ff 100644
--- a/src/main/java/org/apache/commons/beanutils2/converters/NumberConverter.java
+++ b/src/main/java/org/apache/commons/beanutils2/converters/NumberConverter.java
@@ -33,16 +33,16 @@
  * to and from <b>java.lang.Number</b> objects.
  * <p>
  * This implementation handles conversion for the following
- * <code>java.lang.Number</code> types.
+ * {@code java.lang.Number} types.
  * <ul>
- *     <li><code>java.lang.Byte</code></li>
- *     <li><code>java.lang.Short</code></li>
- *     <li><code>java.lang.Integer</code></li>
- *     <li><code>java.lang.Long</code></li>
- *     <li><code>java.lang.Float</code></li>
- *     <li><code>java.lang.Double</code></li>
- *     <li><code>java.math.BigDecimal</code></li>
- *     <li><code>java.math.BigInteger</code></li>
+ *     <li>{@code java.lang.Byte}</li>
+ *     <li>{@code java.lang.Short}</li>
+ *     <li>{@code java.lang.Integer}</li>
+ *     <li>{@code java.lang.Long}</li>
+ *     <li>{@code java.lang.Float}</li>
+ *     <li>{@code java.lang.Double}</li>
+ *     <li>{@code java.math.BigDecimal}</li>
+ *     <li>{@code java.math.BigInteger}</li>
  * </ul>
  *
  * <h3>String Conversions (to and from)</h3>
@@ -51,37 +51,37 @@
  * <ul>
  *    <li>Using the default format for the default Locale, configure using:
  *        <ul>
- *          <li><code>setUseLocaleFormat(true)</code></li>
+ *          <li>{@code setUseLocaleFormat(true)}</li>
  *        </ul>
  *    </li>
  *    <li>Using the default format for a specified Locale, configure using:
  *        <ul>
- *          <li><code>setLocale(Locale)</code></li>
+ *          <li>{@code setLocale(Locale)}</li>
  *        </ul>
  *    </li>
  *    <li>Using a specified pattern for the default Locale, configure using:
  *        <ul>
- *          <li><code>setPattern(String)</code></li>
+ *          <li>{@code setPattern(String)}</li>
  *        </ul>
  *    </li>
  *    <li>Using a specified pattern for a specified Locale, configure using:
  *        <ul>
- *          <li><code>setPattern(String)</code></li>
- *          <li><code>setLocale(Locale)</code></li>
+ *          <li>{@code setPattern(String)}</li>
+ *          <li>{@code setLocale(Locale)}</li>
  *        </ul>
  *    </li>
  *    <li>If none of the above are configured the
- *        <code>toNumber(String)</code> method is used to convert
+ *        {@code toNumber(String)} method is used to convert
  *        from String to Number and the Number's
- *        <code>toString()</code> method used to convert from
+ *        {@code toString()} method used to convert from
  *        Number to String.</li>
  * </ul>
  *
  * <p>
  * <strong>N.B.</strong>Patterns can only be specified using the <i>standard</i>
- * pattern characters and NOT in <i>localized</i> form (see <code>java.text.DecimalFormat</code>).
- * For example to cater for number styles used in Germany such as <code>0.000,00</code> the pattern
- * is specified in the normal form <code>0,000.00</code> and the locale set to <code>Locale.GERMANY</code>.
+ * pattern characters and NOT in <i>localized</i> form (see {@code java.text.DecimalFormat}).
+ * For example to cater for number styles used in Germany such as {@code 0.000,00} the pattern
+ * is specified in the normal form {@code 0,000.00</code> and the locale set to <code>Locale.GERMANY}.
  *
  * @since 1.8.0
  */
@@ -95,11 +95,11 @@
     private boolean useLocaleFormat;
     private Locale locale;
 
-    // ----------------------------------------------------------- Constructors
+    
 
     /**
      * Construct a <b>java.lang.Number</b> <i>Converter</i>
-     * that throws a <code>ConversionException</code> if a error occurs.
+     * that throws a {@code ConversionException} if a error occurs.
      *
      * @param allowDecimals Indicates whether decimals are allowed
      */
@@ -109,7 +109,7 @@
     }
 
     /**
-     * Construct a <code>java.lang.Number</code> <i>Converter</i> that returns
+     * Construct a {@code java.lang.Number} <i>Converter</i> that returns
      * a default value if an error occurs.
      *
      * @param allowDecimals Indicates whether decimals are allowed
@@ -121,7 +121,7 @@
         setDefaultValue(defaultValue);
     }
 
-    // --------------------------------------------------------- Public Methods
+    
 
     /**
      * Return whether decimals are allowed in the number.
@@ -136,7 +136,7 @@
      * Set whether a format should be used to convert
      * the Number.
      *
-     * @param useLocaleFormat <code>true</code> if a number format
+     * @param useLocaleFormat {@code true} if a number format
      * should be used.
      */
     public void setUseLocaleFormat(final boolean useLocaleFormat) {
@@ -145,10 +145,10 @@
 
     /**
      * Return the number format pattern used to convert
-     * Numbers to/from a <code>java.lang.String</code>
-     * (or <code>null</code> if none specified).
+     * Numbers to/from a {@code java.lang.String}
+     * (or {@code null} if none specified).
      * <p>
-     * See <code>java.text.DecimalFormat</code> for details
+     * See {@code java.text.DecimalFormat} for details
      * of how to specify the pattern.
      *
      * @return The format pattern.
@@ -159,9 +159,9 @@
 
     /**
      * Set a number format pattern to use to convert
-     * Numbers to/from a <code>java.lang.String</code>.
+     * Numbers to/from a {@code java.lang.String}.
      * <p>
-     * See <code>java.text.DecimalFormat</code> for details
+     * See {@code java.text.DecimalFormat} for details
      * of how to specify the pattern.
      *
      * @param pattern The format pattern.
@@ -173,7 +173,7 @@
 
     /**
      * Return the Locale for the <i>Converter</i>
-     * (or <code>null</code> if none specified).
+     * (or {@code null} if none specified).
      *
      * @return The locale to use for conversion
      */
@@ -191,7 +191,7 @@
         setUseLocaleFormat(true);
     }
 
-    // ------------------------------------------------------ Protected Methods
+    
 
     /**
      * Convert an input Number object into a String.
@@ -285,14 +285,14 @@
      * <p>
      * This method handles conversion to the following types:
      * <ul>
-     *     <li><code>java.lang.Byte</code></li>
-     *     <li><code>java.lang.Short</code></li>
-     *     <li><code>java.lang.Integer</code></li>
-     *     <li><code>java.lang.Long</code></li>
-     *     <li><code>java.lang.Float</code></li>
-     *     <li><code>java.lang.Double</code></li>
-     *     <li><code>java.math.BigDecimal</code></li>
-     *     <li><code>java.math.BigInteger</code></li>
+     *     <li>{@code java.lang.Byte}</li>
+     *     <li>{@code java.lang.Short}</li>
+     *     <li>{@code java.lang.Integer}</li>
+     *     <li>{@code java.lang.Long}</li>
+     *     <li>{@code java.lang.Float}</li>
+     *     <li>{@code java.lang.Double}</li>
+     *     <li>{@code java.math.BigDecimal}</li>
+     *     <li>{@code java.math.BigInteger}</li>
      * </ul>
      * @param sourceType The type being converted from
      * @param targetType The Number type to convert to
@@ -403,14 +403,14 @@
      * <p>
      * This method handles conversion from a String to the following types:
      * <ul>
-     *     <li><code>java.lang.Byte</code></li>
-     *     <li><code>java.lang.Short</code></li>
-     *     <li><code>java.lang.Integer</code></li>
-     *     <li><code>java.lang.Long</code></li>
-     *     <li><code>java.lang.Float</code></li>
-     *     <li><code>java.lang.Double</code></li>
-     *     <li><code>java.math.BigDecimal</code></li>
-     *     <li><code>java.math.BigInteger</code></li>
+     *     <li>{@code java.lang.Byte}</li>
+     *     <li>{@code java.lang.Short}</li>
+     *     <li>{@code java.lang.Integer}</li>
+     *     <li>{@code java.lang.Long}</li>
+     *     <li>{@code java.lang.Float}</li>
+     *     <li>{@code java.lang.Double}</li>
+     *     <li>{@code java.math.BigDecimal}</li>
+     *     <li>{@code java.math.BigInteger}</li>
      * </ul>
      * @param sourceType The type being converted from
      * @param targetType The Number type to convert to
@@ -534,7 +534,7 @@
     }
 
     /**
-     * Convert a String into a <code>Number</code> object.
+     * Convert a String into a {@code Number} object.
      * @param sourceType the source type of the conversion
      * @param targetType The type to convert the value to
      * @param value The String date value.
diff --git a/src/main/java/org/apache/commons/beanutils2/converters/OffsetDateTimeConverter.java b/src/main/java/org/apache/commons/beanutils2/converters/OffsetDateTimeConverter.java
index deba044..a857514 100644
--- a/src/main/java/org/apache/commons/beanutils2/converters/OffsetDateTimeConverter.java
+++ b/src/main/java/org/apache/commons/beanutils2/converters/OffsetDateTimeConverter.java
@@ -29,7 +29,7 @@
  * </p>
  * <p>
  * Can be configured to either return a <i>default value</i> or throw a
- * <code>ConversionException</code> if a conversion error occurs.
+ * {@code ConversionException} if a conversion error occurs.
  * </p>
  *
  * @since 2.0
@@ -39,7 +39,7 @@
 
     /**
      * Construct a <b>java.time.OffsetDateTime</b> <i>Converter</i> that throws
-     * a <code>ConversionException</code> if an error occurs.
+     * a {@code ConversionException} if an error occurs.
      */
     public OffsetDateTimeConverter() {
         super();
@@ -58,9 +58,9 @@
     }
 
     /**
-     * Return the default type this <code>Converter</code> handles.
+     * Return the default type this {@code Converter} handles.
      *
-     * @return The default type this <code>Converter</code> handles.
+     * @return The default type this {@code Converter} handles.
      */
     @Override
     protected Class<?> getDefaultType() {
diff --git a/src/main/java/org/apache/commons/beanutils2/converters/OffsetTimeConverter.java b/src/main/java/org/apache/commons/beanutils2/converters/OffsetTimeConverter.java
index 06f3621..0c27950 100644
--- a/src/main/java/org/apache/commons/beanutils2/converters/OffsetTimeConverter.java
+++ b/src/main/java/org/apache/commons/beanutils2/converters/OffsetTimeConverter.java
@@ -23,7 +23,7 @@
  * to and from <b>java.time.OffsetTime</b> objects.
  * <p>
  * Can be configured to either return a <i>default value</i> or throw a
- * <code>ConversionException</code> if a conversion error occurs.
+ * {@code ConversionException} if a conversion error occurs.
  * </p>
  *
  * @since 2.0
@@ -33,7 +33,7 @@
 
     /**
      * Construct a <b>java.time.OffsetTime</b> <i>Converter</i> that throws
-     * a <code>ConversionException</code> if an error occurs.
+     * a {@code ConversionException} if an error occurs.
      */
     public OffsetTimeConverter() {
         super();
@@ -52,9 +52,9 @@
     }
 
     /**
-     * Return the default type this <code>Converter</code> handles.
+     * Return the default type this {@code Converter} handles.
      *
-     * @return The default type this <code>Converter</code> handles.
+     * @return The default type this {@code Converter} handles.
      * @since 2.0
      */
     @Override
diff --git a/src/main/java/org/apache/commons/beanutils2/converters/PathConverter.java b/src/main/java/org/apache/commons/beanutils2/converters/PathConverter.java
index 55b4f5c..d454f29 100644
--- a/src/main/java/org/apache/commons/beanutils2/converters/PathConverter.java
+++ b/src/main/java/org/apache/commons/beanutils2/converters/PathConverter.java
@@ -24,7 +24,7 @@
  * to and from <b>java.nio.file.Path</b> objects.
  * <p>
  * Can be configured to either return a <i>default value</i> or throw a
- * <code>ConversionException</code> if a conversion error occurs.
+ * {@code ConversionException} if a conversion error occurs.
  *
  * @since 2.0
  */
@@ -32,7 +32,7 @@
 
     /**
      * Construct a <b>java.nio.file.Path</b> <i>Converter</i> that throws
-     * a <code>ConversionException</code> if an error occurs.
+     * a {@code ConversionException} if an error occurs.
      */
     public PathConverter() {
         super();
@@ -51,9 +51,9 @@
     }
 
     /**
-     * Return the default type this <code>Converter</code> handles.
+     * Return the default type this {@code Converter} handles.
      *
-     * @return The default type this <code>Converter</code> handles.
+     * @return The default type this {@code Converter} handles.
      * @since 2.0
      */
     @Override
diff --git a/src/main/java/org/apache/commons/beanutils2/converters/PeriodConverter.java b/src/main/java/org/apache/commons/beanutils2/converters/PeriodConverter.java
index f345500..a714a98 100644
--- a/src/main/java/org/apache/commons/beanutils2/converters/PeriodConverter.java
+++ b/src/main/java/org/apache/commons/beanutils2/converters/PeriodConverter.java
@@ -23,7 +23,7 @@
  * to and from <b>java.time.Period</b> objects.
  * <p>
  * Can be configured to either return a <i>default value</i> or throw a
- * <code>ConversionException</code> if a conversion error occurs.
+ * {@code ConversionException} if a conversion error occurs.
  * </p>
  *
  * @since 2.0
@@ -33,7 +33,7 @@
 
     /**
      * Construct a <b>java.time.Period</b> <i>Converter</i> that throws
-     * a <code>ConversionException</code> if an error occurs.
+     * a {@code ConversionException} if an error occurs.
      */
     public PeriodConverter() {
         super();
@@ -52,9 +52,9 @@
     }
 
     /**
-     * Return the default type this <code>Converter</code> handles.
+     * Return the default type this {@code Converter} handles.
      *
-     * @return The default type this <code>Converter</code> handles.
+     * @return The default type this {@code Converter} handles.
      * @since 2.0
      */
     @Override
diff --git a/src/main/java/org/apache/commons/beanutils2/converters/ShortConverter.java b/src/main/java/org/apache/commons/beanutils2/converters/ShortConverter.java
index 2bf6547..99e2362 100644
--- a/src/main/java/org/apache/commons/beanutils2/converters/ShortConverter.java
+++ b/src/main/java/org/apache/commons/beanutils2/converters/ShortConverter.java
@@ -26,7 +26,7 @@
  * documentation for further details.
  * <p>
  * Can be configured to either return a <i>default value</i> or throw a
- * <code>ConversionException</code> if a conversion error occurs.
+ * {@code ConversionException} if a conversion error occurs.
  *
  * @since 1.3
  */
@@ -34,7 +34,7 @@
 
     /**
      * Construct a <b>java.lang.Short</b> <i>Converter</i> that throws
-     * a <code>ConversionException</code> if an error occurs.
+     * a {@code ConversionException} if an error occurs.
      */
     public ShortConverter() {
         super(false);
@@ -53,9 +53,9 @@
     }
 
     /**
-     * Return the default type this <code>Converter</code> handles.
+     * Return the default type this {@code Converter} handles.
      *
-     * @return The default type this <code>Converter</code> handles.
+     * @return The default type this {@code Converter} handles.
      * @since 1.8.0
      */
     @Override
diff --git a/src/main/java/org/apache/commons/beanutils2/converters/SqlDateConverter.java b/src/main/java/org/apache/commons/beanutils2/converters/SqlDateConverter.java
index ec26958..109e6a6 100644
--- a/src/main/java/org/apache/commons/beanutils2/converters/SqlDateConverter.java
+++ b/src/main/java/org/apache/commons/beanutils2/converters/SqlDateConverter.java
@@ -28,7 +28,7 @@
  * See the {@link DateTimeConverter} documentation for further details.
  * <p>
  * Can be configured to either return a <i>default value</i> or throw a
- * <code>ConversionException</code> if a conversion error occurs.
+ * {@code ConversionException} if a conversion error occurs.
  *
  * @since 1.3
  */
@@ -36,7 +36,7 @@
 
     /**
      * Construct a <b>java.sql.Date</b> <i>Converter</i> that throws
-     * a <code>ConversionException</code> if an error occurs.
+     * a {@code ConversionException} if an error occurs.
      */
     public SqlDateConverter() {
         super();
@@ -55,9 +55,9 @@
     }
 
     /**
-     * Return the default type this <code>Converter</code> handles.
+     * Return the default type this {@code Converter} handles.
      *
-     * @return The default type this <code>Converter</code> handles.
+     * @return The default type this {@code Converter} handles.
      * @since 1.8.0
      */
     @Override
diff --git a/src/main/java/org/apache/commons/beanutils2/converters/SqlTimeConverter.java b/src/main/java/org/apache/commons/beanutils2/converters/SqlTimeConverter.java
index 4fa74f5..4fdc944 100644
--- a/src/main/java/org/apache/commons/beanutils2/converters/SqlTimeConverter.java
+++ b/src/main/java/org/apache/commons/beanutils2/converters/SqlTimeConverter.java
@@ -31,7 +31,7 @@
  * See the {@link DateTimeConverter} documentation for further details.
  * <p>
  * Can be configured to either return a <i>default value</i> or throw a
- * <code>ConversionException</code> if a conversion error occurs.
+ * {@code ConversionException} if a conversion error occurs.
  *
  * @since 1.3
  */
@@ -39,7 +39,7 @@
 
     /**
      * Construct a <b>java.sql.Time</b> <i>Converter</i> that throws
-     * a <code>ConversionException</code> if an error occurs.
+     * a {@code ConversionException} if an error occurs.
      */
     public SqlTimeConverter() {
         super();
@@ -58,9 +58,9 @@
     }
 
     /**
-     * Return the default type this <code>Converter</code> handles.
+     * Return the default type this {@code Converter} handles.
      *
-     * @return The default type this <code>Converter</code> handles.
+     * @return The default type this {@code Converter} handles.
      * @since 1.8.0
      */
     @Override
@@ -69,7 +69,7 @@
     }
 
     /**
-     * Return a <code>DateFormat</code> for the Locale.
+     * Return a {@code DateFormat} for the Locale.
      * @param locale TODO
      * @param timeZone TODO
      *
diff --git a/src/main/java/org/apache/commons/beanutils2/converters/SqlTimestampConverter.java b/src/main/java/org/apache/commons/beanutils2/converters/SqlTimestampConverter.java
index 7f63bf6..c4576d8 100644
--- a/src/main/java/org/apache/commons/beanutils2/converters/SqlTimestampConverter.java
+++ b/src/main/java/org/apache/commons/beanutils2/converters/SqlTimestampConverter.java
@@ -31,7 +31,7 @@
  * See the {@link DateTimeConverter} documentation for further details.
  * <p>
  * Can be configured to either return a <i>default value</i> or throw a
- * <code>ConversionException</code> if a conversion error occurs.
+ * {@code ConversionException} if a conversion error occurs.
  *
  * @since 1.3
  */
@@ -39,7 +39,7 @@
 
     /**
      * Construct a <b>java.sql.Timestamp</b> <i>Converter</i> that throws
-     * a <code>ConversionException</code> if an error occurs.
+     * a {@code ConversionException} if an error occurs.
      */
     public SqlTimestampConverter() {
         super();
@@ -58,9 +58,9 @@
     }
 
     /**
-     * Return the default type this <code>Converter</code> handles.
+     * Return the default type this {@code Converter} handles.
      *
-     * @return The default type this <code>Converter</code> handles.
+     * @return The default type this {@code Converter} handles.
      * @since 1.8.0
      */
     @Override
@@ -69,7 +69,7 @@
     }
 
     /**
-     * Return a <code>DateFormat</code> for the Locale.
+     * Return a {@code DateFormat} for the Locale.
      * @param locale TODO
      * @param timeZone TODO
      *
diff --git a/src/main/java/org/apache/commons/beanutils2/converters/StringConverter.java b/src/main/java/org/apache/commons/beanutils2/converters/StringConverter.java
index 0a0c779..4db439e 100644
--- a/src/main/java/org/apache/commons/beanutils2/converters/StringConverter.java
+++ b/src/main/java/org/apache/commons/beanutils2/converters/StringConverter.java
@@ -19,7 +19,7 @@
 /**
  * {@link org.apache.commons.beanutils2.Converter}
  * implementation that converts an incoming
- * object into a <code>java.lang.String</code> object.
+ * object into a {@code java.lang.String} object.
  * <p>
  * Note that ConvertUtils really is designed to do string-&gt;object conversions,
  * and offers very little support for object-&gt;string conversions. The
@@ -45,7 +45,7 @@
 
     /**
      * Construct a <b>java.lang.String</b> <i>Converter</i> that throws
-     * a <code>ConversionException</code> if an error occurs.
+     * a {@code ConversionException} if an error occurs.
      */
     public StringConverter() {
         super();
@@ -64,9 +64,9 @@
     }
 
     /**
-     * Return the default type this <code>Converter</code> handles.
+     * Return the default type this {@code Converter} handles.
      *
-     * @return The default type this <code>Converter</code> handles.
+     * @return The default type this {@code Converter} handles.
      * @since 1.8.0
      */
     @Override
diff --git a/src/main/java/org/apache/commons/beanutils2/converters/URIConverter.java b/src/main/java/org/apache/commons/beanutils2/converters/URIConverter.java
index e508e4b..902ebe2 100644
--- a/src/main/java/org/apache/commons/beanutils2/converters/URIConverter.java
+++ b/src/main/java/org/apache/commons/beanutils2/converters/URIConverter.java
@@ -23,7 +23,7 @@
  * to and from <b>java.net.URI</b> objects.
  * <p>
  * Can be configured to either return a <i>default value</i> or throw a
- * <code>ConversionException</code> if a conversion error occurs.
+ * {@code ConversionException} if a conversion error occurs.
  *
  * @since 2.0
  */
@@ -31,7 +31,7 @@
 
     /**
      * Construct a <b>java.net.URI</b> <i>Converter</i> that throws
-     * a <code>ConversionException</code> if an error occurs.
+     * a {@code ConversionException} if an error occurs.
      */
     public URIConverter() {
         super();
@@ -50,9 +50,9 @@
     }
 
     /**
-     * Return the default type this <code>Converter</code> handles.
+     * Return the default type this {@code Converter} handles.
      *
-     * @return The default type this <code>Converter</code> handles.
+     * @return The default type this {@code Converter} handles.
      * @since 2.0
      */
     @Override
diff --git a/src/main/java/org/apache/commons/beanutils2/converters/URLConverter.java b/src/main/java/org/apache/commons/beanutils2/converters/URLConverter.java
index 8fcd6b8..d4f2695 100644
--- a/src/main/java/org/apache/commons/beanutils2/converters/URLConverter.java
+++ b/src/main/java/org/apache/commons/beanutils2/converters/URLConverter.java
@@ -23,7 +23,7 @@
  * to and from <b>java.net.URL</b> objects.
  * <p>
  * Can be configured to either return a <i>default value</i> or throw a
- * <code>ConversionException</code> if a conversion error occurs.
+ * {@code ConversionException} if a conversion error occurs.
  *
  * @since 1.3
  */
@@ -31,7 +31,7 @@
 
     /**
      * Construct a <b>java.net.URL</b> <i>Converter</i> that throws
-     * a <code>ConversionException</code> if an error occurs.
+     * a {@code ConversionException} if an error occurs.
      */
     public URLConverter() {
         super();
@@ -50,9 +50,9 @@
     }
 
     /**
-     * Return the default type this <code>Converter</code> handles.
+     * Return the default type this {@code Converter} handles.
      *
-     * @return The default type this <code>Converter</code> handles.
+     * @return The default type this {@code Converter} handles.
      * @since 1.8.0
      */
     @Override
diff --git a/src/main/java/org/apache/commons/beanutils2/converters/UUIDConverter.java b/src/main/java/org/apache/commons/beanutils2/converters/UUIDConverter.java
index 415d49c..c2f09e6 100644
--- a/src/main/java/org/apache/commons/beanutils2/converters/UUIDConverter.java
+++ b/src/main/java/org/apache/commons/beanutils2/converters/UUIDConverter.java
@@ -23,7 +23,7 @@
  * to and from <b>java.util.UUID</b> objects.
  * <p>
  * Can be configured to either return a <i>default value</i> or throw a
- * <code>ConversionException</code> if a conversion error occurs.
+ * {@code ConversionException} if a conversion error occurs.
  *
  * @since 2.0
  */
@@ -31,7 +31,7 @@
 
     /**
      * Construct a <b>java.util.UUID</b> <i>Converter</i> that throws
-     * a <code>ConversionException</code> if an error occurs.
+     * a {@code ConversionException} if an error occurs.
      */
     public UUIDConverter() {
         super();
@@ -50,9 +50,9 @@
     }
 
     /**
-     * Return the default type this <code>Converter</code> handles.
+     * Return the default type this {@code Converter} handles.
      *
-     * @return The default type this <code>Converter</code> handles.
+     * @return The default type this {@code Converter} handles.
      * @since 2.0
      */
     @Override
diff --git a/src/main/java/org/apache/commons/beanutils2/converters/YearConverter.java b/src/main/java/org/apache/commons/beanutils2/converters/YearConverter.java
index 6055265..89395ba 100644
--- a/src/main/java/org/apache/commons/beanutils2/converters/YearConverter.java
+++ b/src/main/java/org/apache/commons/beanutils2/converters/YearConverter.java
@@ -23,7 +23,7 @@
  * to and from <b>java.time.Year</b> objects.
  * <p>
  * Can be configured to either return a <i>default value</i> or throw a
- * <code>ConversionException</code> if a conversion error occurs.
+ * {@code ConversionException} if a conversion error occurs.
  * </p>
  *
  * @since 2.0
@@ -33,7 +33,7 @@
 
     /**
      * Construct a <b>java.time.Year</b> <i>Converter</i> that throws
-     * a <code>ConversionException</code> if an error occurs.
+     * a {@code ConversionException} if an error occurs.
      */
     public YearConverter() {
         super();
@@ -52,9 +52,9 @@
     }
 
     /**
-     * Return the default type this <code>Converter</code> handles.
+     * Return the default type this {@code Converter} handles.
      *
-     * @return The default type this <code>Converter</code> handles.
+     * @return The default type this {@code Converter} handles.
      * @since 2.0
      */
     @Override
diff --git a/src/main/java/org/apache/commons/beanutils2/converters/YearMonthConverter.java b/src/main/java/org/apache/commons/beanutils2/converters/YearMonthConverter.java
index c89a53a..a47e9f6 100644
--- a/src/main/java/org/apache/commons/beanutils2/converters/YearMonthConverter.java
+++ b/src/main/java/org/apache/commons/beanutils2/converters/YearMonthConverter.java
@@ -23,7 +23,7 @@
  * to and from <b>java.time.YearMonth</b> objects.
  * <p>
  * Can be configured to either return a <i>default value</i> or throw a
- * <code>ConversionException</code> if a conversion error occurs.
+ * {@code ConversionException} if a conversion error occurs.
  * </p>
  *
  * @since 2.0
@@ -33,7 +33,7 @@
 
     /**
      * Construct a <b>java.time.YearMonth</b> <i>Converter</i> that throws
-     * a <code>ConversionException</code> if an error occurs.
+     * a {@code ConversionException} if an error occurs.
      */
     public YearMonthConverter() {
         super();
@@ -52,9 +52,9 @@
     }
 
     /**
-     * Return the default type this <code>Converter</code> handles.
+     * Return the default type this {@code Converter} handles.
      *
-     * @return The default type this <code>Converter</code> handles.
+     * @return The default type this {@code Converter} handles.
      * @since 2.0
      */
     @Override
diff --git a/src/main/java/org/apache/commons/beanutils2/converters/ZoneIdConverter.java b/src/main/java/org/apache/commons/beanutils2/converters/ZoneIdConverter.java
index 90f3e8e..f5e5928 100644
--- a/src/main/java/org/apache/commons/beanutils2/converters/ZoneIdConverter.java
+++ b/src/main/java/org/apache/commons/beanutils2/converters/ZoneIdConverter.java
@@ -23,7 +23,7 @@
  * to and from <b>java.time.ZoneId</b> objects.
  * <p>
  * Can be configured to either return a <i>default value</i> or throw a
- * <code>ConversionException</code> if a conversion error occurs.
+ * {@code ConversionException} if a conversion error occurs.
  * </p>
  *
  * @since 2.0
@@ -33,7 +33,7 @@
 
     /**
      * Construct a <b>java.time.ZoneId</b> <i>Converter</i> that throws
-     * a <code>ConversionException</code> if an error occurs.
+     * a {@code ConversionException} if an error occurs.
      */
     public ZoneIdConverter() {
         super();
@@ -52,9 +52,9 @@
     }
 
     /**
-     * Return the default type this <code>Converter</code> handles.
+     * Return the default type this {@code Converter} handles.
      *
-     * @return The default type this <code>Converter</code> handles.
+     * @return The default type this {@code Converter} handles.
      * @since 2.0
      */
     @Override
diff --git a/src/main/java/org/apache/commons/beanutils2/converters/ZoneOffsetConverter.java b/src/main/java/org/apache/commons/beanutils2/converters/ZoneOffsetConverter.java
index eeaccc5..00133ca 100644
--- a/src/main/java/org/apache/commons/beanutils2/converters/ZoneOffsetConverter.java
+++ b/src/main/java/org/apache/commons/beanutils2/converters/ZoneOffsetConverter.java
@@ -23,7 +23,7 @@
  * to and from <b>java.time.ZoneOffset</b> objects.
  * <p>
  * Can be configured to either return a <i>default value</i> or throw a
- * <code>ConversionException</code> if a conversion error occurs.
+ * {@code ConversionException} if a conversion error occurs.
  * </p>
  *
  * @since 2.0
@@ -33,7 +33,7 @@
 
     /**
      * Construct a <b>java.time.ZoneOffset</b> <i>Converter</i> that throws
-     * a <code>ConversionException</code> if an error occurs.
+     * a {@code ConversionException} if an error occurs.
      */
     public ZoneOffsetConverter() {
         super();
@@ -52,9 +52,9 @@
     }
 
     /**
-     * Return the default type this <code>Converter</code> handles.
+     * Return the default type this {@code Converter} handles.
      *
-     * @return The default type this <code>Converter</code> handles.
+     * @return The default type this {@code Converter} handles.
      * @since 2.0
      */
     @Override
diff --git a/src/main/java/org/apache/commons/beanutils2/converters/ZonedDateTimeConverter.java b/src/main/java/org/apache/commons/beanutils2/converters/ZonedDateTimeConverter.java
index d95e545..c1c9f1e 100644
--- a/src/main/java/org/apache/commons/beanutils2/converters/ZonedDateTimeConverter.java
+++ b/src/main/java/org/apache/commons/beanutils2/converters/ZonedDateTimeConverter.java
@@ -29,7 +29,7 @@
  * </p>
  * <p>
  * Can be configured to either return a <i>default value</i> or throw a
- * <code>ConversionException</code> if a conversion error occurs.
+ * {@code ConversionException} if a conversion error occurs.
  * </p>
  *
  * @since 2.0
@@ -39,7 +39,7 @@
 
     /**
      * Construct a <b>java.time.ZonedDateTime</b> <i>Converter</i> that throws
-     * a <code>ConversionException</code> if an error occurs.
+     * a {@code ConversionException} if an error occurs.
      */
     public ZonedDateTimeConverter() {
         super();
@@ -58,9 +58,9 @@
     }
 
     /**
-     * Return the default type this <code>Converter</code> handles.
+     * Return the default type this {@code Converter} handles.
      *
-     * @return The default type this <code>Converter</code> handles.
+     * @return The default type this {@code Converter} handles.
      */
     @Override
     protected Class<?> getDefaultType() {
diff --git a/src/main/java/org/apache/commons/beanutils2/expression/DefaultResolver.java b/src/main/java/org/apache/commons/beanutils2/expression/DefaultResolver.java
index e65257c..745d0c4 100644
--- a/src/main/java/org/apache/commons/beanutils2/expression/DefaultResolver.java
+++ b/src/main/java/org/apache/commons/beanutils2/expression/DefaultResolver.java
@@ -22,31 +22,31 @@
  * This class assists in resolving property names in the following five formats,
  * with the layout of an identifying String in parentheses:
  * <ul>
- * <li><strong>Simple (<code>name</code>)</strong> - The specified
- *     <code>name</code> identifies an individual property of a particular
+ * <li><strong>Simple ({@code name})</strong> - The specified
+ *     {@code name} identifies an individual property of a particular
  *     JavaBean.  The name of the actual getter or setter method to be used
  *     is determined using standard JavaBeans introspection, so that (unless
- *     overridden by a <code>BeanInfo</code> class, a property named "xyz"
- *     will have a getter method named <code>getXyz()</code> or (for boolean
- *     properties only) <code>isXyz()</code>, and a setter method named
- *     <code>setXyz()</code>.</li>
- * <li><strong>Nested (<code>name1.name2.name3</code>)</strong> The first
+ *     overridden by a {@code BeanInfo} class, a property named "xyz"
+ *     will have a getter method named {@code getXyz()} or (for boolean
+ *     properties only) {@code isXyz()}, and a setter method named
+ *     {@code setXyz()}.</li>
+ * <li><strong>Nested ({@code name1.name2.name3})</strong> The first
  *     name element is used to select a property getter, as for simple
  *     references above.  The object returned for this property is then
  *     consulted, using the same approach, for a property getter for a
- *     property named <code>name2</code>, and so on.  The property value that
+ *     property named {@code name2}, and so on.  The property value that
  *     is ultimately retrieved or modified is the one identified by the
  *     last name element.</li>
- * <li><strong>Indexed (<code>name[index]</code>)</strong> - The underlying
+ * <li><strong>Indexed ({@code name[index]})</strong> - The underlying
  *     property value is assumed to be an array, or this JavaBean is assumed
  *     to have indexed property getter and setter methods.  The appropriate
- *     (zero-relative) entry in the array is selected.  <code>List</code>
+ *     (zero-relative) entry in the array is selected.  {@code List}
  *     objects are now also supported for read/write.  You simply need to define
- *     a getter that returns the <code>List</code></li>
- * <li><strong>Mapped (<code>name(key)</code>)</strong> - The JavaBean
+ *     a getter that returns the {@code List}</li>
+ * <li><strong>Mapped ({@code name(key)})</strong> - The JavaBean
  *     is assumed to have an property getter and setter methods with an
- *     additional attribute of type <code>java.lang.String</code>.</li>
- * <li><strong>Combined (<code>name1.name2[index].name3(key)</code>)</strong> -
+ *     additional attribute of type {@code java.lang.String}.</li>
+ * <li><strong>Combined ({@code name1.name2[index].name3(key)})</strong> -
  *     Combining mapped, nested, and indexed references is also
  *     supported.</li>
  * </ul>
@@ -107,7 +107,7 @@
     }
 
     /**
-     * Return the map key from the property expression or <code>null</code>.
+     * Return the map key from the property expression or {@code null}.
      *
      * @param expression The property expression
      * @return The index value
@@ -174,8 +174,8 @@
      * Indicate whether the expression is for an indexed property or not.
      *
      * @param expression The property expression
-     * @return <code>true</code> if the expression is indexed,
-     *  otherwise <code>false</code>
+     * @return {@code true} if the expression is indexed,
+     *  otherwise {@code false}
      */
     @Override
     public boolean isIndexed(final String expression) {
@@ -197,8 +197,8 @@
      * Indicate whether the expression is for a mapped property or not.
      *
      * @param expression The property expression
-     * @return <code>true</code> if the expression is mapped,
-     *  otherwise <code>false</code>
+     * @return {@code true} if the expression is mapped,
+     *  otherwise {@code false}
      */
     @Override
     public boolean isMapped(final String expression) {
diff --git a/src/main/java/org/apache/commons/beanutils2/expression/Resolver.java b/src/main/java/org/apache/commons/beanutils2/expression/Resolver.java
index 8583d34..5748f92 100644
--- a/src/main/java/org/apache/commons/beanutils2/expression/Resolver.java
+++ b/src/main/java/org/apache/commons/beanutils2/expression/Resolver.java
@@ -19,8 +19,8 @@
 /**
  * Property Name Expression Resolver.
  * <p>
- * Methods such as PropertyUtilsBean's <code>setNestedProperty()</code> method
- * use a <code>Resolver</code> to process a <i>property name</i>
+ * Methods such as PropertyUtilsBean's {@code setNestedProperty()} method
+ * use a {@code Resolver} to process a <i>property name</i>
  * expression and resolve <i>nested</i>, <i>indexed</i> and <i>mapped</i>
  * property names. The following code provides an example usage
  * demonstrating all the methods:
@@ -56,7 +56,7 @@
  * </pre>
  *
  * In order to create an implementation, it is important to understand how
- * BeanUtils/PropertyUtils uses the <code>resolver</code>. The following are
+ * BeanUtils/PropertyUtils uses the {@code resolver}. The following are
  * the main methods that use it:
  * <ul>
  *   <li>{@link org.apache.commons.beanutils2.PropertyUtilsBean}
@@ -102,7 +102,7 @@
     int getIndex(String expression);
 
     /**
-     * Extract the map key from the property expression or <code>null</code>.
+     * Extract the map key from the property expression or {@code null}.
      *
      * @param expression The property expression
      * @return The index value
@@ -131,8 +131,8 @@
      * Indicate whether the expression is for an indexed property or not.
      *
      * @param expression The property expression
-     * @return <code>true</code> if the expression is indexed,
-     *  otherwise <code>false</code>
+     * @return {@code true} if the expression is indexed,
+     *  otherwise {@code false}
      */
     boolean isIndexed(String expression);
 
@@ -140,8 +140,8 @@
      * Indicate whether the expression is for a mapped property or not.
      *
      * @param expression The property expression
-     * @return <code>true</code> if the expression is mapped,
-     *  otherwise <code>false</code>
+     * @return {@code true} if the expression is mapped,
+     *  otherwise {@code false}
      */
     boolean isMapped(String expression);
 
diff --git a/src/main/java/org/apache/commons/beanutils2/locale/BaseLocaleConverter.java b/src/main/java/org/apache/commons/beanutils2/locale/BaseLocaleConverter.java
index 4c6a346..23cccca 100644
--- a/src/main/java/org/apache/commons/beanutils2/locale/BaseLocaleConverter.java
+++ b/src/main/java/org/apache/commons/beanutils2/locale/BaseLocaleConverter.java
@@ -37,7 +37,7 @@
 
 public abstract class BaseLocaleConverter implements LocaleConverter {
 
-    // ----------------------------------------------------- Instance Variables
+    
 
     /** All logging goes through this logger */
     private final Log log = LogFactory.getLog(BaseLocaleConverter.class);
@@ -57,7 +57,7 @@
     /** The flag indicating whether the given pattern string is localized or not. */
     protected boolean locPattern = false;
 
-    // ----------------------------------------------------------- Constructors
+    
 
     /**
      * Create a {@link LocaleConverter} that will throw a {@link ConversionException}
@@ -139,7 +139,7 @@
         this.locPattern = locPattern;
     }
 
-    // --------------------------------------------------------- Methods
+    
 
     /**
      * Convert the specified locale-sensitive input object into an output object of the
diff --git a/src/main/java/org/apache/commons/beanutils2/locale/LocaleBeanUtils.java b/src/main/java/org/apache/commons/beanutils2/locale/LocaleBeanUtils.java
index 6b5bfc5..3696bd3 100644
--- a/src/main/java/org/apache/commons/beanutils2/locale/LocaleBeanUtils.java
+++ b/src/main/java/org/apache/commons/beanutils2/locale/LocaleBeanUtils.java
@@ -29,7 +29,7 @@
  * <p>Utility methods for populating JavaBeans properties
  * via reflection in a locale-dependent manner.</p>
  *
- * <p>The implementations for these methods are provided by <code>LocaleBeanUtilsBean</code>.
+ * <p>The implementations for these methods are provided by {@code LocaleBeanUtilsBean}.
  * For more details see {@link LocaleBeanUtilsBean}.</p>
  *
  */
@@ -37,12 +37,12 @@
 public class LocaleBeanUtils extends BeanUtils {
 
 
-    // ----------------------------------------------------- Instance Variables
+    
 
     /**
      * <p>Gets the locale used when no locale is passed.</p>
      *
-     * <p>For more details see <code>LocaleBeanUtilsBean</code></p>
+     * <p>For more details see {@code LocaleBeanUtilsBean}</p>
      *
      * @return the default locale
      * @see LocaleBeanUtilsBean#getDefaultLocale()
@@ -56,7 +56,7 @@
     /**
      * <p>Sets the locale used when no locale is passed.</p>
      *
-     * <p>For more details see <code>LocaleBeanUtilsBean</code></p>
+     * <p>For more details see {@code LocaleBeanUtilsBean}</p>
      *
      * @param locale the default locale
      * @see LocaleBeanUtilsBean#setDefaultLocale(Locale)
@@ -69,10 +69,10 @@
     /**
      * <p>Gets whether the pattern is localized or not.</p>
      *
-     * <p>For more details see <code>LocaleBeanUtilsBean</code></p>
+     * <p>For more details see {@code LocaleBeanUtilsBean}</p>
      *
-     * @return <code>true</code> if pattern is localized,
-     * otherwise <code>false</code>
+     * @return {@code true} if pattern is localized,
+     * otherwise {@code false}
      * @see LocaleBeanUtilsBean#getApplyLocalized()
      */
     public static boolean getApplyLocalized() {
@@ -83,10 +83,10 @@
     /**
      * <p>Sets whether the pattern is localized or not.</p>
      *
-     * <p>For more details see <code>LocaleBeanUtilsBean</code></p>
+     * <p>For more details see {@code LocaleBeanUtilsBean}</p>
      *
-     * @param newApplyLocalized <code>true</code> if pattern is localized,
-     * otherwise <code>false</code>
+     * @param newApplyLocalized {@code true} if pattern is localized,
+     * otherwise {@code false}
      * @see LocaleBeanUtilsBean#setApplyLocalized(boolean)
      */
     public static void setApplyLocalized(final boolean newApplyLocalized) {
@@ -95,16 +95,16 @@
     }
 
 
-    // --------------------------------------------------------- Public Methods
+    
 
     /**
      * <p>Return the value of the specified locale-sensitive indexed property
      * of the specified bean, as a String.</p>
      *
-     * <p>For more details see <code>LocaleBeanUtilsBean</code></p>
+     * <p>For more details see {@code LocaleBeanUtilsBean}</p>
      *
      * @param bean Bean whose property is to be extracted
-     * @param name <code>propertyname[index]</code> of the property value
+     * @param name {@code propertyname[index]} of the property value
      *  to be extracted
      * @param pattern The conversion pattern
      * @return The indexed property's value, converted to a String
@@ -130,10 +130,10 @@
      * of the specified bean, as a String using the default conversion pattern of
      * the corresponding {@link LocaleConverter}.
      *
-     * <p>For more details see <code>LocaleBeanUtilsBean</code></p>
+     * <p>For more details see {@code LocaleBeanUtilsBean}</p>
      *
      * @param bean Bean whose property is to be extracted
-     * @param name <code>propertyname[index]</code> of the property value
+     * @param name {@code propertyname[index]} of the property value
      *  to be extracted
      * @return The indexed property's value, converted to a String
      *
@@ -157,7 +157,7 @@
      * <p>Return the value of the specified locale-sensitive indexed property
      * of the specified bean, as a String using the specified conversion pattern.</p>
      *
-     * <p>For more details see <code>LocaleBeanUtilsBean</code></p>
+     * <p>For more details see {@code LocaleBeanUtilsBean}</p>
      *
      * @param bean Bean whose property is to be extracted
      * @param name Simple property name of the property value to be extracted
@@ -187,7 +187,7 @@
      * of the specified bean, as a String using the default conversion pattern of
      * the corresponding {@link LocaleConverter}.</p>
      *
-     * <p>For more details see <code>LocaleBeanUtilsBean</code></p>
+     * <p>For more details see {@code LocaleBeanUtilsBean}</p>
      *
      * @param bean Bean whose property is to be extracted
      * @param name Simple property name of the property value to be extracted
@@ -215,7 +215,7 @@
      * of the specified bean, converted to a String using the specified
      * conversion pattern.</p>
      *
-     * <p>For more details see <code>LocaleBeanUtilsBean</code></p>
+     * <p>For more details see {@code LocaleBeanUtilsBean}</p>
      *
      * @param bean Bean whose property is to be extracted
      * @param name Name of the property to be extracted
@@ -243,7 +243,7 @@
      * of the specified bean, converted to a String using the default
      * conversion pattern of the corresponding {@link LocaleConverter}.</p>
      *
-     * <p>For more details see <code>LocaleBeanUtilsBean</code></p>
+     * <p>For more details see {@code LocaleBeanUtilsBean}</p>
      *
      * @param bean Bean whose property is to be extracted
      * @param name Name of the property to be extracted
@@ -269,7 +269,7 @@
      * <p>Return the value of the specified mapped locale-sensitive property
      * of the specified bean, as a String using the specified conversion pattern.</p>
      *
-     * <p>For more details see <code>LocaleBeanUtilsBean</code></p>
+     * <p>For more details see {@code LocaleBeanUtilsBean}</p>
      *
      * @param bean Bean whose property is to be extracted
      * @param name Simple property name of the property value to be extracted
@@ -300,7 +300,7 @@
      * The key is specified as a method parameter and must *not* be included
      * in the property name expression.</p>
      *
-     * <p>For more details see <code>LocaleBeanUtilsBean</code></p>
+     * <p>For more details see {@code LocaleBeanUtilsBean}</p>
      *
      * @param bean Bean whose property is to be extracted
      * @param name Simple property name of the property value to be extracted
@@ -329,10 +329,10 @@
      * <p>Return the value of the specified locale-sensitive mapped property
      * of the specified bean, as a String using the specified pattern.</p>
      *
-     * <p>For more details see <code>LocaleBeanUtilsBean</code></p>
+     * <p>For more details see {@code LocaleBeanUtilsBean}</p>
      *
      * @param bean Bean whose property is to be extracted
-     * @param name <code>propertyname(index)</code> of the property value
+     * @param name {@code propertyname(index)} of the property value
      *  to be extracted
      * @param pattern The conversion pattern
      * @return The mapped property's value, converted to a String
@@ -359,10 +359,10 @@
      * of the specified bean, as a String using the default
      * conversion pattern of the corresponding {@link LocaleConverter}.</p>
      *
-     * <p>For more details see <code>LocaleBeanUtilsBean</code></p>
+     * <p>For more details see {@code LocaleBeanUtilsBean}</p>
      *
      * @param bean Bean whose property is to be extracted
-     * @param name <code>propertyname(index)</code> of the property value
+     * @param name {@code propertyname(index)} of the property value
      *  to be extracted
      * @return The mapped property's value, converted to a String
      *
@@ -387,7 +387,7 @@
      * of the specified name, for the specified bean,
      * as a String using the specified pattern.</p>
      *
-     * <p>For more details see <code>LocaleBeanUtilsBean</code></p>
+     * <p>For more details see {@code LocaleBeanUtilsBean}</p>
      *
      * @param bean Bean whose property is to be extracted
      * @param name Possibly nested name of the property to be extracted
@@ -414,7 +414,7 @@
      * <p>Return the value of the (possibly nested) locale-sensitive property
      * of the specified name.</p>
      *
-     * <p>For more details see <code>LocaleBeanUtilsBean</code></p>
+     * <p>For more details see {@code LocaleBeanUtilsBean}</p>
      *
      * @param bean Bean whose property is to be extracted
      * @param name Possibly nested name of the property to be extracted
@@ -440,7 +440,7 @@
      * <p>Return the value of the specified locale-sensitive property
      * of the specified bean.</p>
      *
-     * <p>For more details see <code>LocaleBeanUtilsBean</code></p>
+     * <p>For more details see {@code LocaleBeanUtilsBean}</p>
      *
      * @param bean Bean whose property is to be extracted
      * @param name Possibly indexed and/or nested name of the property
@@ -468,7 +468,7 @@
      * <p>Return the value of the specified locale-sensitive property
      * of the specified bean.</p>
      *
-     * <p>For more details see <code>LocaleBeanUtilsBean</code></p>
+     * <p>For more details see {@code LocaleBeanUtilsBean}</p>
      *
      * @param bean Bean whose property is to be extracted
      * @param name Possibly indexed and/or nested name of the property
@@ -496,7 +496,7 @@
      * conversions as required to conform to the type of the destination property
      * using the default conversion pattern of the corresponding {@link LocaleConverter}.</p>
      *
-     * <p>For more details see <code>LocaleBeanUtilsBean</code></p>
+     * <p>For more details see {@code LocaleBeanUtilsBean}</p>
      *
      * @param bean Bean on which setting is to be performed
      * @param name Property name (can be nested/indexed/mapped/combo)
@@ -520,7 +520,7 @@
      * conversions as required to conform to the type of the destination
      * property using the specified conversion pattern.</p>
      *
-     * <p>For more details see <code>LocaleBeanUtilsBean</code></p>
+     * <p>For more details see {@code LocaleBeanUtilsBean}</p>
      *
      * @param bean Bean on which setting is to be performed
      * @param name Property name (can be nested/indexed/mapped/combo)
@@ -543,7 +543,7 @@
     /**
      * <p>Calculate the property type.</p>
      *
-     * <p>For more details see <code>LocaleBeanUtilsBean</code></p>
+     * <p>For more details see {@code LocaleBeanUtilsBean}</p>
      *
      * @param target The bean
      * @param name The property name
@@ -567,7 +567,7 @@
      * <p>Convert the specified value to the required type using the
      * specified conversion pattern.</p>
      *
-     * <p>For more details see <code>LocaleBeanUtilsBean</code></p>
+     * <p>For more details see {@code LocaleBeanUtilsBean}</p>
      *
      * @param type The Java type of target property
      * @param index The indexed subscript value (if any)
@@ -584,7 +584,7 @@
     /**
      * <p>Convert the specified value to the required type.</p>
      *
-     * <p>For more details see <code>LocaleBeanUtilsBean</code></p>
+     * <p>For more details see {@code LocaleBeanUtilsBean}</p>
      *
      * @param type The Java type of target property
      * @param index The indexed subscript value (if any)
@@ -600,7 +600,7 @@
     /**
      * <p>Invoke the setter method.</p>
      *
-     * <p>For more details see <code>LocaleBeanUtilsBean</code></p>
+     * <p>For more details see {@code LocaleBeanUtilsBean}</p>
      *
      * @param target The bean
      * @param propName The Simple name of target property
diff --git a/src/main/java/org/apache/commons/beanutils2/locale/LocaleBeanUtilsBean.java b/src/main/java/org/apache/commons/beanutils2/locale/LocaleBeanUtilsBean.java
index f14463f..8bad65c 100644
--- a/src/main/java/org/apache/commons/beanutils2/locale/LocaleBeanUtilsBean.java
+++ b/src/main/java/org/apache/commons/beanutils2/locale/LocaleBeanUtilsBean.java
@@ -47,7 +47,7 @@
 public class LocaleBeanUtilsBean extends BeanUtilsBean {
 
     /**
-     * Contains <code>LocaleBeanUtilsBean</code> instances indexed by context classloader.
+     * Contains {@code LocaleBeanUtilsBean} instances indexed by context classloader.
      */
     private static final ContextClassLoaderLocal<LocaleBeanUtilsBean>
             LOCALE_BEANS_BY_CLASSLOADER = new ContextClassLoaderLocal<LocaleBeanUtilsBean>() {
@@ -81,12 +81,12 @@
     /** All logging goes through this logger */
     private final Log log = LogFactory.getLog(LocaleBeanUtilsBean.class);
 
-    // ----------------------------------------------------- Instance Variables
+    
 
     /** Convertor used by this class */
     private final LocaleConvertUtilsBean localeConvertUtils;
 
-    // --------------------------------------------------------- Constructors
+    
 
     /** Construct instance with standard conversion bean */
     public LocaleBeanUtilsBean() {
@@ -96,7 +96,7 @@
     /**
      * Construct instance that uses given locale conversion
      *
-     * @param localeConvertUtils use this <code>localeConvertUtils</code> to perform
+     * @param localeConvertUtils use this {@code localeConvertUtils} to perform
      * conversions
      * @param convertUtilsBean use this for standard conversions
      * @param propertyUtilsBean use this for property conversions
@@ -112,14 +112,14 @@
     /**
      * Construct instance that uses given locale conversion
      *
-     * @param localeConvertUtils use this <code>localeConvertUtils</code> to perform
+     * @param localeConvertUtils use this {@code localeConvertUtils} to perform
      * conversions
      */
     public LocaleBeanUtilsBean(final LocaleConvertUtilsBean localeConvertUtils) {
         this.localeConvertUtils = localeConvertUtils;
     }
 
-    // --------------------------------------------------------- Public Methods
+    
 
     /**
      * Gets the bean instance used for conversions
@@ -154,8 +154,8 @@
      * Is the pattern to be applied localized
      * (Indicate whether the pattern is localized or not)
      *
-     * @return <code>true</code> if pattern is localized,
-     * otherwise <code>false</code>
+     * @return {@code true} if pattern is localized,
+     * otherwise {@code false}
      */
     public boolean getApplyLocalized() {
 
@@ -166,8 +166,8 @@
      * Sets whether the pattern is applied localized
      * (Indicate whether the pattern is localized or not)
      *
-     * @param newApplyLocalized <code>true</code> if pattern is localized,
-     * otherwise <code>false</code>
+     * @param newApplyLocalized {@code true} if pattern is localized,
+     * otherwise {@code false}
      */
     public void setApplyLocalized(final boolean newApplyLocalized) {
 
@@ -175,17 +175,17 @@
     }
 
 
-    // --------------------------------------------------------- Public Methods
+    
 
     /**
      * Return the value of the specified locale-sensitive indexed property
      * of the specified bean, as a String. The zero-relative index of the
      * required value must be included (in square brackets) as a suffix to
-     * the property name, or <code>IllegalArgumentException</code> will be
+     * the property name, or {@code IllegalArgumentException} will be
      * thrown.
      *
      * @param bean Bean whose property is to be extracted
-     * @param name <code>propertyname[index]</code> of the property value
+     * @param name {@code propertyname[index]} of the property value
      *  to be extracted
      * @param pattern The conversion pattern
      * @return The indexed property's value, converted to a String
@@ -215,10 +215,10 @@
      * of the specified bean, as a String using the default conversion pattern of
      * the corresponding {@link LocaleConverter}. The zero-relative index
      * of the required value must be included (in square brackets) as a suffix
-     * to the property name, or <code>IllegalArgumentException</code> will be thrown.
+     * to the property name, or {@code IllegalArgumentException} will be thrown.
      *
      * @param bean Bean whose property is to be extracted
-     * @param name <code>propertyname[index]</code> of the property value
+     * @param name {@code propertyname[index]} of the property value
      *  to be extracted
      * @return The indexed property's value, converted to a String
      *
@@ -411,11 +411,11 @@
      * of the specified bean, as a String using the specified pattern.
      * The String-valued key of the required value
      * must be included (in parentheses) as a suffix to
-     * the property name, or <code>IllegalArgumentException</code> will be
+     * the property name, or {@code IllegalArgumentException} will be
      * thrown.
      *
      * @param bean Bean whose property is to be extracted
-     * @param name <code>propertyname(index)</code> of the property value
+     * @param name {@code propertyname(index)} of the property value
      *  to be extracted
      * @param pattern The conversion pattern
      * @return The mapped property's value, converted to a String
@@ -447,11 +447,11 @@
      * conversion pattern of the corresponding {@link LocaleConverter}.
      * The String-valued key of the required value
      * must be included (in parentheses) as a suffix to
-     * the property name, or <code>IllegalArgumentException</code> will be
+     * the property name, or {@code IllegalArgumentException} will be
      * thrown.
      *
      * @param bean Bean whose property is to be extracted
-     * @param name <code>propertyname(index)</code> of the property value
+     * @param name {@code propertyname(index)} of the property value
      *  to be extracted
      * @return The mapped property's value, converted to a String
      *
diff --git a/src/main/java/org/apache/commons/beanutils2/locale/LocaleConvertUtils.java b/src/main/java/org/apache/commons/beanutils2/locale/LocaleConvertUtils.java
index ebd9dd6..0f2529e 100644
--- a/src/main/java/org/apache/commons/beanutils2/locale/LocaleConvertUtils.java
+++ b/src/main/java/org/apache/commons/beanutils2/locale/LocaleConvertUtils.java
@@ -26,18 +26,18 @@
  *
  * <p>The implementations for these method are provided by {@link LocaleConvertUtilsBean}.
  * These static utility method use the default instance. More sophisticated can be provided
- * by using a <code>LocaleConvertUtilsBean</code> instance.</p>
+ * by using a {@code LocaleConvertUtilsBean} instance.</p>
  *
  */
 public class LocaleConvertUtils {
 
-    // ----------------------------------------------------- Instance Variables
+    
 
     /**
-     * <p>Gets the <code>Locale</code> which will be used when
-     * no <code>Locale</code> is passed to a method.</p>
+     * <p>Gets the {@code Locale} which will be used when
+     * no {@code Locale} is passed to a method.</p>
      *
-     * <p>For more details see <code>LocaleConvertUtilsBean</code></p>
+     * <p>For more details see {@code LocaleConvertUtilsBean}</p>
      * @return the default locale
      * @see LocaleConvertUtilsBean#getDefaultLocale()
      */
@@ -47,10 +47,10 @@
     }
 
     /**
-     * <p>Sets the <code>Locale</code> which will be used when
-     * no <code>Locale</code> is passed to a method.</p>
+     * <p>Sets the {@code Locale} which will be used when
+     * no {@code Locale} is passed to a method.</p>
      *
-     * <p>For more details see <code>LocaleConvertUtilsBean</code></p>
+     * <p>For more details see {@code LocaleConvertUtilsBean}</p>
      *
      * @param locale the default locale
      * @see LocaleConvertUtilsBean#setDefaultLocale(Locale)
@@ -63,10 +63,10 @@
     /**
      * <p>Gets applyLocalized.</p>
      *
-     * <p>For more details see <code>LocaleConvertUtilsBean</code></p>
+     * <p>For more details see {@code LocaleConvertUtilsBean}</p>
      *
-     * @return <code>true</code> if pattern is localized,
-     * otherwise <code>false</code>
+     * @return {@code true} if pattern is localized,
+     * otherwise {@code false}
      * @see LocaleConvertUtilsBean#getApplyLocalized()
      */
     public static boolean getApplyLocalized() {
@@ -76,22 +76,22 @@
     /**
      * <p>Sets applyLocalized.</p>
      *
-     * <p>For more details see <code>LocaleConvertUtilsBean</code></p>
+     * <p>For more details see {@code LocaleConvertUtilsBean}</p>
      *
-     * @param newApplyLocalized <code>true</code> if pattern is localized,
-     * otherwise <code>false</code>
+     * @param newApplyLocalized {@code true} if pattern is localized,
+     * otherwise {@code false}
      * @see LocaleConvertUtilsBean#setApplyLocalized(boolean)
      */
     public static void setApplyLocalized(final boolean newApplyLocalized) {
         LocaleConvertUtilsBean.getInstance().setApplyLocalized(newApplyLocalized);
     }
 
-    // --------------------------------------------------------- Methods
+    
 
     /**
      * <p>Convert the specified locale-sensitive value into a String.</p>
      *
-     * <p>For more details see <code>LocaleConvertUtilsBean</code></p>
+     * <p>For more details see {@code LocaleConvertUtilsBean}</p>
      *
      * @param value The Value to be converted
      * @return the converted value
@@ -105,7 +105,7 @@
      * <p>Convert the specified locale-sensitive value into a String
      * using the conversion pattern.</p>
      *
-     * <p>For more details see <code>LocaleConvertUtilsBean</code></p>
+     * <p>For more details see {@code LocaleConvertUtilsBean}</p>
      *
      * @param value The Value to be converted
      * @param pattern       The conversion pattern
@@ -120,7 +120,7 @@
      * <p>Convert the specified locale-sensitive value into a String
      * using the particular conversion pattern.</p>
      *
-     * <p>For more details see <code>LocaleConvertUtilsBean</code></p>
+     * <p>For more details see {@code LocaleConvertUtilsBean}</p>
      *
      * @param value The Value to be converted
      * @param locale The locale
@@ -137,7 +137,7 @@
      * <p>Convert the specified value to an object of the specified class (if
      * possible).  Otherwise, return a String representation of the value.</p>
      *
-     * <p>For more details see <code>LocaleConvertUtilsBean</code></p>
+     * <p>For more details see {@code LocaleConvertUtilsBean}</p>
      *
      * @param value The String scalar value to be converted
      * @param clazz The Data type to which this value should be converted.
@@ -154,7 +154,7 @@
      * possible) using the conversion pattern. Otherwise, return a String
      * representation of the value.</p>
      *
-     * <p>For more details see <code>LocaleConvertUtilsBean</code></p>
+     * <p>For more details see {@code LocaleConvertUtilsBean}</p>
      *
      * @param value The String scalar value to be converted
      * @param clazz The Data type to which this value should be converted.
@@ -172,7 +172,7 @@
      * possible) using the conversion pattern. Otherwise, return a String
      * representation of the value.</p>
      *
-     * <p>For more details see <code>LocaleConvertUtilsBean</code></p>
+     * <p>For more details see {@code LocaleConvertUtilsBean}</p>
      *
      * @param value The String scalar value to be converted
      * @param clazz The Data type to which this value should be converted.
@@ -190,7 +190,7 @@
      * <p>Convert an array of specified values to an array of objects of the
      * specified class (if possible) using the conversion pattern.</p>
      *
-     * <p>For more details see <code>LocaleConvertUtilsBean</code></p>
+     * <p>For more details see {@code LocaleConvertUtilsBean}</p>
      *
      * @param values Value to be converted (may be null)
      * @param clazz Java array or element class to be converted to
@@ -207,7 +207,7 @@
     * <p>Convert an array of specified values to an array of objects of the
     * specified class (if possible).</p>
     *
-    * <p>For more details see <code>LocaleConvertUtilsBean</code></p>
+    * <p>For more details see {@code LocaleConvertUtilsBean}</p>
     *
     * @param values Value to be converted (may be null)
     * @param clazz Java array or element class to be converted to
@@ -223,7 +223,7 @@
      * <p>Convert an array of specified values to an array of objects of the
      * specified class (if possible) using the conversion pattern.</p>
      *
-     * <p>For more details see <code>LocaleConvertUtilsBean</code></p>
+     * <p>For more details see {@code LocaleConvertUtilsBean}</p>
      *
      * @param values Value to be converted (may be null)
      * @param clazz Java array or element class to be converted to
@@ -239,9 +239,9 @@
 
     /**
      * <p>Register a custom {@link LocaleConverter} for the specified destination
-     * <code>Class</code>, replacing any previously registered converter.</p>
+     * {@code Class}, replacing any previously registered converter.</p>
      *
-     * <p>For more details see <code>LocaleConvertUtilsBean</code></p>
+     * <p>For more details see {@code LocaleConvertUtilsBean}</p>
      *
      * @param converter The LocaleConverter to be registered
      * @param clazz The Destination class for conversions performed by this
@@ -257,7 +257,7 @@
     /**
      * <p>Remove any registered {@link LocaleConverter}.</p>
      *
-     * <p>For more details see <code>LocaleConvertUtilsBean</code></p>
+     * <p>For more details see {@code LocaleConvertUtilsBean}</p>
      *
      * @see LocaleConvertUtilsBean#deregister()
      */
@@ -270,7 +270,7 @@
     /**
      * <p>Remove any registered {@link LocaleConverter} for the specified locale.</p>
      *
-     * <p>For more details see <code>LocaleConvertUtilsBean</code></p>
+     * <p>For more details see {@code LocaleConvertUtilsBean}</p>
      *
      * @param locale The locale
      * @see LocaleConvertUtilsBean#deregister(Locale)
@@ -284,7 +284,7 @@
     /**
      * <p>Remove any registered {@link LocaleConverter} for the specified locale and Class.</p>
      *
-     * <p>For more details see <code>LocaleConvertUtilsBean</code></p>
+     * <p>For more details see {@code LocaleConvertUtilsBean}</p>
      *
      * @param clazz Class for which to remove a registered Converter
      * @param locale The locale
@@ -298,9 +298,9 @@
     /**
      * <p>Look up and return any registered {@link LocaleConverter} for the specified
      * destination class and locale; if there is no registered Converter, return
-     * <code>null</code>.</p>
+     * {@code null}.</p>
      *
-     * <p>For more details see <code>LocaleConvertUtilsBean</code></p>
+     * <p>For more details see {@code LocaleConvertUtilsBean}</p>
      *
      * @param clazz Class for which to return a registered Converter
      * @param locale The Locale
diff --git a/src/main/java/org/apache/commons/beanutils2/locale/LocaleConvertUtilsBean.java b/src/main/java/org/apache/commons/beanutils2/locale/LocaleConvertUtilsBean.java
index 29d0c1e..2cb5f3d 100644
--- a/src/main/java/org/apache/commons/beanutils2/locale/LocaleConvertUtilsBean.java
+++ b/src/main/java/org/apache/commons/beanutils2/locale/LocaleConvertUtilsBean.java
@@ -92,7 +92,7 @@
         return LocaleBeanUtilsBean.getLocaleBeanUtilsInstance().getLocaleConvertUtils();
     }
 
-    // ----------------------------------------------------- Instance Variables
+    
 
     /** The locale - default for conversion. */
     private Locale defaultLocale = Locale.getDefault();
@@ -100,7 +100,7 @@
     /** Indicate whether the pattern is localized or not */
     private boolean applyLocalized = false;
 
-    /** The <code>Log</code> instance for this class. */
+    /** The {@code Log} instance for this class. */
     private final Log log = LogFactory.getLog(LocaleConvertUtilsBean.class);
 
     /** Every entry of the mapConverters is:
@@ -109,7 +109,7 @@
      */
     private final DelegateFastHashMap mapConverters = new DelegateFastHashMap(BeanUtils.createCache());
 
-    // --------------------------------------------------------- Constructors
+    
 
     /**
      *  Makes the state by default (deregisters all converters for all locales)
@@ -121,7 +121,7 @@
         mapConverters.setFast(true);
     }
 
-    // --------------------------------------------------------- Properties
+    
 
     /**
      * getter for defaultLocale.
@@ -149,8 +149,8 @@
     /**
      * getter for applyLocalized
      *
-     * @return <code>true</code> if pattern is localized,
-     * otherwise <code>false</code>
+     * @return {@code true} if pattern is localized,
+     * otherwise {@code false}
      */
     public boolean getApplyLocalized() {
         return applyLocalized;
@@ -159,14 +159,14 @@
     /**
      * setter for applyLocalized
      *
-     * @param newApplyLocalized <code>true</code> if pattern is localized,
-     * otherwise <code>false</code>
+     * @param newApplyLocalized {@code true} if pattern is localized,
+     * otherwise {@code false}
      */
     public void setApplyLocalized(final boolean newApplyLocalized) {
         applyLocalized = newApplyLocalized;
     }
 
-    // --------------------------------------------------------- Methods
+    
 
     /**
      * Convert the specified locale-sensitive value into a String.
@@ -353,7 +353,7 @@
 
     /**
      * Register a custom {@link LocaleConverter} for the specified destination
-     * <code>Class</code>, replacing any previously registered converter.
+     * {@code Class}, replacing any previously registered converter.
      *
      * @param converter The LocaleConverter to be registered
      * @param clazz The Destination class for conversions performed by this
@@ -406,7 +406,7 @@
     /**
      * Look up and return any registered {@link LocaleConverter} for the specified
      * destination class and locale; if there is no registered Converter, return
-     * <code>null</code>.
+     * {@code null}.
      *
      * @param clazz Class for which to return a registered Converter
      * @param locale The Locale
@@ -425,7 +425,7 @@
 
     /**
      * Look up and return any registered map instance for the specified locale;
-     * if there is no registered one, return <code>null</code>.
+     * if there is no registered one, return {@code null}.
      *
      * @param locale The Locale
      * @return The map instance contains the all {@link LocaleConverter} types for
diff --git a/src/main/java/org/apache/commons/beanutils2/locale/converters/BigDecimalLocaleConverter.java b/src/main/java/org/apache/commons/beanutils2/locale/converters/BigDecimalLocaleConverter.java
index aa97d4c..e93ca81 100644
--- a/src/main/java/org/apache/commons/beanutils2/locale/converters/BigDecimalLocaleConverter.java
+++ b/src/main/java/org/apache/commons/beanutils2/locale/converters/BigDecimalLocaleConverter.java
@@ -26,7 +26,7 @@
 /**
  * <p>Standard {@link org.apache.commons.beanutils2.locale.LocaleConverter}
  * implementation that converts an incoming
- * locale-sensitive String into a <code>java.math.BigDecimal</code> object,
+ * locale-sensitive String into a {@code java.math.BigDecimal} object,
  * optionally using a default value or throwing a
  * {@link org.apache.commons.beanutils2.ConversionException}
  * if a conversion error occurs.</p>
@@ -35,7 +35,7 @@
 
 public class BigDecimalLocaleConverter extends DecimalLocaleConverter {
 
-    // ----------------------------------------------------------- Constructors
+    
 
     /**
      * Create a {@link org.apache.commons.beanutils2.locale.LocaleConverter}
diff --git a/src/main/java/org/apache/commons/beanutils2/locale/converters/BigIntegerLocaleConverter.java b/src/main/java/org/apache/commons/beanutils2/locale/converters/BigIntegerLocaleConverter.java
index 54dc248..41678c3 100644
--- a/src/main/java/org/apache/commons/beanutils2/locale/converters/BigIntegerLocaleConverter.java
+++ b/src/main/java/org/apache/commons/beanutils2/locale/converters/BigIntegerLocaleConverter.java
@@ -26,7 +26,7 @@
 /**
  * <p>Standard {@link org.apache.commons.beanutils2.locale.LocaleConverter}
  * implementation that converts an incoming
- * locale-sensitive String into a <code>java.math.BigInteger</code> object,
+ * locale-sensitive String into a {@code java.math.BigInteger} object,
  * optionally using a default value or throwing a
  * {@link org.apache.commons.beanutils2.ConversionException}
  * if a conversion error occurs.</p>
@@ -36,7 +36,7 @@
 public class BigIntegerLocaleConverter extends DecimalLocaleConverter {
 
 
-    // ----------------------------------------------------------- Constructors
+    
 
     /**
      * Create a {@link org.apache.commons.beanutils2.locale.LocaleConverter}
diff --git a/src/main/java/org/apache/commons/beanutils2/locale/converters/ByteLocaleConverter.java b/src/main/java/org/apache/commons/beanutils2/locale/converters/ByteLocaleConverter.java
index e17d671..8226c5f 100644
--- a/src/main/java/org/apache/commons/beanutils2/locale/converters/ByteLocaleConverter.java
+++ b/src/main/java/org/apache/commons/beanutils2/locale/converters/ByteLocaleConverter.java
@@ -26,7 +26,7 @@
 /**
  * <p>Standard {@link org.apache.commons.beanutils2.locale.LocaleConverter}
  * implementation that converts an incoming
- * locale-sensitive String into a <code>java.lang.Byte</code> object,
+ * locale-sensitive String into a {@code java.lang.Byte} object,
  * optionally using a default value or throwing a
  * {@link org.apache.commons.beanutils2.ConversionException}
  * if a conversion error occurs.</p>
@@ -36,7 +36,7 @@
 public class ByteLocaleConverter extends DecimalLocaleConverter {
 
 
-    // ----------------------------------------------------------- Constructors
+    
 
     /**
      * Create a {@link org.apache.commons.beanutils2.locale.LocaleConverter}
diff --git a/src/main/java/org/apache/commons/beanutils2/locale/converters/DateLocaleConverter.java b/src/main/java/org/apache/commons/beanutils2/locale/converters/DateLocaleConverter.java
index 6af68f6..620c8c5 100644
--- a/src/main/java/org/apache/commons/beanutils2/locale/converters/DateLocaleConverter.java
+++ b/src/main/java/org/apache/commons/beanutils2/locale/converters/DateLocaleConverter.java
@@ -33,7 +33,7 @@
 /**
  * <p>Standard {@link org.apache.commons.beanutils2.locale.LocaleConverter}
  * implementation that converts an incoming
- * locale-sensitive String into a <code>java.util.Date</code> object,
+ * locale-sensitive String into a {@code java.util.Date} object,
  * optionally using a default value or throwing a
  * {@link org.apache.commons.beanutils2.ConversionException}
  * if a conversion error occurs.</p>
@@ -42,7 +42,7 @@
 
 public class DateLocaleConverter extends BaseLocaleConverter {
 
-    // ----------------------------------------------------- Instance Variables
+    
 
     /** All logging goes through this logger */
     private final Log log = LogFactory.getLog(DateLocaleConverter.class);
@@ -56,7 +56,7 @@
      */
     private static final String DEFAULT_PATTERN_CHARS = DateLocaleConverter.initDefaultChars();
 
-    // ----------------------------------------------------------- Constructors
+    
 
     /**
      * Create a {@link org.apache.commons.beanutils2.locale.LocaleConverter}
@@ -221,12 +221,12 @@
         super(defaultValue, locale, pattern, locPattern);
     }
 
-    // --------------------------------------------------------- Methods
+    
 
     /**
      * Returns whether date formatting is lenient.
      *
-     * @return true if the <code>DateFormat</code> used for formatting is lenient
+     * @return true if the {@code DateFormat} used for formatting is lenient
      * @see java.text.DateFormat#isLenient
      */
     public boolean isLenient() {
@@ -236,14 +236,14 @@
     /**
      * Specify whether or not date-time parsing should be lenient.
      *
-     * @param lenient true if the <code>DateFormat</code> used for formatting should be lenient
+     * @param lenient true if the {@code DateFormat} used for formatting should be lenient
      * @see java.text.DateFormat#setLenient
      */
     public void setLenient(final boolean lenient) {
         isLenient = lenient;
     }
 
-    // --------------------------------------------------------- Methods
+    
 
     /**
      * Convert the specified locale-sensitive input object into an output object of the
diff --git a/src/main/java/org/apache/commons/beanutils2/locale/converters/DecimalLocaleConverter.java b/src/main/java/org/apache/commons/beanutils2/locale/converters/DecimalLocaleConverter.java
index dca8e4d..c998480 100644
--- a/src/main/java/org/apache/commons/beanutils2/locale/converters/DecimalLocaleConverter.java
+++ b/src/main/java/org/apache/commons/beanutils2/locale/converters/DecimalLocaleConverter.java
@@ -30,7 +30,7 @@
 /**
  * <p>Standard {@link org.apache.commons.beanutils2.locale.LocaleConverter}
  * implementation that converts an incoming
- * locale-sensitive String into a <code>java.lang.Number</code> object,
+ * locale-sensitive String into a {@code java.lang.Number} object,
  * optionally using a default value or throwing a
  * {@link org.apache.commons.beanutils2.ConversionException}
  * if a conversion error occurs.</p>
@@ -41,12 +41,12 @@
 public class DecimalLocaleConverter extends BaseLocaleConverter {
 
 
-    // ----------------------------------------------------- Instance Variables
+    
 
     /** All logging goes through this logger */
     private final Log log = LogFactory.getLog(DecimalLocaleConverter.class);
 
-    // ----------------------------------------------------------- Constructors
+    
 
     /**
      * Create a {@link org.apache.commons.beanutils2.locale.LocaleConverter}
@@ -211,7 +211,7 @@
 
     }
 
-    // --------------------------------------------------------- Methods
+    
 
     /**
      * Convert the specified locale-sensitive input object into an output
diff --git a/src/main/java/org/apache/commons/beanutils2/locale/converters/DoubleLocaleConverter.java b/src/main/java/org/apache/commons/beanutils2/locale/converters/DoubleLocaleConverter.java
index 0dd2a92..875d79c 100644
--- a/src/main/java/org/apache/commons/beanutils2/locale/converters/DoubleLocaleConverter.java
+++ b/src/main/java/org/apache/commons/beanutils2/locale/converters/DoubleLocaleConverter.java
@@ -25,7 +25,7 @@
 /**
  * <p>Standard {@link org.apache.commons.beanutils2.locale.LocaleConverter}
  * implementation that converts an incoming
- * locale-sensitive String into a <code>java.lang.Double</code> object,
+ * locale-sensitive String into a {@code java.lang.Double} object,
  * optionally using a default value or throwing a
  * {@link org.apache.commons.beanutils2.ConversionException}
  * if a conversion error occurs.</p>
@@ -35,7 +35,7 @@
 public class DoubleLocaleConverter extends DecimalLocaleConverter {
 
 
-    // ----------------------------------------------------------- Constructors
+    
 
     /**
      * Create a {@link org.apache.commons.beanutils2.locale.LocaleConverter}
diff --git a/src/main/java/org/apache/commons/beanutils2/locale/converters/FloatLocaleConverter.java b/src/main/java/org/apache/commons/beanutils2/locale/converters/FloatLocaleConverter.java
index 21fdb25..6aef50d 100644
--- a/src/main/java/org/apache/commons/beanutils2/locale/converters/FloatLocaleConverter.java
+++ b/src/main/java/org/apache/commons/beanutils2/locale/converters/FloatLocaleConverter.java
@@ -26,7 +26,7 @@
 /**
  * <p>Standard {@link org.apache.commons.beanutils2.locale.LocaleConverter}
  * implementation that converts an incoming
- * locale-sensitive String into a <code>java.math.BigDecimal</code> object,
+ * locale-sensitive String into a {@code java.math.BigDecimal} object,
  * optionally using a default value or throwing a
  * {@link org.apache.commons.beanutils2.ConversionException}
  * if a conversion error occurs.</p>
@@ -36,7 +36,7 @@
 public class FloatLocaleConverter extends DecimalLocaleConverter {
 
 
-    // ----------------------------------------------------------- Constructors
+    
 
     /**
      * Create a {@link org.apache.commons.beanutils2.locale.LocaleConverter}
diff --git a/src/main/java/org/apache/commons/beanutils2/locale/converters/IntegerLocaleConverter.java b/src/main/java/org/apache/commons/beanutils2/locale/converters/IntegerLocaleConverter.java
index 6871fa6..37304aa 100644
--- a/src/main/java/org/apache/commons/beanutils2/locale/converters/IntegerLocaleConverter.java
+++ b/src/main/java/org/apache/commons/beanutils2/locale/converters/IntegerLocaleConverter.java
@@ -26,7 +26,7 @@
 /**
  * <p>Standard {@link org.apache.commons.beanutils2.locale.LocaleConverter}
  * implementation that converts an incoming
- * locale-sensitive String into a <code>java.lang.Integer</code> object,
+ * locale-sensitive String into a {@code java.lang.Integer} object,
  * optionally using a default value or throwing a
  * {@link org.apache.commons.beanutils2.ConversionException}
  * if a conversion error occurs.</p>
@@ -36,7 +36,7 @@
 public class IntegerLocaleConverter extends DecimalLocaleConverter {
 
 
-    // ----------------------------------------------------------- Constructors
+    
 
     /**
      * Create a {@link org.apache.commons.beanutils2.locale.LocaleConverter}
diff --git a/src/main/java/org/apache/commons/beanutils2/locale/converters/LongLocaleConverter.java b/src/main/java/org/apache/commons/beanutils2/locale/converters/LongLocaleConverter.java
index 721464e..3b07fb3 100644
--- a/src/main/java/org/apache/commons/beanutils2/locale/converters/LongLocaleConverter.java
+++ b/src/main/java/org/apache/commons/beanutils2/locale/converters/LongLocaleConverter.java
@@ -24,7 +24,7 @@
 /**
  * <p>Standard {@link org.apache.commons.beanutils2.locale.LocaleConverter}
  * implementation that converts an incoming
- * locale-sensitive String into a <code>java.lang.Long</code> object,
+ * locale-sensitive String into a {@code java.lang.Long} object,
  * optionally using a default value or throwing a
  * {@link org.apache.commons.beanutils2.ConversionException}
  * if a conversion error occurs.</p>
@@ -34,7 +34,7 @@
 public class LongLocaleConverter extends DecimalLocaleConverter {
 
 
-    // ----------------------------------------------------------- Constructors
+    
 
     /**
      * Create a {@link org.apache.commons.beanutils2.locale.LocaleConverter}
diff --git a/src/main/java/org/apache/commons/beanutils2/locale/converters/ShortLocaleConverter.java b/src/main/java/org/apache/commons/beanutils2/locale/converters/ShortLocaleConverter.java
index 59b633a..11d5288 100644
--- a/src/main/java/org/apache/commons/beanutils2/locale/converters/ShortLocaleConverter.java
+++ b/src/main/java/org/apache/commons/beanutils2/locale/converters/ShortLocaleConverter.java
@@ -26,7 +26,7 @@
 /**
  * <p>Standard {@link org.apache.commons.beanutils2.locale.LocaleConverter}
  * implementation that converts an incoming
- * locale-sensitive String into a <code>java.lang.Short</code> object,
+ * locale-sensitive String into a {@code java.lang.Short} object,
  * optionally using a default value or throwing a
  * {@link org.apache.commons.beanutils2.ConversionException}
  * if a conversion error occurs.</p>
@@ -35,7 +35,7 @@
 
 public class ShortLocaleConverter extends DecimalLocaleConverter {
 
-    // ----------------------------------------------------------- Constructors
+    
 
     /**
      * Create a {@link org.apache.commons.beanutils2.locale.LocaleConverter}
diff --git a/src/main/java/org/apache/commons/beanutils2/locale/converters/SqlDateLocaleConverter.java b/src/main/java/org/apache/commons/beanutils2/locale/converters/SqlDateLocaleConverter.java
index da33ab6..d8c0ab1 100644
--- a/src/main/java/org/apache/commons/beanutils2/locale/converters/SqlDateLocaleConverter.java
+++ b/src/main/java/org/apache/commons/beanutils2/locale/converters/SqlDateLocaleConverter.java
@@ -24,7 +24,7 @@
 /**
  * <p>Standard {@link org.apache.commons.beanutils2.locale.LocaleConverter}
  * implementation that converts an incoming
- * locale-sensitive String into a <code>java.sql.Date</code> object,
+ * locale-sensitive String into a {@code java.sql.Date} object,
  * optionally using a default value or throwing a
  * {@link org.apache.commons.beanutils2.ConversionException}
  * if a conversion error occurs.</p>
@@ -34,7 +34,7 @@
 public class SqlDateLocaleConverter extends DateLocaleConverter {
 
 
-    // ----------------------------------------------------------- Constructors
+    
 
     /**
      * Create a {@link org.apache.commons.beanutils2.locale.LocaleConverter}
@@ -199,7 +199,7 @@
     }
 
 
-    // --------------------------------------------------------- Methods
+    
 
     /**
      * Convert the specified locale-sensitive input object into an output object of the
diff --git a/src/main/java/org/apache/commons/beanutils2/locale/converters/SqlTimeLocaleConverter.java b/src/main/java/org/apache/commons/beanutils2/locale/converters/SqlTimeLocaleConverter.java
index 1e94d9c..a0e54de 100644
--- a/src/main/java/org/apache/commons/beanutils2/locale/converters/SqlTimeLocaleConverter.java
+++ b/src/main/java/org/apache/commons/beanutils2/locale/converters/SqlTimeLocaleConverter.java
@@ -24,7 +24,7 @@
 /**
  * <p>Standard {@link org.apache.commons.beanutils2.locale.LocaleConverter}
  * implementation that converts an incoming
- * locale-sensitive String into a <code>java.sql.Time</code> object,
+ * locale-sensitive String into a {@code java.sql.Time} object,
  * optionally using a default value or throwing a
  * {@link org.apache.commons.beanutils2.ConversionException}
  * if a conversion error occurs.</p>
@@ -34,7 +34,7 @@
 public class SqlTimeLocaleConverter extends DateLocaleConverter {
 
 
-    // ----------------------------------------------------------- Constructors
+    
 
     /**
      * Create a {@link org.apache.commons.beanutils2.locale.LocaleConverter}
@@ -198,7 +198,7 @@
         super(defaultValue, locale, pattern, locPattern);
     }
 
-    // --------------------------------------------------------- Methods
+    
 
     /**
      * Convert the specified locale-sensitive input object into an output object of the
diff --git a/src/main/java/org/apache/commons/beanutils2/locale/converters/SqlTimestampLocaleConverter.java b/src/main/java/org/apache/commons/beanutils2/locale/converters/SqlTimestampLocaleConverter.java
index be6f9fe..c8b639b 100644
--- a/src/main/java/org/apache/commons/beanutils2/locale/converters/SqlTimestampLocaleConverter.java
+++ b/src/main/java/org/apache/commons/beanutils2/locale/converters/SqlTimestampLocaleConverter.java
@@ -24,7 +24,7 @@
 /**
  * <p>Standard {@link org.apache.commons.beanutils2.locale.LocaleConverter}
  * implementation that converts an incoming
- * locale-sensitive String into a <code>java.sql.Timestamp</code> object,
+ * locale-sensitive String into a {@code java.sql.Timestamp} object,
  * optionally using a default value or throwing a
  * {@link org.apache.commons.beanutils2.ConversionException}
  * if a conversion error occurs.</p>
@@ -34,7 +34,7 @@
 public class SqlTimestampLocaleConverter extends DateLocaleConverter {
 
 
-    // ----------------------------------------------------------- Constructors
+    
 
     /**
      * Create a {@link org.apache.commons.beanutils2.locale.LocaleConverter}
@@ -197,7 +197,7 @@
         super(defaultValue, locale, pattern, locPattern);
     }
 
-    // --------------------------------------------------------- Methods
+    
 
     /**
      * Convert the specified locale-sensitive input object into an output object of the
diff --git a/src/main/java/org/apache/commons/beanutils2/locale/converters/StringLocaleConverter.java b/src/main/java/org/apache/commons/beanutils2/locale/converters/StringLocaleConverter.java
index 82e1e8b..ba354fe 100644
--- a/src/main/java/org/apache/commons/beanutils2/locale/converters/StringLocaleConverter.java
+++ b/src/main/java/org/apache/commons/beanutils2/locale/converters/StringLocaleConverter.java
@@ -35,7 +35,7 @@
 /**
  * <p>Standard {@link org.apache.commons.beanutils2.locale.LocaleConverter}
  * implementation that converts an incoming
- * locale-sensitive object into a <code>java.lang.String</code> object,
+ * locale-sensitive object into a {@code java.lang.String} object,
  * optionally using a default value or throwing a
  * {@link org.apache.commons.beanutils2.ConversionException}
  * if a conversion error occurs.</p>
@@ -44,13 +44,13 @@
 
 public class StringLocaleConverter extends BaseLocaleConverter {
 
-    // ----------------------------------------------------- Instance Variables
+    
 
     /** All logging goes through this logger */
     private final Log log = LogFactory.getLog(StringLocaleConverter.class);     //msz fix
 
 
-    // ----------------------------------------------------------- Constructors
+    
 
     /**
      * Create a {@link org.apache.commons.beanutils2.locale.LocaleConverter}
@@ -214,7 +214,7 @@
         super(defaultValue, locale, pattern, locPattern);
     }
 
-    // --------------------------------------------------------- Methods
+    
 
     /**
      * Convert the specified locale-sensitive input object into an output object of the
diff --git a/src/main/java/org/apache/commons/beanutils2/package-info.java b/src/main/java/org/apache/commons/beanutils2/package-info.java
index c5553e4..5cadc54 100644
--- a/src/main/java/org/apache/commons/beanutils2/package-info.java
+++ b/src/main/java/org/apache/commons/beanutils2/package-info.java
@@ -116,11 +116,11 @@
  * <li>Typically, each bean property will have a public <em>getter</em> and
  *     <em>setter</em> method that are used to retrieve or define the property's
  *     value, respectively.  The JavaBeans Specification defines a design
- *     pattern for these names, using <code>get</code> or <code>set</code> as the
+ *     pattern for these names, using {@code get</code> or <code>set} as the
  *     prefix for the property name with it's first character capitalized.  Thus,
  *     you a JavaBean representing an employee might have
- *     (among others) properties named <code>firstName</code>,
- *     <code>lastName</code>, and <code>hireDate</code>, with method signatures
+ *     (among others) properties named {@code firstName},
+ *     {@code lastName</code>, and <code>hireDate}, with method signatures
  *     like this:
  * <pre>
  *         public class Employee {
@@ -138,7 +138,7 @@
  * </pre></li>
  * <li>As you can see from the above example, there is a special variant allowed
  *     for boolean properties -- you can name the <em>getter</em> method with a
- *     <code>is</code> prefix instead of a <code>get</code> prefix if that makes
+ *     {@code is</code> prefix instead of a <code>get} prefix if that makes
  *     for a more understandable method name.</li>
  * <li>If you have both a <em>getter</em> and a <em>setter</em> method for a
  *     property, the data type returned by the <em>getter</em> must match the
@@ -147,14 +147,14 @@
  *     with the same name, but different property types.</li>
  * <li>It is not required that you provide a <em>getter</em> and a
  *     <em>setter</em> for every property.  In the example above, the
- *     <code>fullName</code> property is read-only, because there is no
+ *     {@code fullName} property is read-only, because there is no
  *     <em>setter</em> method.  It is also possible, but less common, to provide
  *     write-only properties.</li>
  * <li>It is also possible to create a JavaBean where the <em>getter</em> and
  *     <em>setter</em> methods do not match the naming pattern described above.
  *     The standard JavaBeans support classes in the Java language, as well as
  *     all classes in the BeanUtils package, allow you to describe the actual
- *     property method names in a <code>BeanInfo</code> class associated with
+ *     property method names in a {@code BeanInfo} class associated with
  *     your bean class.  See the JavaBeans Specification for full details.</li>
  * <li>The JavaBeans Specification also describes many additional design patterns
  *     for event listeners, wiring JavaBeans together into component hierarchies,
@@ -195,7 +195,7 @@
  * But what happens in more sophisticated environments where you do not
  * necessarily know ahead of time which bean class you are going to be using,
  * or which property you want to retrieve or modify?  The Java language provides
- * classes like <code>java.beans.Introspector</code>, which can examine a Java
+ * classes like {@code java.beans.Introspector}, which can examine a Java
  * class at runtime and identify for you the names of the property getter and
  * setter methods, plus the <em>Reflection</em> capabilities to dynamically call
  * such a method.  However, these APIs can be difficult to use, and expose the
@@ -218,8 +218,8 @@
  * <ul>
  * <li><strong>Simple</strong> - Simple, or scalar, properties have a single
  *     value that may be retrieved or modified.  The underlying property type
- *     might be a Java language primitive (such as <code>int</code>, a simple
- *     object (such as a <code>java.lang.String</code>), or a more complex
+ *     might be a Java language primitive (such as {@code int}, a simple
+ *     object (such as a {@code java.lang.String}), or a more complex
  *     object whose class is defined either by the Java language, by the
  *     application, or by a class library included with the application.</li>
  * <li><strong>Indexed</strong> - An indexed property stores an ordered collection
@@ -228,11 +228,11 @@
  *     entire set of values may be set or retrieved using an array.
  *     As an extension to the JavaBeans specification, the
  *     <em>BeanUtils</em> package considers any property whose underlying data
- *     type is <code>java.util.List</code> (or an implementation of List) to be
+ *     type is {@code java.util.List} (or an implementation of List) to be
  *     indexed as well.</li>
  * <li><strong>Mapped</strong> - As an extension to standard JavaBeans APIs,
  *     the <em>BeanUtils</em> package considers any property whose underlying
- *     value is a <code>java.util.Map</code> to be "mapped".  You can set and
+ *     value is a {@code java.util.Map} to be "mapped".  You can set and
  *     retrieve individual values via a String-valued key.</li>
  * </ul>
  *
@@ -342,7 +342,7 @@
  * really a Java object, and you wish to retrieve a property of <em>that</em>
  * object instead?</p>
  *
- * <p>For example, assume we really wanted the <code>city</code> property of the
+ * <p>For example, assume we really wanted the {@code city} property of the
  * employee's home address.  Using standard Java programming techniques for direct
  * access to the bean properties, we might write:</p>
  *
@@ -402,17 +402,17 @@
  * <p>The key to this extension mechanism is the {@link org.apache.commons.beanutils2.BeanIntrospector}
  * interface. The purpose of an object implementing this interface is to
  * process a specific target class and create corresponding
- * <code>PropertyDescriptor</code> objects for the properties it detects.
+ * {@code PropertyDescriptor} objects for the properties it detects.
  * Per default, BeanUtils uses a {@link org.apache.commons.beanutils2.DefaultBeanIntrospector}
  * object which detects properties compatible with the <em>JavaBeans</em>
  * specification.</p>
  *
- * <p>In order to extend the property discovery mechanism, <code>PropertyUtils</code>
+ * <p>In order to extend the property discovery mechanism, {@code PropertyUtils}
  * offers the {@link org.apache.commons.beanutils2.PropertyUtils#addBeanIntrospector(BeanIntrospector)}
- * method. Here a custom <code>BeanIntrospector</code> implementation can be
+ * method. Here a custom {@code BeanIntrospector} implementation can be
  * passed in. During introspection of a class, this custom introspector is
  * then called, and it can add the properties it has detected to the total
- * result. As an example of such a custom <code>BeanIntrospector</code>
+ * result. As an example of such a custom {@code BeanIntrospector}
  * implementation, BeanUtils ships with the {@link org.apache.commons.beanutils2.FluentPropertyBeanIntrospector}
  * class. This implementation can detect properties whose set methods have a
  * non-void return type - thus enabling support for typical properties in a
@@ -422,27 +422,27 @@
  * <h2>2.5 Suppressing Properties</h2>
  * <p>The mechanism of customizing bean introspection described in the previous
  * section can also be used to suppress specific properties. There is a
- * specialized <code>BeanIntrospector</code> implementation that does exactly
+ * specialized {@code BeanIntrospector} implementation that does exactly
  * this: {@link org.apache.commons.beanutils2.SuppressPropertiesBeanIntrospector}.
  * When creating an instance, a collection with the names of properties that
  * should not be accessible on beans has to be provided. These properties will
- * then be removed if they have been detected by other <code>BeanIntrospector</code>
+ * then be removed if they have been detected by other {@code BeanIntrospector}
  * instances during processing of a bean class.</p>
  *
- * <p>A good use case for suppressing properties is the special <code>class</code>
+ * <p>A good use case for suppressing properties is the special {@code class}
  * property which is per default available for all beans; it is generated from the
- * <code>getClass()</code> method inherited from <code>Object</code> which follows the
+ * {@code getClass()</code> method inherited from <code>Object} which follows the
  * naming conventions for property get methods. Exposing this property in an
  * uncontrolled way can lead to a security vulnerability as it allows access to
  * the class loader. More information can be found at
  * <a href="https://issues.apache.org/jira/browse/BEANUTILS-463">
  * https://issues.apache.org/jira/browse/BEANUTILS-463</a>.</p>
  *
- * <p>Because the <code>class</code> property is undesired in many use cases
- * there is already an instance of <code>SuppressPropertiesBeanIntrospector</code>
+ * <p>Because the {@code class} property is undesired in many use cases
+ * there is already an instance of {@code SuppressPropertiesBeanIntrospector}
  * which is configured to suppress this property. It can be obtained via the
- * <code>SUPPRESS_CLASS</code> constant of
- * <code>SuppressPropertiesBeanIntrospector</code>.</p>
+ * {@code SUPPRESS_CLASS} constant of
+ * {@code SuppressPropertiesBeanIntrospector}.</p>
  *
  * <a id="dynamic"></a>
  * <h1>3. Dynamic Beans (DynaBeans)</h1>
@@ -466,10 +466,10 @@
  * bean class actually implementing the interface's methods, and the associated
  * {@link org.apache.commons.beanutils2.DynaClass} interface that defines the set of
  * properties supported by a particular group of DynaBeans, in much the same way
- * that <code>java.lang.Class</code> defines the set of properties supported by
+ * that {@code java.lang.Class} defines the set of properties supported by
  * all instances of a particular JavaBean class.</p>
  *
- * <p>For example, the <code>Employee</code> class used in the examples above
+ * <p>For example, the {@code Employee} class used in the examples above
  * might be implemented as a DynaBean, rather than as a standard JavaBean.  You
  * can access its properties like this:</p>
  *
@@ -484,7 +484,7 @@
  * <p>One very important convenience feature should be noted:  <em>the
  * PropertyUtils property getter and setter methods understand how to access
  * properties in DynaBeans</em>.  Therefore, if the bean you pass as the first
- * argument to, say, <code>PropertyUtils.getSimpleProperty()</code> is really a
+ * argument to, say, {@code PropertyUtils.getSimpleProperty()} is really a
  * DynaBean implementation, the call will get converted to the appropriate
  * DynaBean getter method transparently.  Thus, you can base your application's
  * dynamic property access totally on the PropertyUtils APIs, if you wish, and
@@ -499,7 +499,7 @@
  * implementations are not sufficient.</p>
  *
  * <a id="dynamic.basic"></a>
- * <h2>3.2 <code>BasicDynaBean</code> and <code>BasicDynaClass</code></h2>
+ * <h2>3.2 {@code BasicDynaBean</code> and <code>BasicDynaClass}</h2>
  *
  * <p>The {@link org.apache.commons.beanutils2.BasicDynaBean} and
  * {@link org.apache.commons.beanutils2.BasicDynaClass} implementation provides a
@@ -520,11 +520,11 @@
  * </pre>
  *
  * <p>Note that the 'dynaBeanClass' argument (in the constructor of
- * <code>BasicDynaClass</code>) can have the value of <code>null</code>.  In this
- * case, the value of <code>dynaClass.getDynaBeanClass</code> will just be the
- * <code>Class</code> for BasicDynaBean.</p>
+ * {@code BasicDynaClass</code>) can have the value of <code>null}.  In this
+ * case, the value of {@code dynaClass.getDynaBeanClass} will just be the
+ * {@code Class} for BasicDynaBean.</p>
  *
- * <p>Next, you use the <code>newInstance()</code> method of this DynaClass to
+ * <p>Next, you use the {@code newInstance()} method of this DynaClass to
  * create new DynaBean instances that conform to this DynaClass, and populate
  * its initial property values (much as you would instantiate a new standard
  * JavaBean and then call its property setters):</p>
@@ -538,25 +538,25 @@
  * </pre>
  *
  * <p>Note that the DynaBean class was declared to be
- * <code>DynaBean</code> instead of <code>BasicDynaBean</code>.  In
+ * {@code DynaBean</code> instead of <code>BasicDynaBean}.  In
  * general, if you are using DynaBeans, you will not want to care about the
  * actual implementation class that is being used -- you only care about
- * declaring that it is a <code>DynaBean</code> so that you can use the
+ * declaring that it is a {@code DynaBean} so that you can use the
  * DynaBean APIs.</p>
  *
  * <p>As stated above, you can pass a DynaBean instance as the first argument
- * to a <code>PropertyUtils</code> method that gets and sets properties, and it
+ * to a {@code PropertyUtils} method that gets and sets properties, and it
  * will be interpreted as you expect -- the dynamic properties of the DynaBean
  * will be retrieved or modified, instead of underlying properties on the
  * actual BasicDynaBean implementation class.</p>
  *
  * <a id="dynamic.resultSet"></a>
- * <h2>3.3 <code>ResultSetDynaClass</code> (Wraps ResultSet in DynaBeans)</h2>
+ * <h2>3.3 {@code ResultSetDynaClass} (Wraps ResultSet in DynaBeans)</h2>
  *
  * <p>A very common use case for DynaBean APIs is to wrap other collections of
  * "stuff" that do not normally present themselves as JavaBeans.  One of the most
  * common collections that would be nice to wrap is the
- * <code>java.sql.ResultSet</code> that is returned when you ask a JDBC driver
+ * {@code java.sql.ResultSet} that is returned when you ask a JDBC driver
  * to perform a SQL SELECT statement.  Commons BeanUtils offers a standard
  * mechanism for making each row of the result set visible as a DynaBean,
  * which you can utilize as shown in this example:</p>
@@ -578,20 +578,20 @@
  *
  *
  * <a id="dynamic.rowSet"></a>
- * <h2>3.4 <code>RowSetDynaClass</code> (Disconnected ResultSet as DynaBeans)</h2>
- * <p>Although <a href="#dynamic.resultSet"><code>ResultSetDynaClass</code></a> is
+ * <h2>3.4 {@code RowSetDynaClass} (Disconnected ResultSet as DynaBeans)</h2>
+ * <p>Although <a href="#dynamic.resultSet">{@code ResultSetDynaClass}</a> is
  * a very useful technique for representing the results of an SQL query as a
  * series of DynaBeans, an important problem is that the underlying
- * <code>ResultSet</code> must remain open throughout the period of time that the
+ * {@code ResultSet} must remain open throughout the period of time that the
  * rows are being processed by your application.  This hinders the ability to use
- * <code>ResultSetDynaClass</code> as a means of communicating information from
+ * {@code ResultSetDynaClass} as a means of communicating information from
  * the model layer to the view layer in a model-view-controller architecture
  * such as that provided by the <a href="http://struts.apache.org/">Struts
  * Framework</a>, because there is no easy mechanism to assure that the result set
- * is finally closed (and the underlying <code>Connection</code> returned to its
+ * is finally closed (and the underlying {@code Connection} returned to its
  * connection pool, if you are using one).</p>
  *
- * <p>The <code>RowSetDynaClass</code> class represents a different approach to
+ * <p>The {@code RowSetDynaClass} class represents a different approach to
  * this problem.  When you construct such an instance, the underlying data is
  * <em>copied</em> into a set of in-memory DynaBeans that represent the result.
  * The advantage of this technique, of course, is that you can immediately close
@@ -602,15 +602,15 @@
  * environments (particularly in web applications), this tradeoff is usually
  * quite beneficial.</p>
  *
- * <p>As an additional benefit, the <code>RowSetDynaClass</code> class is defined
- * to implement <code>java.io.Serializable</code>, so that it (and the
+ * <p>As an additional benefit, the {@code RowSetDynaClass} class is defined
+ * to implement {@code java.io.Serializable}, so that it (and the
  * DynaBeans that correspond to each row of the result) can be conveniently
  * serialized and deserialized (as long as the underlying column values are
- * also Serializable).  Thus, <code>RowSetDynaClass</code> represents a very
+ * also Serializable).  Thus, {@code RowSetDynaClass} represents a very
  * convenient way to transmit the results of an SQL query to a remote Java-based
  * client application (such as an applet).</p>
  *
- * <p>The normal usage pattern for a <code>RowSetDynaClass</code> will look
+ * <p>The normal usage pattern for a {@code RowSetDynaClass} will look
  * something like this:</p>
  * <pre>
  *     Connection conn = ...;  // Acquire connection from pool
@@ -626,10 +626,10 @@
  *
  *
  * <a id="dynamic.wrap"></a>
- * <h2>3.5 <code>WrapDynaBean</code> and <code>WrapDynaClass</code></h2>
+ * <h2>3.5 {@code WrapDynaBean</code> and <code>WrapDynaClass}</h2>
  *
  * <p>OK, you've tried the DynaBeans APIs and they are cool -- very simple
- * <code>get()</code> and <code>set()</code> methods provide easy access to all
+ * {@code get()</code> and <code>set()} methods provide easy access to all
  * of the dynamically defined simple, indexed, and mapped properties of your
  * DynaBeans.  You'd like to use the DynaBean APIs to access <strong>all</strong>
  * of your beans, but you've got a bunch of existing standard JavaBeans classes
@@ -646,7 +646,7 @@
  *     String firstName = wrapper.get("firstName");
  * </pre>
  *
- * <p>Note that, although appropriate <code>WrapDynaClass</code> instances are
+ * <p>Note that, although appropriate {@code WrapDynaClass} instances are
  * created internally, you never need to deal with them.</p>
  *
  * <a id="dynamic.lazy"></a>
@@ -660,7 +660,7 @@
  *          with <i>lazy</i> map/list processing</li>
  *     <li>3. <a href="#LazyDynaList">LazyDynaList</a> - A <i>lazy list</i>
  *          for {@link org.apache.commons.beanutils2.DynaBean DynaBean's},
- *          <code>java.util.Map</code>'s or POJO beans.</li>
+ *          {@code java.util.Map}'s or POJO beans.</li>
  *     <li>4. <a href="#LazyDynaClass">LazyDynaClass</a> - A
  *          {@link org.apache.commons.beanutils2.MutableDynaClass} implementation.</li>
  * </ul>
@@ -675,34 +675,34 @@
  *              interface. This provides the ability to add and remove a DynaClass's
  *              properties. <i>Lazy</i> beans use this feature to automatically add
  *              a property which doesn't exist to the DynaClass when
- *              the <code>set(name, value)</code> method is called.</li>
+ *              the {@code set(name, value)} method is called.</li>
  *          <li><strong><i>Lazy</i> List/Array growth</strong> - If an <i>indexed</i> property is not large
- *              enough to accomodate the <code>index</code> being set then the <code>List</code> or
- *              <code>Array</code> is automatically <i>grown</i> so that it is.</li>
+ *              enough to accomodate the {@code index</code> being set then the <code>List} or
+ *              {@code Array} is automatically <i>grown</i> so that it is.</li>
  *          <li><strong><i>Lazy</i> List/Array instantiation</strong> - if an <i>indexed</i>
  *              property doesn't exist then calling the {@link org.apache.commons.beanutils2.DynaBean DynaBean's}
- *              <i>indexed</i> property getter/setter methods (i.e. <code>get(name, index)</code> or
- *              <code>set(name, index, value)</code>) results in either a new <code>List</code>
- *              or <code>Array</code> being instantiated. If the indexed property has not been
- *              defined in the DynaClass then it is automatically added and a default <code>List</code>
+ *              <i>indexed</i> property getter/setter methods (i.e. {@code get(name, index)} or
+ *              {@code set(name, index, value)</code>) results in either a new <code>List}
+ *              or {@code Array} being instantiated. If the indexed property has not been
+ *              defined in the DynaClass then it is automatically added and a default {@code List}
  *              implementation instantiated.</li>
  *         <li><strong><i>Lazy</i> Map instantiation</strong> - if a <i>mapped</i>
  *              property doesn't exist then calling the {@link org.apache.commons.beanutils2.DynaBean DynaBean's}
- *              <i>mapped</i> property getter/setter methods (i.e. <code>get(name, key)</code> or
- *              <code>set(name, key, value)</code>) results in a new <code>Map</code>
+ *              <i>mapped</i> property getter/setter methods (i.e. {@code get(name, key)} or
+ *              {@code set(name, key, value)</code>) results in a new <code>Map}
  *              being instantiated. If the mapped property has not been defined in the DynaClass
- *              then it is automatically added and a default <code>Map</code> implementation
+ *              then it is automatically added and a default {@code Map} implementation
  *              instantiated.</li>
  *         <li><strong><i>Lazy</i> Bean instantiation</strong> - if a property is defined in
- *              the <code>DynaClass</code> as a <code>DynaBean</code> or regular bean and
- *              doesn't exist in the <code>DynaBean</code> then <code>LazyDynaBean</code> wiill
+ *              the {@code DynaClass</code> as a <code>DynaBean} or regular bean and
+ *              doesn't exist in the {@code DynaBean</code> then <code>LazyDynaBean} wiill
  *              try to instantiate the bean using a default empty constructor.</li>
  *     </ul>
  *
  * <p><strong>1. {@link org.apache.commons.beanutils2.LazyDynaBean}</strong> is the standard <i>lazy</i> bean
  *    implementation. By default it is associated with a {@link org.apache.commons.beanutils2.LazyDynaClass}
  *    which implements the {@link org.apache.commons.beanutils2.MutableDynaClass} interface - however
- *    it can be used with any <code>MutableDynaClass</code> implementation. The question is <i>how do
+ *    it can be used with any {@code MutableDynaClass} implementation. The question is <i>how do
  *    I use it?</i> - well it can be as simple as creating a new bean and then calling the getters/setters...</p>
  *
  * <pre>
@@ -719,15 +719,15 @@
  * </pre>
  *
  * <p><strong>2. {@link org.apache.commons.beanutils2.LazyDynaMap}</strong> is a <i>light weight</i>
- *    <code>DynaBean</code> facade to a <code>Map</code> with all the usual <i>lazy</i> features. Its
- *    <i>light weight</i> because it doesn't have an associated <code>DynaClass</code> containing all the properties.
- *    In fact it actually implements the <code>DynaClass</code> interface itself (and <code>MutableDynaClass</code>)
- *    and derives all the <i>DynaClass</i> information from the actual contents of the <code>Map</code>. A
- *    <code>LazyDynaMap</code> can be created around an existing <code>Map</code> or can instantiate its own
- *    <code>Map</code>. After any <code>DynaBean</code> processing has finished the <code>Map</code> can be retrieved
+ *    {@code DynaBean</code> facade to a <code>Map} with all the usual <i>lazy</i> features. Its
+ *    <i>light weight</i> because it doesn't have an associated {@code DynaClass} containing all the properties.
+ *    In fact it actually implements the {@code DynaClass</code> interface itself (and <code>MutableDynaClass})
+ *    and derives all the <i>DynaClass</i> information from the actual contents of the {@code Map}. A
+ *    {@code LazyDynaMap</code> can be created around an existing <code>Map} or can instantiate its own
+ *    {@code Map</code>. After any <code>DynaBean</code> processing has finished the <code>Map} can be retrieved
  *    and the DynaBean <i>facade</i> discarded.</p>
  *
- * <p>If you need a new <code>Map</code> then to use....</p>
+ * <p>If you need a new {@code Map} then to use....</p>
  *
  * <pre>
  *     DynaBean dynaBean = new LazyDynaMap();        // create DynaBean
@@ -738,7 +738,7 @@
  *
  *     Map myMap = dynaBean.getMap()                 // retrieve the Map
  * </pre>
- * <p><i>or</i> to use with an existing <code>Map</code> ....</p>
+ * <p><i>or</i> to use with an existing {@code Map} ....</p>
  *
  * <pre>
  *     Map myMap = ....                             // exisitng Map
@@ -748,22 +748,22 @@
  *
  * <p><strong>3. {@link org.apache.commons.beanutils2.LazyDynaList}</strong>
  *      is  <i>lazy list</i> for {@link org.apache.commons.beanutils2.DynaBean DynaBeans}
- *      <code>java.util.Map</code>'s or POJO beans. See the <a href="LazyDynaList.html">Javadoc</a>
+ *      {@code java.util.Map}'s or POJO beans. See the <a href="LazyDynaList.html">Javadoc</a>
  *      for more details and example usage.</p>
  *
  * <p><strong>4. {@link org.apache.commons.beanutils2.LazyDynaClass}</strong>
  *      extends {@link org.apache.commons.beanutils2.BasicDynaClass} and implements
  *      the <a href="MutableDynaClass.html">MutableDynaClass</a> interface.
- *      It can be used with other <code>DynaBean</code> implementations, but it
- *      is the default <code>DynaClass</code> used by <code>LazyDynaBean</code>.
- *      When using the <code>LazyDynaBean</code> there may be no need to have
- *      anything to do with the <code>DynaClass</code>. However sometimes there
- *      is a requirement to set up the <code>DynaClass</code> first - perhaps to
+ *      It can be used with other {@code DynaBean} implementations, but it
+ *      is the default {@code DynaClass</code> used by <code>LazyDynaBean}.
+ *      When using the {@code LazyDynaBean} there may be no need to have
+ *      anything to do with the {@code DynaClass}. However sometimes there
+ *      is a requirement to set up the {@code DynaClass} first - perhaps to
  *      define the type of array for an indexed property, or if using the DynaBean
  *      in <i>restricted</i> mode (see note below) is required. Doing so is
  *      straight forward...</p>
  *
- * <p><i>Either</i> create a <code>LazyDynaClass</code> first...
+ * <p><i>Either</i> create a {@code LazyDynaClass} first...
  *
  * <pre>
  *     MutableDynaClass dynaClass = new LazyDynaClass();    // create DynaClass
@@ -775,7 +775,7 @@
  *     DynaBean dynaBean = new LazyDynaBean(dynaClass);     // Create DynaBean with associated DynaClass
  * </pre>
  *
- * <p><i>or</i> create a <code>LazyDynaBean</code> and get the <code>DynaClass</code>...
+ * <p><i>or</i> create a {@code LazyDynaBean</code> and get the <code>DynaClass}...
  *
  * <pre>
  *     DynaBean dynaBean = new LazyDynaBean();              // Create LazyDynaBean
@@ -789,8 +789,8 @@
  *
  * <p><strong>NOTE:</strong> One feature of {@link org.apache.commons.beanutils2.MutableDynaClass} is that it
  *    has a <i>Restricted</i> property. When the DynaClass is <i>restricted</i> no properties can be added
- *    or removed from the <code>DynaClass</code>. Neither the <code>LazyDynaBean</code> or <code>LazyDynaMap</code>
- *    will add properties automatically if the <code>DynaClass</code> is <i>restricted</i>.</p>
+ *    or removed from the {@code DynaClass</code>. Neither the <code>LazyDynaBean</code> or <code>LazyDynaMap}
+ *    will add properties automatically if the {@code DynaClass} is <i>restricted</i>.</p>
  *
  *
  * <a id="conversion"></a>
@@ -807,12 +807,12 @@
  * for performing this task as well.</p>
  *
  * <a id="conversion.beanutils"></a>
- * <h2>4.2 <code>BeanUtils</code> and <code>ConvertUtils</code> Conversions</h2>
+ * <h2>4.2 {@code BeanUtils</code> and <code>ConvertUtils} Conversions</h2>
  *
  * <p>A very common use case (and the situation that caused the initial creation
  * of the <em>BeanUtils</em> package) was the desire to convert the set of request
  * parameters that were included in a
- * <code>javax.servlet.HttpServletRequest</code> received by a web application
+ * {@code javax.servlet.HttpServletRequest} received by a web application
  * into a set of corresponding property setter calls on an arbitrary JavaBean.
  * (This is one of the fundamental services provided by the
  * <a href="http://struts.apache.org/">Struts Framework</a>, which uses
@@ -824,9 +824,9 @@
  * data type.  The {@link org.apache.commons.beanutils2.BeanUtils} class provides
  * property setter methods that accept String values, and automatically convert
  * them to appropriate property types for Java primitives (such as
- * <code>int</code> or <code>boolean</code>), and property getter methods that
- * perform the reverse conversion.  Finally, a <code>populate()</code> method
- * is provided that accepts a <code>java.util.Map</code> containing a set of
+ * {@code int</code> or <code>boolean}), and property getter methods that
+ * perform the reverse conversion.  Finally, a {@code populate()} method
+ * is provided that accepts a {@code java.util.Map} containing a set of
  * property values (keyed by property name), and calls all of the appropriate
  * setters whenever the underlying bean has a property with the same name as
  * one of the request parameters.  So, you can perform the all-in-one property
@@ -844,11 +844,11 @@
  *     BeanUtils.populate(bean, map);
  * </pre>
  *
- * <p>The <code>BeanUtils</code> class relies on conversion methods defined in
+ * <p>The {@code BeanUtils} class relies on conversion methods defined in
  * the {@link org.apache.commons.beanutils2.ConvertUtils} class to perform the actual
  * conversions, and these methods are availablve for direct use as well.
  * <strong>WARNING</strong> - It is likely that the hard coded use of
- * <code>ConvertUtils</code> methods will be deprecated in the future, and
+ * {@code ConvertUtils} methods will be deprecated in the future, and
  * replaced with a mechanism that allows you to plug in your own implementations
  * of the {@link org.apache.commons.beanutils2.Converter} interface instead.  Therefore,
  * new code should not be written with reliance on ConvertUtils.</p>
@@ -856,24 +856,24 @@
  * <a id="conversion.defining"></a>
  * <h2>4.3 Defining Your Own Converters</h2>
  *
- * <p>The <code>ConvertUtils</code> class supports the ability to define and
+ * <p>The {@code ConvertUtils} class supports the ability to define and
  * register your own String --&gt; Object conversions for any given Java class.
  * Once registered, such converters will be used transparently by all of the
- * <code>BeanUtils</code> methods (including <code>populate()</code>).  To
+ * {@code BeanUtils</code> methods (including <code>populate()}).  To
  * create and register your own converter, follow these steps:</p>
  * <ul>
  * <li>Write a class that implements the {@link org.apache.commons.beanutils2.Converter}
- *     interface.  The <code>convert()</code> method should accept the
- *     <code>java.lang.Class</code> object of your application class (i.e.
+ *     interface.  The {@code convert()} method should accept the
+ *     {@code java.lang.Class} object of your application class (i.e.
  *     the class that you want to convert to, and a String representing the
  *     incoming value to be converted.</li>
  * <li>At application startup time, register an instance of your converter class
- *     by calling the <code>ConvertUtils.register()</code> method.</li>
+ *     by calling the {@code ConvertUtils.register()} method.</li>
  * </ul>
  *
  * <a id="conversion.i18n"></a>
  * <h2>4.4 Locale Aware Conversions</h2>
- * <p>The standard classes in <code>org.apache.commons.beanutils2</code> are not
+ * <p>The standard classes in {@code org.apache.commons.beanutils2} are not
  * locale aware. This gives them a cleaner interface and makes then easier to use
  * in situations where the locale is not important.</p>
  * <p>Extended, locale-aware analogues can be found in
@@ -887,8 +887,8 @@
  * <a id="instances.background"></a>
  * <h2>Background</h2>
  * <p>
- * So far, the examples have covered the static utility classes (<code>BeanUtils</code>,
- * <code>ConvertUtils</code> and <code>PropertyUtils</code>). These are easy to use but are
+ * So far, the examples have covered the static utility classes ({@code BeanUtils},
+ * {@code ConvertUtils</code> and <code>PropertyUtils}). These are easy to use but are
  * somewhat inflexible. These all share the same registered converters and the same caches.
  * </p>
  * <p>
@@ -915,21 +915,21 @@
  * <a id="bean-comparator"></a>
  * <h2>6.1 Comparing Beans</h2>
  * <p>
- * <code>org.apache.commons.beanutils2.BeanComparator</code> is a <code>Comparator</code> implementation
+ * {@code org.apache.commons.beanutils2.BeanComparator</code> is a <code>Comparator} implementation
  * that compares beans based on a shared property value.
  * </p>
  * <a id="bean-property-closure"></a>
  * <h2>6.2 Operating On Collections Of Beans</h2>
  * <p>
- * The <code>Closure</code> interface in <code>commons-collections</code> encapsulates a block of code that
- * executes on an arbitrary input Object. <code>Commons-collections</code> contains code that allows
- * <code>Closures</code> to be applied to the contents of a Collection. For more details, see the
+ * The {@code Closure</code> interface in <code>commons-collections} encapsulates a block of code that
+ * executes on an arbitrary input Object. {@code Commons-collections} contains code that allows
+ * {@code Closures} to be applied to the contents of a Collection. For more details, see the
  * <a href='https://commons.apache.org/collections/'>commons-collections</a>
  * documentation.
  * </p>
  * <p>
- * <code>BeanPropertyValueChangeClosure</code> is a <code>Closure</code> that sets a specified property
- * to a particular value. A typical usage is to combine this with <code>commons-collections</code>
+ * {@code BeanPropertyValueChangeClosure</code> is a <code>Closure} that sets a specified property
+ * to a particular value. A typical usage is to combine this with {@code commons-collections}
  * so that all the beans in a collection can have a particular property set to a particular value.
  * </p>
  * <p>For example, set the activeEmployee property to TRUE for an entire collection:</p>
@@ -945,17 +945,17 @@
  * <a id="bean-property-predicate"></a>
  * <h2>6.3 Querying Or Filtering Collections Of Beans</h2>
  * <p>
- * The <code>Predicate</code> interface in <code>commons-collections</code> encapsulates an evaluation
- * of an input Object that returns either true or false. <code>Commons-collections</code> contains code
+ * The {@code Predicate</code> interface in <code>commons-collections} encapsulates an evaluation
+ * of an input Object that returns either true or false. {@code Commons-collections} contains code
  * that allows
- * <code>Predicates</code> to be applied to be used to filter collections. For more details, see the
+ * {@code Predicates} to be applied to be used to filter collections. For more details, see the
  * <a href='https://commons.apache.org/collections/'>commons-collections</a>
  * documentation.
  * </p>
  * <p>
- * <code>BeanPropertyValueEqualsPredicate</code> is a <code>Predicate</code> that evaluates a
+ * {@code BeanPropertyValueEqualsPredicate</code> is a <code>Predicate} that evaluates a
  * set property value against a given value. A typical usage is
- * (in combination with <code>commons-collections</code>)
+ * (in combination with {@code commons-collections})
  * to filter collections on the basis of a property value.
  * </p>
  * <p>For example, to filter a collection to find all beans where active employee is false use:</p>
@@ -970,16 +970,16 @@
  * <a href="bean-property-transformer"></a>
  * <h2>6.4 Transforming Collections Of Beans</h2>
  * <p>
- * The <code>Transformer</code> interface in <code>commons-collections</code> encapsulates the transformation
- * of an input Object into an output object. <code>Commons-collections</code> contains code
+ * The {@code Transformer</code> interface in <code>commons-collections} encapsulates the transformation
+ * of an input Object into an output object. {@code Commons-collections} contains code
  * that allows
- * <code>Transformers</code> to be applied produce a collection of outputs from a collection of inputs.
+ * {@code Transformers} to be applied produce a collection of outputs from a collection of inputs.
  * For more details, see the
  * <a href='https://commons.apache.org/collections/'>commons-collections</a>
  * documentation.
  * </p>
  * <p>
- * <code>BeanToPropertyTransformer</code> is a <code>Transformer</code> implementation
+ * {@code BeanToPropertyTransformer</code> is a <code>Transformer} implementation
  * that transforms a bean into it's property value.
  * </p>
  * <p>
@@ -1006,9 +1006,9 @@
  * <p>There are some subtleties  of this specification that can catch out the unwary:</p>
  * <ul>
  * <li>A property can have only one set and one get method. Overloading is not allowed.</li>
- * <li>The <code>java.beans.Introspector</code> searches widely for a custom <em>BeanInfo</em>
+ * <li>The {@code java.beans.Introspector} searches widely for a custom <em>BeanInfo</em>
  * class. If your class has the same name as another with a custom <em>BeanInfo</em>
- * (typically a java API class) then the <code>Introspector</code> may use that instead of
+ * (typically a java API class) then the {@code Introspector} may use that instead of
  * creating via reflection based on your class. If this happens, the only solution is to
  * create your own <em>BeanInfo</em>.</li>
  * </ul>
diff --git a/src/test/java/org/apache/commons/beanutils2/BasicDynaBeanTestCase.java b/src/test/java/org/apache/commons/beanutils2/BasicDynaBeanTestCase.java
index 16d094c..39dad0c 100644
--- a/src/test/java/org/apache/commons/beanutils2/BasicDynaBeanTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/BasicDynaBeanTestCase.java
@@ -34,8 +34,8 @@
 
 
 /**
- * <p>Test Case for the <code>BasicDynaBean</code> implementation class.
- * These tests were based on the ones in <code>PropertyUtilsTestCase</code>
+ * <p>Test Case for the {@code BasicDynaBean} implementation class.
+ * These tests were based on the ones in {@code PropertyUtilsTestCase}
  * because the two classes provide similar levels of functionality.</p>
  *
  */
@@ -43,7 +43,7 @@
 public class BasicDynaBeanTestCase extends TestCase {
 
 
-    // ---------------------------------------------------- Instance Variables
+    
 
 
     /**
@@ -54,7 +54,7 @@
 
     /**
      * The set of property names we expect to have returned when calling
-     * <code>getDynaProperties()</code>.  You should update this list
+     * {@code getDynaProperties()}.  You should update this list
      * when new properties are added to TestBean.
      */
     protected final static String[] properties = {
@@ -77,7 +77,7 @@
     };
 
 
-    // ---------------------------------------------------------- Constructors
+    
 
 
     /**
@@ -92,7 +92,7 @@
     }
 
 
-    // -------------------------------------------------- Overall Test Methods
+    
 
 
     /**
@@ -166,7 +166,7 @@
 
 
 
-    // ------------------------------------------------ Individual Test Methods
+    
 
 
     /**
@@ -196,7 +196,7 @@
 
 
     /**
-     * Positive getDynaProperty on property <code>booleanProperty</code>.
+     * Positive getDynaProperty on property {@code booleanProperty}.
      */
     public void testGetDescriptorBoolean() {
 
@@ -206,7 +206,7 @@
 
 
     /**
-     * Positive getDynaProperty on property <code>doubleProperty</code>.
+     * Positive getDynaProperty on property {@code doubleProperty}.
      */
     public void testGetDescriptorDouble() {
 
@@ -216,7 +216,7 @@
 
 
     /**
-     * Positive getDynaProperty on property <code>floatProperty</code>.
+     * Positive getDynaProperty on property {@code floatProperty}.
      */
     public void testGetDescriptorFloat() {
 
@@ -226,7 +226,7 @@
 
 
     /**
-     * Positive getDynaProperty on property <code>intProperty</code>.
+     * Positive getDynaProperty on property {@code intProperty}.
      */
     public void testGetDescriptorInt() {
 
@@ -236,7 +236,7 @@
 
 
     /**
-     * Positive getDynaProperty on property <code>longProperty</code>.
+     * Positive getDynaProperty on property {@code longProperty}.
      */
     public void testGetDescriptorLong() {
 
@@ -246,7 +246,7 @@
 
 
     /**
-     * Positive getDynaProperty on property <code>booleanSecond</code>
+     * Positive getDynaProperty on property {@code booleanSecond}
      * that uses an "is" method as the getter.
      */
     public void testGetDescriptorSecond() {
@@ -257,7 +257,7 @@
 
 
     /**
-     * Positive getDynaProperty on property <code>shortProperty</code>.
+     * Positive getDynaProperty on property {@code shortProperty}.
      */
     public void testGetDescriptorShort() {
 
@@ -267,7 +267,7 @@
 
 
     /**
-     * Positive getDynaProperty on property <code>stringProperty</code>.
+     * Positive getDynaProperty on property {@code stringProperty}.
      */
     public void testGetDescriptorString() {
 
@@ -278,7 +278,7 @@
 
     /**
      * Positive test for getDynaPropertys().  Each property name
-     * listed in <code>properties</code> should be returned exactly once.
+     * listed in {@code properties} should be returned exactly once.
      */
     public void testGetDescriptors() {
 
@@ -591,7 +591,7 @@
 
 
     /**
-     * Test <code>contains()</code> method for mapped properties.
+     * Test {@code contains()} method for mapped properties.
      */
     public void testMappedContains() {
 
@@ -614,7 +614,7 @@
 
 
     /**
-     * Test <code>remove()</code> method for mapped properties.
+     * Test {@code remove()} method for mapped properties.
      */
     public void testMappedRemove() {
 
@@ -971,12 +971,12 @@
     }
 
 
-    // ------------------------------------------------------ Protected Methods
+    
 
 
     /**
-     * Create and return a <code>DynaClass</code> instance for our test
-     * <code>DynaBean</code>.
+     * Create and return a {@code DynaClass} instance for our test
+     * {@code DynaBean}.
      */
     protected DynaClass createDynaClass() {
 
diff --git a/src/test/java/org/apache/commons/beanutils2/BeanComparatorTestCase.java b/src/test/java/org/apache/commons/beanutils2/BeanComparatorTestCase.java
index 7c2400f..03552f6 100644
--- a/src/test/java/org/apache/commons/beanutils2/BeanComparatorTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/BeanComparatorTestCase.java
@@ -28,7 +28,7 @@
  */
 public class BeanComparatorTestCase extends TestCase {
 
-    // ---------------------------------------------------- Instance Variables
+    
 
     /**
      * The test beans for each test.
@@ -37,7 +37,7 @@
     protected AlphaBean alphaBean1 = null;
     protected AlphaBean alphaBean2 = null;
 
-    // ---------------------------------------------------------- Constructors
+    
 
     /**
      * Constructs a new instance of this test case.
@@ -48,7 +48,7 @@
         super(name);
     }
 
-    // -------------------------------------------------- Overall Test Methods
+    
 
     /**
      * Sets up instance variables required by this test case.
@@ -78,7 +78,7 @@
         alphaBean2 = null;
     }
 
-    // ------------------------------------------------ Individual Test Methods
+    
 
     /**
      *  Tests comparing two beans via their name using the default Comparator
diff --git a/src/test/java/org/apache/commons/beanutils2/BeanPropertyValueChangeConsumerTestCase.java b/src/test/java/org/apache/commons/beanutils2/BeanPropertyValueChangeConsumerTestCase.java
index befef64..28d3944 100644
--- a/src/test/java/org/apache/commons/beanutils2/BeanPropertyValueChangeConsumerTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/BeanPropertyValueChangeConsumerTestCase.java
@@ -21,7 +21,7 @@
 
 
 /**
- * Test cases for <code>BeanPropertyValueChangeClosure</code>.
+ * Test cases for {@code BeanPropertyValueChangeClosure}.
  *
  */
 public class BeanPropertyValueChangeConsumerTestCase extends TestCase {
diff --git a/src/test/java/org/apache/commons/beanutils2/BeanPropertyValueEqualsPredicateTestCase.java b/src/test/java/org/apache/commons/beanutils2/BeanPropertyValueEqualsPredicateTestCase.java
index 04d9306..a1ec591 100644
--- a/src/test/java/org/apache/commons/beanutils2/BeanPropertyValueEqualsPredicateTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/BeanPropertyValueEqualsPredicateTestCase.java
@@ -20,7 +20,7 @@
 import junit.framework.TestCase;
 
 /**
- * Test cases for <code>BeanPropertyValueEqualsPredicateTest</code>.
+ * Test cases for {@code BeanPropertyValueEqualsPredicateTest}.
  *
  */
 public class BeanPropertyValueEqualsPredicateTestCase extends TestCase {
diff --git a/src/test/java/org/apache/commons/beanutils2/BeanToPropertyValueTransformerTestCase.java b/src/test/java/org/apache/commons/beanutils2/BeanToPropertyValueTransformerTestCase.java
index c5c73c6..bedcf9f 100644
--- a/src/test/java/org/apache/commons/beanutils2/BeanToPropertyValueTransformerTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/BeanToPropertyValueTransformerTestCase.java
@@ -21,7 +21,7 @@
 
 
 /**
- * Test cases for <code>BeanToPropertyValueTransformer</code>.
+ * Test cases for {@code BeanToPropertyValueTransformer}.
  *
  */
 public class BeanToPropertyValueTransformerTestCase extends TestCase {
diff --git a/src/test/java/org/apache/commons/beanutils2/BeanUtils2TestCase.java b/src/test/java/org/apache/commons/beanutils2/BeanUtils2TestCase.java
index 19de166..f608146 100644
--- a/src/test/java/org/apache/commons/beanutils2/BeanUtils2TestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/BeanUtils2TestCase.java
@@ -25,7 +25,7 @@
  */
 public class BeanUtils2TestCase extends BeanUtilsTestCase {
 
-    // ---------------------------------------------------------- Constructors
+    
 
     /**
      * Construct a new instance of this test case.
@@ -37,7 +37,7 @@
     }
 
 
-    // -------------------------------------------------- Overall Test Methods
+    
 
 
     /**
@@ -67,7 +67,7 @@
     }
 
     /**
-     * Test <code>copyProperty()</code> converting to a String.
+     * Test {@code copyProperty()} converting to a String.
      */
     @Override
     public void testCopyPropertyConvertToString() {
@@ -80,7 +80,7 @@
     }
 
     /**
-     * Test <code>copyProperty()</code> converting to a String.
+     * Test {@code copyProperty()} converting to a String.
      */
     @Override
     public void testCopyPropertyConvertToStringArray() {
@@ -95,7 +95,7 @@
     }
 
     /**
-     * Test <code>copyProperty()</code> converting to a String on indexed property
+     * Test {@code copyProperty()} converting to a String on indexed property
      */
     @Override
     public void testCopyPropertyConvertToStringIndexed() {
@@ -110,7 +110,7 @@
     }
 
     /**
-     * Test <code>getArrayProperty()</code> converting to a String.
+     * Test {@code getArrayProperty()} converting to a String.
      */
     @Override
     public void testGetArrayPropertyDate() {
@@ -126,7 +126,7 @@
     }
 
     /**
-     * Test <code>getArrayProperty()</code> converting to a String.
+     * Test {@code getArrayProperty()} converting to a String.
      */
     @Override
     public void testGetIndexedPropertyDate() {
@@ -141,7 +141,7 @@
     }
 
     /**
-     * Test <code>getSimpleProperty()</code> converting to a String.
+     * Test {@code getSimpleProperty()} converting to a String.
      */
     @Override
     public void testGetSimplePropertyDate() {
@@ -156,7 +156,7 @@
     }
 
     /**
-     * Test <code>setProperty()</code> converting to a String.
+     * Test {@code setProperty()} converting to a String.
      */
     @Override
     public void testSetPropertyConvertToString() {
@@ -169,7 +169,7 @@
     }
 
     /**
-     * Test <code>setProperty()</code> converting to a String array.
+     * Test {@code setProperty()} converting to a String array.
      */
     @Override
     public void testSetPropertyConvertToStringArray() {
@@ -184,7 +184,7 @@
     }
 
     /**
-     * Test <code>setProperty()</code> converting to a String on indexed property
+     * Test {@code setProperty()} converting to a String on indexed property
      */
     @Override
     public void testSetPropertyConvertToStringIndexed() {
diff --git a/src/test/java/org/apache/commons/beanutils2/BeanUtilsBenchCase.java b/src/test/java/org/apache/commons/beanutils2/BeanUtilsBenchCase.java
index 9941d0e..5957505 100644
--- a/src/test/java/org/apache/commons/beanutils2/BeanUtilsBenchCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/BeanUtilsBenchCase.java
@@ -36,7 +36,7 @@
 public class BeanUtilsBenchCase extends TestCase {
 
 
-    // ------------------------------------------------------------ Constructors
+    
 
 
     /**
@@ -51,7 +51,7 @@
     }
 
 
-    // ------------------------------------------------------ Instance Variables
+    
 
 
     // Basic loop counter
@@ -74,7 +74,7 @@
     private BeanUtilsBean bu = null;
 
 
-    // ---------------------------------------------------- Overall Test Methods
+    
 
 
     /**
@@ -170,7 +170,7 @@
 
 
 
-    // ------------------------------------------------- Individual Test Methods
+    
 
 
     // Time copyProperties() from a bean
@@ -372,7 +372,7 @@
     }
 
 
-    // --------------------------------------------------------- Support Methods
+    
 
 
 }
diff --git a/src/test/java/org/apache/commons/beanutils2/BeanUtilsTestCase.java b/src/test/java/org/apache/commons/beanutils2/BeanUtilsTestCase.java
index f75f138..46c5746 100644
--- a/src/test/java/org/apache/commons/beanutils2/BeanUtilsTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/BeanUtilsTestCase.java
@@ -53,7 +53,7 @@
  *
  * <p>
  *  So far, this test case has tests for the following methods of the
- *  <code>BeanUtils</code> class:
+ *  {@code BeanUtils} class:
  * </p>
  * <ul>
  *   <li>getArrayProperty(Object bean, String name)</li>
@@ -63,7 +63,7 @@
 
 public class BeanUtilsTestCase extends TestCase {
 
-    // ---------------------------------------------------- Instance Variables
+    
 
     /**
      * The test bean for each test.
@@ -106,7 +106,7 @@
     /** Test String Date value */
     protected String testStringDate;
 
-    // ---------------------------------------------------------- Constructors
+    
 
     /**
      * Construct a new instance of this test case.
@@ -118,7 +118,7 @@
     }
 
 
-    // -------------------------------------------------- Overall Test Methods
+    
 
 
     /**
@@ -170,7 +170,7 @@
     }
 
 
-    // ------------------------------------------------ Individual Test Methods
+    
 
 
     /**
@@ -252,7 +252,7 @@
 
 
     /**
-     * Test copyProperties() when the origin is a a <code>Map</code>.
+     * Test copyProperties() when the origin is a a {@code Map}.
      */
     public void testCopyPropertiesMap() {
 
@@ -471,7 +471,7 @@
     }
 
     /**
-     * Test <code>getArrayProperty()</code> converting to a String.
+     * Test {@code getArrayProperty()} converting to a String.
      */
     public void testGetArrayPropertyDate() {
         String[] value = null;
@@ -507,7 +507,7 @@
     }
 
     /**
-     * Test <code>getArrayProperty()</code> converting to a String.
+     * Test {@code getArrayProperty()} converting to a String.
      */
     public void testGetIndexedPropertyDate() {
         String value = null;
@@ -604,7 +604,7 @@
     }
 
     /**
-     * Test <code>getSimpleProperty()</code> converting to a String.
+     * Test {@code getSimpleProperty()} converting to a String.
      */
     public void testGetSimplePropertyDate() {
         String value = null;
@@ -931,7 +931,7 @@
     }
 
     /**
-     * Test <code>setProperty()</code> conversion.
+     * Test {@code setProperty()} conversion.
      */
     public void testSetPropertyConvert() {
         try {
@@ -943,7 +943,7 @@
     }
 
     /**
-     * Test <code>setProperty()</code> converting from a String.
+     * Test {@code setProperty()} converting from a String.
      */
     public void testSetPropertyConvertFromString() {
         try {
@@ -955,7 +955,7 @@
     }
 
     /**
-     * Test <code>setProperty()</code> converting to a String.
+     * Test {@code setProperty()} converting to a String.
      */
     public void testSetPropertyConvertToString() {
         try {
@@ -967,7 +967,7 @@
     }
 
     /**
-     * Test <code>setProperty()</code> converting to a String array.
+     * Test {@code setProperty()} converting to a String array.
      */
     public void testSetPropertyConvertToStringArray() {
         try {
@@ -981,7 +981,7 @@
     }
 
     /**
-     * Test <code>setProperty()</code> converting to a String on indexed property
+     * Test {@code setProperty()} converting to a String on indexed property
      */
     public void testSetPropertyConvertToStringIndexed() {
         try {
@@ -1158,7 +1158,7 @@
     }
 
     /**
-     * Test <code>copyProperty()</code> conversion.
+     * Test {@code copyProperty()} conversion.
      */
     public void testCopyPropertyConvert() {
         try {
@@ -1170,7 +1170,7 @@
     }
 
     /**
-     * Test <code>copyProperty()</code> converting from a String.
+     * Test {@code copyProperty()} converting from a String.
      */
     public void testCopyPropertyConvertFromString() {
         try {
@@ -1182,7 +1182,7 @@
     }
 
     /**
-     * Test <code>copyProperty()</code> converting to a String.
+     * Test {@code copyProperty()} converting to a String.
      */
     public void testCopyPropertyConvertToString() {
         try {
@@ -1194,7 +1194,7 @@
     }
 
     /**
-     * Test <code>copyProperty()</code> converting to a String.
+     * Test {@code copyProperty()} converting to a String.
      */
     public void testCopyPropertyConvertToStringArray() {
         try {
@@ -1208,7 +1208,7 @@
     }
 
     /**
-     * Test <code>copyProperty()</code> converting to a String on indexed property
+     * Test {@code copyProperty()} converting to a String on indexed property
      */
     public void testCopyPropertyConvertToStringIndexed() {
         try {
diff --git a/src/test/java/org/apache/commons/beanutils2/BeanificationTestCase.java b/src/test/java/org/apache/commons/beanutils2/BeanificationTestCase.java
index a2381b3..497179f 100644
--- a/src/test/java/org/apache/commons/beanutils2/BeanificationTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/BeanificationTestCase.java
@@ -37,15 +37,15 @@
 
 public class BeanificationTestCase extends TestCase {
 
-    // ---------------------------------------------------- Constants
+    
 
     /** Maximum number of iterations before our test fails */
     public static final int MAX_GC_ITERATIONS = 50;
 
-    // ---------------------------------------------------- Instance Variables
+    
 
 
-    // ---------------------------------------------------------- Constructors
+    
 
 
     /**
@@ -58,7 +58,7 @@
     }
 
 
-    // -------------------------------------------------- Overall Test Methods
+    
 
 
     /**
@@ -89,7 +89,7 @@
     }
 
 
-    // ------------------------------------------------ Individual Test Methods
+    
 
     /** Test of the methodology we'll use for some of the later tests */
     public void testMemoryTestMethodology() throws Exception {
diff --git a/src/test/java/org/apache/commons/beanutils2/BenchBean.java b/src/test/java/org/apache/commons/beanutils2/BenchBean.java
index 5bec3f3..4fc2b26 100644
--- a/src/test/java/org/apache/commons/beanutils2/BenchBean.java
+++ b/src/test/java/org/apache/commons/beanutils2/BenchBean.java
@@ -27,7 +27,7 @@
 public class BenchBean {
 
 
-    // -------------------------------------------------------------- Properties
+    
 
 
     /**
diff --git a/src/test/java/org/apache/commons/beanutils2/ConstructorUtilsTestCase.java b/src/test/java/org/apache/commons/beanutils2/ConstructorUtilsTestCase.java
index e6b4644..1ca6755 100644
--- a/src/test/java/org/apache/commons/beanutils2/ConstructorUtilsTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/ConstructorUtilsTestCase.java
@@ -28,12 +28,12 @@
 
 
 /**
- * <p> Test case for <code>ConstructorUtils</code> </p>
+ * <p> Test case for {@code ConstructorUtils} </p>
  *
  */
 public class ConstructorUtilsTestCase extends TestCase {
 
-    // ---------------------------------------------------------- Constructors
+    
 
     /**
      * Construct a new instance of this test case.
@@ -45,7 +45,7 @@
     }
 
 
-    // -------------------------------------------------- Overall Test Methods
+    
 
 
     /**
@@ -73,7 +73,7 @@
     }
 
 
-    // ------------------------------------------------ Individual Test Methods
+    
 
     public void testInvokeConstructor() throws Exception {
         {
diff --git a/src/test/java/org/apache/commons/beanutils2/ConvertUtilsTestCase.java b/src/test/java/org/apache/commons/beanutils2/ConvertUtilsTestCase.java
index f5ae83c..6ff8a07 100644
--- a/src/test/java/org/apache/commons/beanutils2/ConvertUtilsTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/ConvertUtilsTestCase.java
@@ -41,10 +41,10 @@
 
 public class ConvertUtilsTestCase extends TestCase {
 
-    // ---------------------------------------------------- Instance Variables
+    
 
 
-    // ---------------------------------------------------------- Constructors
+    
 
 
     /**
@@ -57,7 +57,7 @@
     }
 
 
-    // -------------------------------------------------- Overall Test Methods
+    
 
 
     /**
@@ -88,7 +88,7 @@
     }
 
 
-    // ------------------------------------------------ Individual Test Methods
+    
 
 
     /**
@@ -673,7 +673,7 @@
                 utils.convert(value, getClass()));
     }
 
-    // -------------------------------------------------------- Private Methods
+    
 
 
     private void checkIntegerArray(final Object value, final int intArray[]) {
diff --git a/src/test/java/org/apache/commons/beanutils2/DynaBeanMapDecoratorTestCase.java b/src/test/java/org/apache/commons/beanutils2/DynaBeanMapDecoratorTestCase.java
index cfbcc43..4f24b10 100644
--- a/src/test/java/org/apache/commons/beanutils2/DynaBeanMapDecoratorTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/DynaBeanMapDecoratorTestCase.java
@@ -30,7 +30,7 @@
 import junit.framework.TestSuite;
 
 /**
- * <p>Test Case for the <code>DynaBeanMapDecorator</code> implementation class.</p>
+ * <p>Test Case for the {@code DynaBeanMapDecorator} implementation class.</p>
  *
  */
 @SuppressWarnings("deprecation")
@@ -57,7 +57,7 @@
     private Map<String, Object> modifiableMap;
     private static final Map<String, Object> emptyMap = new DynaBeanPropertyMapDecorator(new BasicDynaBean(new BasicDynaClass()));
 
-    // ---------------------------------------------------------- Constructors
+    
 
     /**
      * Construct a new instance of this test case.
@@ -68,7 +68,7 @@
         super(name);
     }
 
-    // -------------------------------------------------- Overall Test Methods
+    
 
     /**
      * Run thus Test
@@ -116,7 +116,7 @@
         modifiableMap = null;
     }
 
-    // ------------------------------------------------ Individual Test Methods
+    
 
     /**
      * Test isReadOnly() method
diff --git a/src/test/java/org/apache/commons/beanutils2/DynaBeanUtilsTestCase.java b/src/test/java/org/apache/commons/beanutils2/DynaBeanUtilsTestCase.java
index 10eab1e..a39f492 100644
--- a/src/test/java/org/apache/commons/beanutils2/DynaBeanUtilsTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/DynaBeanUtilsTestCase.java
@@ -38,7 +38,7 @@
 public class DynaBeanUtilsTestCase extends TestCase {
 
 
-    // ----------------------------------------------------- Instance Variables
+    
 
 
     /**
@@ -81,7 +81,7 @@
     };
 
 
-    // ----------------------------------------------------------- Constructors
+    
 
 
     /**
@@ -96,7 +96,7 @@
     }
 
 
-    // --------------------------------------------------- Overall Test Methods
+    
 
 
     /**
@@ -182,7 +182,7 @@
 
 
 
-    // ------------------------------------------------ Individual Test Methods
+    
 
     /**
      * Test the cloneBean() method from a DynaBean.
@@ -339,7 +339,7 @@
 
 
     /**
-     * Test copyProperties() when the origin is a a <code>Map</code>.
+     * Test copyProperties() when the origin is a a {@code Map}.
      */
     public void testCopyPropertiesMap() {
 
@@ -1198,7 +1198,7 @@
     }
 
 
-    // ------------------------------------------------------ Protected Methods
+    
 
 
     // Ensure that the nested intArray matches the specified values
@@ -1226,8 +1226,8 @@
 
 
     /**
-     * Create and return a <code>DynaClass</code> instance for our test
-     * <code>DynaBean</code>.
+     * Create and return a {@code DynaClass} instance for our test
+     * {@code DynaBean}.
      */
     protected static DynaClass createDynaClass() {
 
diff --git a/src/test/java/org/apache/commons/beanutils2/DynaPropertyUtilsTestCase.java b/src/test/java/org/apache/commons/beanutils2/DynaPropertyUtilsTestCase.java
index 974e98c..386c221 100644
--- a/src/test/java/org/apache/commons/beanutils2/DynaPropertyUtilsTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/DynaPropertyUtilsTestCase.java
@@ -38,7 +38,7 @@
 public class DynaPropertyUtilsTestCase extends TestCase {
 
 
-    // ----------------------------------------------------- Instance Variables
+    
 
 
     /**
@@ -79,7 +79,7 @@
     protected TestBean nested = null;
 
 
-    // ----------------------------------------------------------- Constructors
+    
 
 
     /**
@@ -94,7 +94,7 @@
     }
 
 
-    // --------------------------------------------------- Overall Test Methods
+    
 
 
     /**
@@ -179,11 +179,11 @@
 
 
 
-    // ------------------------------------------------ Individual Test Methods
+    
 
 
     /**
-     * Test copyProperties() when the origin is a a <code>Map</code>.
+     * Test copyProperties() when the origin is a a {@code Map}.
      */
     public void testCopyPropertiesMap() {
 
@@ -2599,12 +2599,12 @@
     }
 
 
-    // ------------------------------------------------------ Protected Methods
+    
 
 
     /**
-     * Create and return a <code>DynaClass</code> instance for our test
-     * <code>DynaBean</code>.
+     * Create and return a {@code DynaClass} instance for our test
+     * {@code DynaBean}.
      */
     protected DynaClass createDynaClass() {
 
diff --git a/src/test/java/org/apache/commons/beanutils2/DynaResultSetTestCase.java b/src/test/java/org/apache/commons/beanutils2/DynaResultSetTestCase.java
index ff107b5..994d094 100644
--- a/src/test/java/org/apache/commons/beanutils2/DynaResultSetTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/DynaResultSetTestCase.java
@@ -35,7 +35,7 @@
 public class DynaResultSetTestCase extends TestCase {
 
 
-    // ----------------------------------------------------- Instance Variables
+    
 
 
     /**
@@ -58,7 +58,7 @@
       "timestampproperty" };
 
 
-    // ----------------------------------------------------------- Constructors
+    
 
 
     /**
@@ -73,7 +73,7 @@
     }
 
 
-    // --------------------------------------------------- Overall Test Methods
+    
 
 
     /**
@@ -109,7 +109,7 @@
 
 
 
-    // ------------------------------------------------ Individual Test Methods
+    
 
 
     public void testGetName() {
diff --git a/src/test/java/org/apache/commons/beanutils2/DynaRowSetTestCase.java b/src/test/java/org/apache/commons/beanutils2/DynaRowSetTestCase.java
index f108e30..148cb05 100644
--- a/src/test/java/org/apache/commons/beanutils2/DynaRowSetTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/DynaRowSetTestCase.java
@@ -38,7 +38,7 @@
 public class DynaRowSetTestCase extends TestCase {
 
 
-    // ----------------------------------------------------- Instance Variables
+    
 
 
     /**
@@ -61,7 +61,7 @@
       "timestampproperty" };
 
 
-    // ----------------------------------------------------------- Constructors
+    
 
 
     /**
@@ -76,7 +76,7 @@
     }
 
 
-    // --------------------------------------------------- Overall Test Methods
+    
 
 
     /**
@@ -112,7 +112,7 @@
 
 
 
-    // ------------------------------------------------ Individual Test Methods
+    
 
 
     public void testGetName() {
diff --git a/src/test/java/org/apache/commons/beanutils2/IndexedPropertyTestCase.java b/src/test/java/org/apache/commons/beanutils2/IndexedPropertyTestCase.java
index 294011d..d566c5d 100644
--- a/src/test/java/org/apache/commons/beanutils2/IndexedPropertyTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/IndexedPropertyTestCase.java
@@ -39,7 +39,7 @@
 
 public class IndexedPropertyTestCase {
 
-    // ---------------------------------------------------- Instance Variables
+    
 
     /**
      * The test bean for each test.
@@ -54,7 +54,7 @@
     private ArrayList<Object> arrayList;
 
 
-    // -------------------------------------------------- Overall Test Methods
+    
 
 
     /**
@@ -102,7 +102,7 @@
     }
 
 
-    // ------------------------------------------------ Individual Test Methods
+    
 
     /**
      * Test IndexedPropertyDescriptor for an Array
diff --git a/src/test/java/org/apache/commons/beanutils2/IndexedTestBean.java b/src/test/java/org/apache/commons/beanutils2/IndexedTestBean.java
index 302abff..494a96b 100644
--- a/src/test/java/org/apache/commons/beanutils2/IndexedTestBean.java
+++ b/src/test/java/org/apache/commons/beanutils2/IndexedTestBean.java
@@ -31,7 +31,7 @@
     private ArrayList<Object> arrayList;
 
 
-    // ----------------------------------------------------------- Constructors
+    
 
     /**
      * Default Constructor.
diff --git a/src/test/java/org/apache/commons/beanutils2/LazyDynaBeanTestCase.java b/src/test/java/org/apache/commons/beanutils2/LazyDynaBeanTestCase.java
index 4d9c1ce..0dbea0a 100644
--- a/src/test/java/org/apache/commons/beanutils2/LazyDynaBeanTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/LazyDynaBeanTestCase.java
@@ -27,7 +27,7 @@
 import junit.framework.TestSuite;
 
 /**
- * <p>Test Case for the <code>LazyDynaBean</code> implementation class.</p>
+ * <p>Test Case for the {@code LazyDynaBean} implementation class.</p>
  *
  */
 public class LazyDynaBeanTestCase extends TestCase {
@@ -43,7 +43,7 @@
     protected Integer testInteger2    = new Integer(40);
     protected String testKey          = "myKey";
 
-    // ---------------------------------------------------------- Constructors
+    
 
     /**
      * Construct a new instance of this test case.
@@ -54,7 +54,7 @@
         super(name);
     }
 
-    // -------------------------------------------------- Overall Test Methods
+    
 
     /**
      * Run thus Test
@@ -88,7 +88,7 @@
       bean = null;
     }
 
-    // ------------------------------------------------ Individual Test Methods
+    
 
     /**
      * Test Getting/Setting a Simple Property
diff --git a/src/test/java/org/apache/commons/beanutils2/LazyDynaClassTestCase.java b/src/test/java/org/apache/commons/beanutils2/LazyDynaClassTestCase.java
index bdb6c7c..1a7d990 100644
--- a/src/test/java/org/apache/commons/beanutils2/LazyDynaClassTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/LazyDynaClassTestCase.java
@@ -21,7 +21,7 @@
 import junit.framework.TestSuite;
 
 /**
- * <p>Test Case for the <code>LazyDynaClass</code> implementation class.</p>
+ * <p>Test Case for the {@code LazyDynaClass} implementation class.</p>
  *
  */
 public class LazyDynaClassTestCase extends TestCase {
@@ -29,7 +29,7 @@
     protected LazyDynaClass dynaClass = null;
     protected String testProperty     = "myProperty";
 
-    // ---------------------------------------------------------- Constructors
+    
 
     /**
      * Construct a new instance of this test case.
@@ -40,7 +40,7 @@
         super(name);
     }
 
-    // -------------------------------------------------- Overall Test Methods
+    
 
     /**
      * Run this Test
@@ -72,7 +72,7 @@
         dynaClass = null;
     }
 
-    // ------------------------------------------------ Individual Test Methods
+    
 
     /**
      * Test add(name) method
diff --git a/src/test/java/org/apache/commons/beanutils2/LazyDynaListTestCase.java b/src/test/java/org/apache/commons/beanutils2/LazyDynaListTestCase.java
index 3623d1e..1935e8d 100644
--- a/src/test/java/org/apache/commons/beanutils2/LazyDynaListTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/LazyDynaListTestCase.java
@@ -31,7 +31,7 @@
 import junit.framework.TestSuite;
 
 /**
- * <p>Test Case for the <code>LazyDynaList</code>class.</p>
+ * <p>Test Case for the {@code LazyDynaList}class.</p>
  *
  */
 public class LazyDynaListTestCase extends TestCase {
@@ -48,7 +48,7 @@
     protected DynaClass pojoDynaClass = new WrapDynaBean(new TestBean()).getDynaClass();
     protected DynaClass basicDynaClass = new BasicDynaClass("test", BasicDynaBean.class, properties);
 
-    // ---------------------------------------------------------- Constructors
+    
 
     /**
      * Construct a new instance of this test case.
@@ -59,7 +59,7 @@
         super(name);
     }
 
-    // -------------------------------------------------- Overall Test Methods
+    
 
     /**
      * Run thus Test
@@ -89,7 +89,7 @@
     public void tearDown() {
     }
 
-    // ------------------------------------------------ Individual Test Methods
+    
 
     /**
      * Test DynaBean Create
diff --git a/src/test/java/org/apache/commons/beanutils2/LazyDynaMapTestCase.java b/src/test/java/org/apache/commons/beanutils2/LazyDynaMapTestCase.java
index d697716..f79b59f 100644
--- a/src/test/java/org/apache/commons/beanutils2/LazyDynaMapTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/LazyDynaMapTestCase.java
@@ -29,7 +29,7 @@
 import junit.framework.TestSuite;
 
 /**
- * <p>Test Case for the <code>LazyDynaMap</code> implementation class.</p>
+ * <p>Test Case for the {@code LazyDynaMap} implementation class.</p>
  *
  */
 public class LazyDynaMapTestCase extends TestCase {
@@ -44,7 +44,7 @@
     protected Integer testInteger2    = new Integer(40);
     protected String testKey          = "myKey";
 
-    // ---------------------------------------------------------- Constructors
+    
 
     /**
      * Construct a new instance of this test case.
@@ -55,7 +55,7 @@
         super(name);
     }
 
-    // -------------------------------------------------- Overall Test Methods
+    
 
     /**
      * Run thus Test
@@ -88,7 +88,7 @@
       dynaMap = null;
     }
 
-    // ------------------------------------------------ Individual Test Methods
+    
 
     /**
      * General Tests
diff --git a/src/test/java/org/apache/commons/beanutils2/MappedPropertyTestBean.java b/src/test/java/org/apache/commons/beanutils2/MappedPropertyTestBean.java
index 61582ef..b1c2d17 100644
--- a/src/test/java/org/apache/commons/beanutils2/MappedPropertyTestBean.java
+++ b/src/test/java/org/apache/commons/beanutils2/MappedPropertyTestBean.java
@@ -32,7 +32,7 @@
     private final Map<Object, Object> myMap = new HashMap<>();
 
 
-    // -------------------------------------------------------------- Properties
+    
 
     public String getMapproperty(final String key) {
         return (String) map.get(key);
diff --git a/src/test/java/org/apache/commons/beanutils2/MappedPropertyTestCase.java b/src/test/java/org/apache/commons/beanutils2/MappedPropertyTestCase.java
index 9f49ce5..22e582e 100644
--- a/src/test/java/org/apache/commons/beanutils2/MappedPropertyTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/MappedPropertyTestCase.java
@@ -21,12 +21,12 @@
 import junit.framework.TestSuite;
 
 /**
- * <p>Test Case for the <code>MappedPropertyDescriptor</code>.</p>
+ * <p>Test Case for the {@code MappedPropertyDescriptor}.</p>
  *
  */
 public class MappedPropertyTestCase extends TestCase {
 
-    // ---------------------------------------------------------- Constructors
+    
 
     /**
      * Construct a new instance of this test case.
@@ -37,7 +37,7 @@
         super(name);
     }
 
-    // -------------------------------------------------- Overall Test Methods
+    
 
     /**
      * Run this Test
@@ -67,7 +67,7 @@
     public void tearDown() {
     }
 
-    // ------------------------------------------------ Individual Test Methods
+    
 
     /**
      * Test valid method name
diff --git a/src/test/java/org/apache/commons/beanutils2/MethodUtilsTestCase.java b/src/test/java/org/apache/commons/beanutils2/MethodUtilsTestCase.java
index 3285b1d..9646a82 100644
--- a/src/test/java/org/apache/commons/beanutils2/MethodUtilsTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/MethodUtilsTestCase.java
@@ -29,12 +29,12 @@
 import junit.framework.TestSuite;
 
 /**
- * <p> Test case for <code>MethodUtils</code> </p>
+ * <p> Test case for {@code MethodUtils} </p>
  *
  */
 public class MethodUtilsTestCase extends TestCase {
 
-    // ---------------------------------------------------------- Constructors
+    
 
     /**
      * Construct a new instance of this test case.
@@ -46,7 +46,7 @@
     }
 
 
-    // -------------------------------------------------- Overall Test Methods
+    
 
 
     /**
@@ -72,10 +72,10 @@
     }
 
 
-    // ------------------------------------------------ Individual Test Methods
+    
 
     /**
-     * <p> Test <code>getAccessibleMethod</code>.
+     * <p> Test {@code getAccessibleMethod}.
      */
     public void testGetAccessibleMethod() {
         // easy bit first - find a public method
@@ -117,7 +117,7 @@
     }
 
     /**
-     * <p> Test <code>invokeExactMethod</code>.
+     * <p> Test {@code invokeExactMethod}.
      */
     public void testInvokeExactMethod() throws Exception {
             final TestBean bean = new TestBean();
@@ -171,7 +171,7 @@
     }
 
     /**
-     * <p> Test <code>invokeMethod</code>.
+     * <p> Test {@code invokeMethod}.
      */
     public void testInvokeMethod() throws Exception {
         final AbstractParent parent = new AlphaBean("parent");
diff --git a/src/test/java/org/apache/commons/beanutils2/NestedTestBean.java b/src/test/java/org/apache/commons/beanutils2/NestedTestBean.java
index 698c0b8..8a524d0 100644
--- a/src/test/java/org/apache/commons/beanutils2/NestedTestBean.java
+++ b/src/test/java/org/apache/commons/beanutils2/NestedTestBean.java
@@ -28,13 +28,13 @@
 public class NestedTestBean {
 
 
-    // ------------------------------------------------------------- Constructors
+    
     public NestedTestBean(final String name) {
         setName(name);
     }
 
 
-    // ------------------------------------------------------------- Properties
+    
 
     private String name;
 
@@ -96,6 +96,6 @@
         return simpleBean;
     }
 
-    // ------------------------------------------------------- Static Variables
+    
 
 }
diff --git a/src/test/java/org/apache/commons/beanutils2/PropertyUtilsBenchCase.java b/src/test/java/org/apache/commons/beanutils2/PropertyUtilsBenchCase.java
index 6d1cc78..2e6b656 100644
--- a/src/test/java/org/apache/commons/beanutils2/PropertyUtilsBenchCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/PropertyUtilsBenchCase.java
@@ -35,7 +35,7 @@
 public class PropertyUtilsBenchCase extends TestCase {
 
 
-    // ------------------------------------------------------------ Constructors
+    
 
 
     /**
@@ -50,7 +50,7 @@
     }
 
 
-    // ------------------------------------------------------ Instance Variables
+    
 
 
     // Basic loop counter
@@ -72,7 +72,7 @@
     private PropertyUtilsBean pu = null;
 
 
-    // ---------------------------------------------------- Overall Test Methods
+    
 
 
     /**
@@ -159,7 +159,7 @@
 
 
 
-    // ------------------------------------------------- Individual Test Methods
+    
 
 
     // Time copyProperties() from a bean
@@ -261,7 +261,7 @@
     }
 
 
-    // --------------------------------------------------------- Support Methods
+    
 
 
 }
diff --git a/src/test/java/org/apache/commons/beanutils2/PropertyUtilsTestCase.java b/src/test/java/org/apache/commons/beanutils2/PropertyUtilsTestCase.java
index ce94961..70468fa 100644
--- a/src/test/java/org/apache/commons/beanutils2/PropertyUtilsTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/PropertyUtilsTestCase.java
@@ -46,7 +46,7 @@
  * change the characteristics of that class.</p>
  *
  * <p>So far, this test case has tests for the following methods of the
- * <code>PropertyUtils</code> class:</p>
+ * {@code PropertyUtils} class:</p>
  * <ul>
  * <li>getIndexedProperty(Object,String)</li>
  * <li>getIndexedProperty(Object,String,int)</li>
@@ -70,7 +70,7 @@
 public class PropertyUtilsTestCase extends TestCase {
 
 
-    // ---------------------------------------------------- Instance Variables
+    
 
 
     /**
@@ -154,7 +154,7 @@
 
     /**
      * The set of property names we expect to have returned when calling
-     * <code>getPropertyDescriptors()</code>.  You should update this list
+     * {@code getPropertyDescriptors()}.  You should update this list
      * when new properties are added to TestBean.
      */
     protected final static String[] properties = {
@@ -179,7 +179,7 @@
     };
 
 
-    // ---------------------------------------------------------- Constructors
+    
 
 
     /**
@@ -194,7 +194,7 @@
     }
 
 
-    // -------------------------------------------------- Overall Test Methods
+    
 
 
     /**
@@ -249,11 +249,11 @@
 
 
 
-    // ------------------------------------------------ Individual Test Methods
+    
 
 
     /**
-     * Test copyProperties() when the origin is a a <code>Map</code>.
+     * Test copyProperties() when the origin is a a {@code Map}.
      */
     public void testCopyPropertiesMap() {
 
@@ -374,7 +374,7 @@
 
 
     /**
-     * Positive getPropertyDescriptor on property <code>booleanProperty</code>.
+     * Positive getPropertyDescriptor on property {@code booleanProperty}.
      */
     public void testGetDescriptorBoolean() {
 
@@ -385,7 +385,7 @@
 
 
     /**
-     * Positive getPropertyDescriptor on property <code>doubleProperty</code>.
+     * Positive getPropertyDescriptor on property {@code doubleProperty}.
      */
     public void testGetDescriptorDouble() {
 
@@ -396,7 +396,7 @@
 
 
     /**
-     * Positive getPropertyDescriptor on property <code>floatProperty</code>.
+     * Positive getPropertyDescriptor on property {@code floatProperty}.
      */
     public void testGetDescriptorFloat() {
 
@@ -407,7 +407,7 @@
 
 
     /**
-     * Positive getPropertyDescriptor on property <code>intProperty</code>.
+     * Positive getPropertyDescriptor on property {@code intProperty}.
      */
     public void testGetDescriptorInt() {
 
@@ -445,7 +445,7 @@
 
 
     /**
-     * Positive getPropertyDescriptor on property <code>longProperty</code>.
+     * Positive getPropertyDescriptor on property {@code longProperty}.
      */
     public void testGetDescriptorLong() {
 
@@ -496,7 +496,7 @@
 
     /**
      * Positive getPropertyDescriptor on property
-     * <code>readOnlyProperty</code>.
+     * {@code readOnlyProperty}.
      */
     public void testGetDescriptorReadOnly() {
 
@@ -507,7 +507,7 @@
 
 
     /**
-     * Positive getPropertyDescriptor on property <code>booleanSecond</code>
+     * Positive getPropertyDescriptor on property {@code booleanSecond}
      * that uses an "is" method as the getter.
      */
     public void testGetDescriptorSecond() {
@@ -519,7 +519,7 @@
 
 
     /**
-     * Positive getPropertyDescriptor on property <code>shortProperty</code>.
+     * Positive getPropertyDescriptor on property {@code shortProperty}.
      */
     public void testGetDescriptorShort() {
 
@@ -530,7 +530,7 @@
 
 
     /**
-     * Positive getPropertyDescriptor on property <code>stringProperty</code>.
+     * Positive getPropertyDescriptor on property {@code stringProperty}.
      */
     public void testGetDescriptorString() {
 
@@ -541,7 +541,7 @@
 
 
     /**
-     * Negative getPropertyDescriptor on property <code>unknown</code>.
+     * Negative getPropertyDescriptor on property {@code unknown}.
      */
     public void testGetDescriptorUnknown() {
 
@@ -552,7 +552,7 @@
 
     /**
      * Positive getPropertyDescriptor on property
-     * <code>writeOnlyProperty</code>.
+     * {@code writeOnlyProperty}.
      */
     public void testGetDescriptorWriteOnly() {
 
@@ -564,7 +564,7 @@
 
     /**
      * Positive test for getPropertyDescriptors().  Each property name
-     * listed in <code>properties</code> should be returned exactly once.
+     * listed in {@code properties} should be returned exactly once.
      */
     public void testGetDescriptors() {
 
@@ -3930,7 +3930,7 @@
     }
 
 
-    // ------------------------------------------------------ Protected Methods
+    
 
 
     /**
diff --git a/src/test/java/org/apache/commons/beanutils2/TestBean.java b/src/test/java/org/apache/commons/beanutils2/TestBean.java
index 19dfece..160a056 100644
--- a/src/test/java/org/apache/commons/beanutils2/TestBean.java
+++ b/src/test/java/org/apache/commons/beanutils2/TestBean.java
@@ -33,7 +33,7 @@
 
 public class TestBean implements Serializable {
 
-    // ----------------------------------------------------------- Constructors
+    
 
     public TestBean() {
         listIndexed.add("String 0");
@@ -100,7 +100,7 @@
         this.string2dArray = string2dArray;
     }
 
-    // ------------------------------------------------------------- Properties
+    
 
 
     /**
@@ -544,7 +544,7 @@
     }
 
 
-    // ------------------------------------------------------ Invalid Properties
+    
 
 
     /**
@@ -575,7 +575,7 @@
 
 
 
-    // ------------------------------------------------------- Static Variables
+    
 
 
     /**
diff --git a/src/test/java/org/apache/commons/beanutils2/TestResultSet.java b/src/test/java/org/apache/commons/beanutils2/TestResultSet.java
index 01cbc58..9dadbd7 100644
--- a/src/test/java/org/apache/commons/beanutils2/TestResultSet.java
+++ b/src/test/java/org/apache/commons/beanutils2/TestResultSet.java
@@ -43,7 +43,7 @@
 
 
 /**
- * <p>Mock object that implements enough of <code>java.sql.ResultSet</code>
+ * <p>Mock object that implements enough of {@code java.sql.ResultSet}
  * to exercise the {@link ResultSetDynaClass} functionality.</p>
  *
  */
@@ -51,7 +51,7 @@
 public class TestResultSet implements InvocationHandler {
 
 
-    // ----------------------------------------------------- Instance Variables
+    
 
 
     /**
@@ -148,7 +148,7 @@
         return (String)arg;
     }
 
-    // ---------------------------------------------------- Implemented Methods
+    
 
 
     public void close() throws SQLException {
@@ -228,7 +228,7 @@
     }
 
 
-    // -------------------------------------------------- Unimplemented Methods
+    
 
 
     public boolean absolute(final int row) throws SQLException {
diff --git a/src/test/java/org/apache/commons/beanutils2/TestResultSetMetaData.java b/src/test/java/org/apache/commons/beanutils2/TestResultSetMetaData.java
index 144f56b..a54ef98 100644
--- a/src/test/java/org/apache/commons/beanutils2/TestResultSetMetaData.java
+++ b/src/test/java/org/apache/commons/beanutils2/TestResultSetMetaData.java
@@ -29,7 +29,7 @@
 
 /**
  * <p>Mock object that implements enough of
- * <code>java.sql.ResultSetMetaData</code>
+ * {@code java.sql.ResultSetMetaData}
  * to exercise the {@link ResultSetDynaClass} functionality.</p>
  *
  */
@@ -37,7 +37,7 @@
 public class TestResultSetMetaData implements InvocationHandler {
 
 
-    // ----------------------------------------------------- Instance Variables
+    
 
 
     /**
@@ -105,7 +105,7 @@
         throw new UnsupportedOperationException(methodName + " not implemented");
     }
 
-    // ---------------------------------------------------- Implemented Methods
+    
 
 
     public String getColumnClassName(final int columnIndex) throws SQLException {
@@ -159,7 +159,7 @@
     }
 
 
-    // -------------------------------------------------- Unimplemented Methods
+    
 
 
     public String getCatalogName(final int columnIndex) throws SQLException {
diff --git a/src/test/java/org/apache/commons/beanutils2/ThrowExceptionConverter.java b/src/test/java/org/apache/commons/beanutils2/ThrowExceptionConverter.java
index dfa7dae..3338c6a 100644
--- a/src/test/java/org/apache/commons/beanutils2/ThrowExceptionConverter.java
+++ b/src/test/java/org/apache/commons/beanutils2/ThrowExceptionConverter.java
@@ -19,7 +19,7 @@
 package org.apache.commons.beanutils2;
 
 /**
- * Converter implementation that throws a <code>PassTestException</code>
+ * Converter implementation that throws a {@code PassTestException}
  * when convert is called.
  * The idea is that catching this exception is a clear signal that this method
  * has been called.
diff --git a/src/test/java/org/apache/commons/beanutils2/WrapDynaBeanTestCase.java b/src/test/java/org/apache/commons/beanutils2/WrapDynaBeanTestCase.java
index 33257fb..72eeb59 100644
--- a/src/test/java/org/apache/commons/beanutils2/WrapDynaBeanTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/WrapDynaBeanTestCase.java
@@ -28,8 +28,8 @@
 
 
 /**
- * <p>Test Case for the <code>WrapDynaBean</code> implementation class.
- * These tests were based on the ones in <code>PropertyUtilsTestCase</code>
+ * <p>Test Case for the {@code WrapDynaBean} implementation class.
+ * These tests were based on the ones in {@code PropertyUtilsTestCase}
  * because the two classes provide similar levels of functionality.</p>
  *
  */
@@ -37,10 +37,10 @@
 public class WrapDynaBeanTestCase extends BasicDynaBeanTestCase {
 
 
-    // ---------------------------------------------------- Instance Variables
+    
 
 
-    // ---------------------------------------------------------- Constructors
+    
 
 
     /**
@@ -55,7 +55,7 @@
     }
 
 
-    // -------------------------------------------------- Overall Test Methods
+    
 
 
     /**
@@ -91,11 +91,11 @@
 
 
 
-    // ------------------------------------------------ Individual Test Methods
+    
 
 
     /**
-     * The <code>set()</code> method.
+     * The {@code set()} method.
      */
     public void testSimpleProperties() {
 
@@ -144,7 +144,7 @@
     }
 
     /**
-     * The <code>set()</code> method.
+     * The {@code set()} method.
      */
     public void testIndexedProperties() {
 
@@ -184,8 +184,8 @@
     }
 
     /**
-     * The <code>contains()</code> method is not supported by the
-     * <code>WrapDynaBean</code> implementation class.
+     * The {@code contains()} method is not supported by the
+     * {@code WrapDynaBean} implementation class.
      */
     @Override
     public void testMappedContains() {
@@ -215,8 +215,8 @@
 
 
     /**
-     * The <code>remove()</code> method is not supported by the
-     * <code>WrapDynaBean</code> implementation class.
+     * The {@code remove()} method is not supported by the
+     * {@code WrapDynaBean} implementation class.
      */
     @Override
     public void testMappedRemove() {
diff --git a/src/test/java/org/apache/commons/beanutils2/bugs/Jira347TestCase.java b/src/test/java/org/apache/commons/beanutils2/bugs/Jira347TestCase.java
index 3c8a139..7a92b31 100644
--- a/src/test/java/org/apache/commons/beanutils2/bugs/Jira347TestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/bugs/Jira347TestCase.java
@@ -53,7 +53,7 @@
         final ClassLoader loader = newClassLoader();
         final Class<?> beanClass    = loader.loadClass(className);
         beanClass.newInstance();
-        // -----------------------------------------------------------------------------
+        
 
         // Sanity checks only
         assertNotNull("ClassLoader is null", loader);
diff --git a/src/test/java/org/apache/commons/beanutils2/converters/ArrayConverterTestCase.java b/src/test/java/org/apache/commons/beanutils2/converters/ArrayConverterTestCase.java
index 80a8b6f..3b4609c 100644
--- a/src/test/java/org/apache/commons/beanutils2/converters/ArrayConverterTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/converters/ArrayConverterTestCase.java
@@ -37,7 +37,7 @@
         return new TestSuite(ArrayConverterTestCase.class);
     }
 
-    // ------------------------------------------------------------------------
+    
 
     /**
      * Construct a new Array Converter test case.
@@ -74,7 +74,7 @@
     }
 
 
-    // ------------------------------------------------------------------------
+    
 
     /** Tear Down */
     @Override
diff --git a/src/test/java/org/apache/commons/beanutils2/converters/BigDecimalConverterTestCase.java b/src/test/java/org/apache/commons/beanutils2/converters/BigDecimalConverterTestCase.java
index 93a0de6..5f2b15d 100644
--- a/src/test/java/org/apache/commons/beanutils2/converters/BigDecimalConverterTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/converters/BigDecimalConverterTestCase.java
@@ -41,13 +41,13 @@
         }
     }
 
-    // ------------------------------------------------------------------------
+    
 
     public static TestSuite suite() {
         return new TestSuite(BigDecimalConverterTestCase.class);
     }
 
-    // ------------------------------------------------------------------------
+    
 
     private Converter converter = null;
 
@@ -60,7 +60,7 @@
         return BigDecimal.class;
     }
 
-    // ------------------------------------------------------------------------
+    
 
     @Override
     protected NumberConverter makeConverter() {
@@ -81,7 +81,7 @@
         numbers[3] = new BigDecimal("23");
     }
 
-    // ------------------------------------------------------------------------
+    
 
     @Override
     public void tearDown() throws Exception {
diff --git a/src/test/java/org/apache/commons/beanutils2/converters/BigIntegerConverterTestCase.java b/src/test/java/org/apache/commons/beanutils2/converters/BigIntegerConverterTestCase.java
index 559d9e6..5284e23 100644
--- a/src/test/java/org/apache/commons/beanutils2/converters/BigIntegerConverterTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/converters/BigIntegerConverterTestCase.java
@@ -34,11 +34,11 @@
         return new TestSuite(BigIntegerConverterTestCase.class);
     }
 
-    // ------------------------------------------------------------------------
+    
 
     private Converter converter = null;
 
-    // ------------------------------------------------------------------------
+    
 
     public BigIntegerConverterTestCase(final String name) {
         super(name);
@@ -54,7 +54,7 @@
         return new BigIntegerConverter();
     }
 
-    // ------------------------------------------------------------------------
+    
 
     @Override
     protected NumberConverter makeConverter(final Object defaultValue) {
@@ -75,7 +75,7 @@
         converter = null;
     }
 
-    // ------------------------------------------------------------------------
+    
 
     public void testSimpleConversion() throws Exception {
         final String[] message= {
diff --git a/src/test/java/org/apache/commons/beanutils2/converters/ByteConverterTestCase.java b/src/test/java/org/apache/commons/beanutils2/converters/ByteConverterTestCase.java
index 9bbaa81..57d3246 100644
--- a/src/test/java/org/apache/commons/beanutils2/converters/ByteConverterTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/converters/ByteConverterTestCase.java
@@ -33,11 +33,11 @@
         return new TestSuite(ByteConverterTestCase.class);
     }
 
-    // ------------------------------------------------------------------------
+    
 
     private Converter converter = null;
 
-    // ------------------------------------------------------------------------
+    
 
     public ByteConverterTestCase(final String name) {
         super(name);
@@ -53,7 +53,7 @@
         return new ByteConverter();
     }
 
-    // ------------------------------------------------------------------------
+    
 
     @Override
     protected NumberConverter makeConverter(final Object defaultValue) {
@@ -73,7 +73,7 @@
         converter = null;
     }
 
-    // ------------------------------------------------------------------------
+    
 
     /**
      * Test Invalid Amounts (too big/small)
diff --git a/src/test/java/org/apache/commons/beanutils2/converters/CalendarConverterTestCase.java b/src/test/java/org/apache/commons/beanutils2/converters/CalendarConverterTestCase.java
index 6f2b4c3..3af6be2 100644
--- a/src/test/java/org/apache/commons/beanutils2/converters/CalendarConverterTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/converters/CalendarConverterTestCase.java
@@ -34,7 +34,7 @@
         return new TestSuite(CalendarConverterTestCase.class);
     }
 
-    // ------------------------------------------------------------------------
+    
 
     /**
      * Construct a new Calendar test case.
@@ -53,7 +53,7 @@
         return Calendar.class;
     }
 
-    // ------------------------------------------------------------------------
+    
     /**
      * Create the Converter with no default value.
      * @return A new Converter
diff --git a/src/test/java/org/apache/commons/beanutils2/converters/CharacterConverterTestCase.java b/src/test/java/org/apache/commons/beanutils2/converters/CharacterConverterTestCase.java
index 1da2b12..4b52657 100644
--- a/src/test/java/org/apache/commons/beanutils2/converters/CharacterConverterTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/converters/CharacterConverterTestCase.java
@@ -36,7 +36,7 @@
         return new TestSuite(CharacterConverterTestCase.class);
     }
 
-    // ------------------------------------------------------------------------
+    
 
     /**
      * Construct a new Character Converter test case.
@@ -57,7 +57,7 @@
     }
 
 
-    // ------------------------------------------------------------------------
+    
 
     /**
      * Tests whether the primitive char class can be passed as target type.
diff --git a/src/test/java/org/apache/commons/beanutils2/converters/ClassConverterTestCase.java b/src/test/java/org/apache/commons/beanutils2/converters/ClassConverterTestCase.java
index e68f0a9..8e295a5 100644
--- a/src/test/java/org/apache/commons/beanutils2/converters/ClassConverterTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/converters/ClassConverterTestCase.java
@@ -36,7 +36,7 @@
         return new TestSuite(ClassConverterTestCase.class);
     }
 
-    // ------------------------------------------------------------------------
+    
 
     /**
      * Construct a new Class Converter test case.
@@ -57,7 +57,7 @@
     }
 
 
-    // ------------------------------------------------------------------------
+    
 
     /**
      * Test Array Conversion
diff --git a/src/test/java/org/apache/commons/beanutils2/converters/ClassReloaderTestCase.java b/src/test/java/org/apache/commons/beanutils2/converters/ClassReloaderTestCase.java
index c3dd0bd..8d0f5e9 100644
--- a/src/test/java/org/apache/commons/beanutils2/converters/ClassReloaderTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/converters/ClassReloaderTestCase.java
@@ -27,7 +27,7 @@
 
 public class ClassReloaderTestCase extends TestCase {
 
-    // ------------------------------------------------------------------------
+    
 
     public static class DummyClass {
     }
@@ -37,7 +37,7 @@
         return new TestSuite(ClassReloaderTestCase.class);
     }
 
-    // ------------------------------------------------------------------------
+    
 
     public ClassReloaderTestCase(final String name) {
         super(name);
diff --git a/src/test/java/org/apache/commons/beanutils2/converters/DateConverterTestBase.java b/src/test/java/org/apache/commons/beanutils2/converters/DateConverterTestBase.java
index 33e10e8..935d3ca 100644
--- a/src/test/java/org/apache/commons/beanutils2/converters/DateConverterTestBase.java
+++ b/src/test/java/org/apache/commons/beanutils2/converters/DateConverterTestBase.java
@@ -42,7 +42,7 @@
 
 public abstract class DateConverterTestBase extends TestCase {
 
-    // ------------------------------------------------------------------------
+    
 
     /**
      * Construct a new test case.
@@ -52,7 +52,7 @@
         super(name);
     }
 
-    // ------------------------------------------------------------------------
+    
 
     /**
      * Return the expected type
@@ -68,7 +68,7 @@
     long getTimeInMillis(final Object date) {
 
         if (date instanceof java.sql.Timestamp) {
-            // ---------------------- JDK 1.3 Fix ----------------------
+            
             // N.B. Prior to JDK 1.4 the Timestamp's getTime() method
             //      didn't include the milliseconds. The following code
             //      ensures it works consistently accross JDK versions
@@ -122,7 +122,7 @@
      */
     protected abstract DateTimeConverter makeConverter();
 
-    // ------------------------------------------------------------------------
+    
 
     /**
      * Create the Converter with a default value.
diff --git a/src/test/java/org/apache/commons/beanutils2/converters/DateConverterTestCase.java b/src/test/java/org/apache/commons/beanutils2/converters/DateConverterTestCase.java
index 71cd21d..cf31194 100644
--- a/src/test/java/org/apache/commons/beanutils2/converters/DateConverterTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/converters/DateConverterTestCase.java
@@ -35,7 +35,7 @@
         return new TestSuite(DateConverterTestCase.class);
     }
 
-    // ------------------------------------------------------------------------
+    
 
     /**
      * Construct a new Date test case.
@@ -63,7 +63,7 @@
         return new DateConverter();
     }
 
-    // ------------------------------------------------------------------------
+    
 
     /**
      * Create the Converter with a default value.
diff --git a/src/test/java/org/apache/commons/beanutils2/converters/DoubleConverterTestCase.java b/src/test/java/org/apache/commons/beanutils2/converters/DoubleConverterTestCase.java
index 20e07eb..bf0118e 100644
--- a/src/test/java/org/apache/commons/beanutils2/converters/DoubleConverterTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/converters/DoubleConverterTestCase.java
@@ -33,11 +33,11 @@
         return new TestSuite(DoubleConverterTestCase.class);
     }
 
-    // ------------------------------------------------------------------------
+    
 
     private Converter converter = null;
 
-    // ------------------------------------------------------------------------
+    
 
     public DoubleConverterTestCase(final String name) {
         super(name);
@@ -53,7 +53,7 @@
         return new DoubleConverter();
     }
 
-    // ------------------------------------------------------------------------
+    
 
     @Override
     protected NumberConverter makeConverter(final Object defaultValue) {
@@ -74,7 +74,7 @@
         converter = null;
     }
 
-    // ------------------------------------------------------------------------
+    
 
     public void testSimpleConversion() throws Exception {
         final String[] message= {
diff --git a/src/test/java/org/apache/commons/beanutils2/converters/DurationConverterTestCase.java b/src/test/java/org/apache/commons/beanutils2/converters/DurationConverterTestCase.java
index a32fda8..0883c1b 100644
--- a/src/test/java/org/apache/commons/beanutils2/converters/DurationConverterTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/converters/DurationConverterTestCase.java
@@ -37,11 +37,11 @@
         return new TestSuite(DurationConverterTestCase.class);
     }
 
-    // ------------------------------------------------------------------------
+    
 
     private Converter converter = null;
 
-    // ------------------------------------------------------------------------
+    
 
     public DurationConverterTestCase(final String name) {
         super(name);
@@ -55,7 +55,7 @@
         return new DurationConverter();
     }
 
-    // ------------------------------------------------------------------------
+    
 
     @Override
     public void setUp() throws Exception {
@@ -67,7 +67,7 @@
         converter = null;
     }
 
-    // ------------------------------------------------------------------------
+    
 
     public void testSimpleConversion() throws Exception {
         final String[] message= {
diff --git a/src/test/java/org/apache/commons/beanutils2/converters/FileConverterTestCase.java b/src/test/java/org/apache/commons/beanutils2/converters/FileConverterTestCase.java
index 8bb8c2e..03d4ebe 100644
--- a/src/test/java/org/apache/commons/beanutils2/converters/FileConverterTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/converters/FileConverterTestCase.java
@@ -37,11 +37,11 @@
         return new TestSuite(FileConverterTestCase.class);
     }
 
-    // ------------------------------------------------------------------------
+    
 
     private Converter converter = null;
 
-    // ------------------------------------------------------------------------
+    
 
     public FileConverterTestCase(final String name) {
         super(name);
@@ -55,7 +55,7 @@
         return new FileConverter();
     }
 
-    // ------------------------------------------------------------------------
+    
 
     @Override
     public void setUp() throws Exception {
@@ -67,7 +67,7 @@
         converter = null;
     }
 
-    // ------------------------------------------------------------------------
+    
 
     public void testSimpleConversion() throws Exception {
         final String[] message= {
diff --git a/src/test/java/org/apache/commons/beanutils2/converters/FloatConverterTestCase.java b/src/test/java/org/apache/commons/beanutils2/converters/FloatConverterTestCase.java
index 03b5176..2bed384 100644
--- a/src/test/java/org/apache/commons/beanutils2/converters/FloatConverterTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/converters/FloatConverterTestCase.java
@@ -33,11 +33,11 @@
         return new TestSuite(FloatConverterTestCase.class);
     }
 
-    // ------------------------------------------------------------------------
+    
 
     private Converter converter = null;
 
-    // ------------------------------------------------------------------------
+    
 
     public FloatConverterTestCase(final String name) {
         super(name);
@@ -53,7 +53,7 @@
         return new FloatConverter();
     }
 
-    // ------------------------------------------------------------------------
+    
 
     @Override
     protected NumberConverter makeConverter(final Object defaultValue) {
@@ -74,7 +74,7 @@
         converter = null;
     }
 
-    // ------------------------------------------------------------------------
+    
 
     /**
      * Test Invalid Amounts (too big/small)
diff --git a/src/test/java/org/apache/commons/beanutils2/converters/IntegerConverterTestCase.java b/src/test/java/org/apache/commons/beanutils2/converters/IntegerConverterTestCase.java
index 71d4641..f1bd9ba 100644
--- a/src/test/java/org/apache/commons/beanutils2/converters/IntegerConverterTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/converters/IntegerConverterTestCase.java
@@ -34,11 +34,11 @@
         return new TestSuite(IntegerConverterTestCase.class);
     }
 
-    // ------------------------------------------------------------------------
+    
 
     private Converter converter = null;
 
-    // ------------------------------------------------------------------------
+    
 
     public IntegerConverterTestCase(final String name) {
         super(name);
@@ -54,7 +54,7 @@
         return new IntegerConverter();
     }
 
-    // ------------------------------------------------------------------------
+    
 
     @Override
     protected NumberConverter makeConverter(final Object defaultValue) {
@@ -75,7 +75,7 @@
         converter = null;
     }
 
-    // ------------------------------------------------------------------------
+    
 
     /**
      * Test Invalid Amounts (too big/small)
diff --git a/src/test/java/org/apache/commons/beanutils2/converters/LocalDateConverterTestCase.java b/src/test/java/org/apache/commons/beanutils2/converters/LocalDateConverterTestCase.java
index 3f05e24..db4b898 100644
--- a/src/test/java/org/apache/commons/beanutils2/converters/LocalDateConverterTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/converters/LocalDateConverterTestCase.java
@@ -37,7 +37,7 @@
         return new TestSuite(LocalDateConverterTestCase.class);
     }
 
-    // ------------------------------------------------------------------------
+    
 
     /**
      * Construct a new Date test case.
@@ -65,7 +65,7 @@
         return new LocalDateConverter();
     }
 
-    // ------------------------------------------------------------------------
+    
 
     /**
      * Create the Converter with a default value.
diff --git a/src/test/java/org/apache/commons/beanutils2/converters/LocalDateTimeConverterTestCase.java b/src/test/java/org/apache/commons/beanutils2/converters/LocalDateTimeConverterTestCase.java
index 37c5833..4ad9ff1 100644
--- a/src/test/java/org/apache/commons/beanutils2/converters/LocalDateTimeConverterTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/converters/LocalDateTimeConverterTestCase.java
@@ -37,7 +37,7 @@
         return new TestSuite(LocalDateTimeConverterTestCase.class);
     }
 
-    // ------------------------------------------------------------------------
+    
 
     /**
      * Construct a new Date test case.
@@ -65,7 +65,7 @@
         return new LocalDateTimeConverter();
     }
 
-    // ------------------------------------------------------------------------
+    
 
     /**
      * Create the Converter with a default value.
diff --git a/src/test/java/org/apache/commons/beanutils2/converters/LocalTimeConverterTestCase.java b/src/test/java/org/apache/commons/beanutils2/converters/LocalTimeConverterTestCase.java
index 7130765..d375bab 100644
--- a/src/test/java/org/apache/commons/beanutils2/converters/LocalTimeConverterTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/converters/LocalTimeConverterTestCase.java
@@ -37,11 +37,11 @@
         return new TestSuite(LocalTimeConverterTestCase.class);
     }
 
-    // ------------------------------------------------------------------------
+    
 
     private Converter converter = null;
 
-    // ------------------------------------------------------------------------
+    
 
     public LocalTimeConverterTestCase(final String name) {
         super(name);
@@ -55,7 +55,7 @@
         return new LocalTimeConverter();
     }
 
-    // ------------------------------------------------------------------------
+    
 
     @Override
     public void setUp() throws Exception {
@@ -67,7 +67,7 @@
         converter = null;
     }
 
-    // ------------------------------------------------------------------------
+    
 
     public void testSimpleConversion() throws Exception {
         final String[] message= {
diff --git a/src/test/java/org/apache/commons/beanutils2/converters/LongConverterTestCase.java b/src/test/java/org/apache/commons/beanutils2/converters/LongConverterTestCase.java
index 31f24e1..795f0cb 100644
--- a/src/test/java/org/apache/commons/beanutils2/converters/LongConverterTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/converters/LongConverterTestCase.java
@@ -33,11 +33,11 @@
         return new TestSuite(LongConverterTestCase.class);
     }
 
-    // ------------------------------------------------------------------------
+    
 
     private Converter converter = null;
 
-    // ------------------------------------------------------------------------
+    
 
     public LongConverterTestCase(final String name) {
         super(name);
@@ -53,7 +53,7 @@
         return new LongConverter();
     }
 
-    // ------------------------------------------------------------------------
+    
 
     @Override
     protected NumberConverter makeConverter(final Object defaultValue) {
@@ -74,7 +74,7 @@
         converter = null;
     }
 
-    // ------------------------------------------------------------------------
+    
 
     public void testSimpleConversion() throws Exception {
         final String[] message= {
diff --git a/src/test/java/org/apache/commons/beanutils2/converters/MonthDayConverterTestCase.java b/src/test/java/org/apache/commons/beanutils2/converters/MonthDayConverterTestCase.java
index 5d5ef64..0c87542 100644
--- a/src/test/java/org/apache/commons/beanutils2/converters/MonthDayConverterTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/converters/MonthDayConverterTestCase.java
@@ -37,11 +37,11 @@
         return new TestSuite(MonthDayConverterTestCase.class);
     }
 
-    // ------------------------------------------------------------------------
+    
 
     private Converter converter = null;
 
-    // ------------------------------------------------------------------------
+    
 
     public MonthDayConverterTestCase(final String name) {
         super(name);
@@ -55,7 +55,7 @@
         return new MonthDayConverter();
     }
 
-    // ------------------------------------------------------------------------
+    
 
     @Override
     public void setUp() throws Exception {
@@ -67,7 +67,7 @@
         converter = null;
     }
 
-    // ------------------------------------------------------------------------
+    
 
     public void testSimpleConversion() throws Exception {
         final String[] message= {
diff --git a/src/test/java/org/apache/commons/beanutils2/converters/NumberConverterTestBase.java b/src/test/java/org/apache/commons/beanutils2/converters/NumberConverterTestBase.java
index e42a202..658c6e9 100644
--- a/src/test/java/org/apache/commons/beanutils2/converters/NumberConverterTestBase.java
+++ b/src/test/java/org/apache/commons/beanutils2/converters/NumberConverterTestBase.java
@@ -38,19 +38,19 @@
     /** Test Number values */
     protected Number[] numbers = new Number[4];
 
-    // ------------------------------------------------------------------------
+    
 
     public NumberConverterTestBase(final String name) {
         super(name);
     }
 
-    // ------------------------------------------------------------------------
+    
 
     protected abstract Class<?> getExpectedType();
     protected abstract NumberConverter makeConverter();
     protected abstract NumberConverter makeConverter(Object defaultValue);
 
-    // ------------------------------------------------------------------------
+    
 
     /**
      * Convert Boolean --> Number (default conversion)
diff --git a/src/test/java/org/apache/commons/beanutils2/converters/OffsetDateTimeConverterTestCase.java b/src/test/java/org/apache/commons/beanutils2/converters/OffsetDateTimeConverterTestCase.java
index 5014d6a..1b407cc 100644
--- a/src/test/java/org/apache/commons/beanutils2/converters/OffsetDateTimeConverterTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/converters/OffsetDateTimeConverterTestCase.java
@@ -37,7 +37,7 @@
         return new TestSuite(OffsetDateTimeConverterTestCase.class);
     }
 
-    // ------------------------------------------------------------------------
+    
 
     /**
      * Construct a new Date test case.
@@ -65,7 +65,7 @@
         return new OffsetDateTimeConverter();
     }
 
-    // ------------------------------------------------------------------------
+    
 
     /**
      * Create the Converter with a default value.
diff --git a/src/test/java/org/apache/commons/beanutils2/converters/OffsetTimeConverterTestCase.java b/src/test/java/org/apache/commons/beanutils2/converters/OffsetTimeConverterTestCase.java
index 1f7eb8f..5925fbf 100644
--- a/src/test/java/org/apache/commons/beanutils2/converters/OffsetTimeConverterTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/converters/OffsetTimeConverterTestCase.java
@@ -37,11 +37,11 @@
         return new TestSuite(OffsetTimeConverterTestCase.class);
     }
 
-    // ------------------------------------------------------------------------
+    
 
     private Converter converter = null;
 
-    // ------------------------------------------------------------------------
+    
 
     public OffsetTimeConverterTestCase(final String name) {
         super(name);
@@ -55,7 +55,7 @@
         return new OffsetTimeConverter();
     }
 
-    // ------------------------------------------------------------------------
+    
 
     @Override
     public void setUp() throws Exception {
@@ -67,7 +67,7 @@
         converter = null;
     }
 
-    // ------------------------------------------------------------------------
+    
 
     public void testSimpleConversion() throws Exception {
         final String[] message= {
diff --git a/src/test/java/org/apache/commons/beanutils2/converters/PathConverterTestCase.java b/src/test/java/org/apache/commons/beanutils2/converters/PathConverterTestCase.java
index 5723cfc..de6dc27 100644
--- a/src/test/java/org/apache/commons/beanutils2/converters/PathConverterTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/converters/PathConverterTestCase.java
@@ -40,11 +40,11 @@
         return new TestSuite(PathConverterTestCase.class);
     }
 
-    // ------------------------------------------------------------------------
+    
 
     private Converter converter = null;
 
-    // ------------------------------------------------------------------------
+    
 
     public PathConverterTestCase(final String name) {
         super(name);
@@ -58,7 +58,7 @@
         return new PathConverter();
     }
 
-    // ------------------------------------------------------------------------
+    
 
     @Override
     public void setUp() throws Exception {
@@ -70,7 +70,7 @@
         converter = null;
     }
 
-    // ------------------------------------------------------------------------
+    
 
     public void testSimpleConversion() throws Exception {
         final String[] message= {
diff --git a/src/test/java/org/apache/commons/beanutils2/converters/PeriodConverterTestCase.java b/src/test/java/org/apache/commons/beanutils2/converters/PeriodConverterTestCase.java
index c6e06fa..3b7c247 100644
--- a/src/test/java/org/apache/commons/beanutils2/converters/PeriodConverterTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/converters/PeriodConverterTestCase.java
@@ -37,11 +37,11 @@
         return new TestSuite(PeriodConverterTestCase.class);
     }
 
-    // ------------------------------------------------------------------------
+    
 
     private Converter converter = null;
 
-    // ------------------------------------------------------------------------
+    
 
     public PeriodConverterTestCase(final String name) {
         super(name);
@@ -55,7 +55,7 @@
         return new PeriodConverter();
     }
 
-    // ------------------------------------------------------------------------
+    
 
     @Override
     public void setUp() throws Exception {
@@ -67,7 +67,7 @@
         converter = null;
     }
 
-    // ------------------------------------------------------------------------
+    
 
     public void testSimpleConversion() throws Exception {
         final String[] message= {
diff --git a/src/test/java/org/apache/commons/beanutils2/converters/ShortConverterTestCase.java b/src/test/java/org/apache/commons/beanutils2/converters/ShortConverterTestCase.java
index d1733e3..bd5b0a2 100644
--- a/src/test/java/org/apache/commons/beanutils2/converters/ShortConverterTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/converters/ShortConverterTestCase.java
@@ -33,11 +33,11 @@
         return new TestSuite(ShortConverterTestCase.class);
     }
 
-    // ------------------------------------------------------------------------
+    
 
     private Converter converter = null;
 
-    // ------------------------------------------------------------------------
+    
 
     public ShortConverterTestCase(final String name) {
         super(name);
@@ -53,7 +53,7 @@
         return new ShortConverter();
     }
 
-    // ------------------------------------------------------------------------
+    
 
     @Override
     protected NumberConverter makeConverter(final Object defaultValue) {
@@ -74,7 +74,7 @@
         converter = null;
     }
 
-    // ------------------------------------------------------------------------
+    
 
     /**
      * Test Invalid Amounts (too big/small)
diff --git a/src/test/java/org/apache/commons/beanutils2/converters/SqlDateConverterTestCase.java b/src/test/java/org/apache/commons/beanutils2/converters/SqlDateConverterTestCase.java
index 2b3ed93..644ab1b 100644
--- a/src/test/java/org/apache/commons/beanutils2/converters/SqlDateConverterTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/converters/SqlDateConverterTestCase.java
@@ -37,7 +37,7 @@
         return new TestSuite(SqlDateConverterTestCase.class);
     }
 
-    // ------------------------------------------------------------------------
+    
 
     /**
      * Construct a new Date test case.
@@ -47,7 +47,7 @@
         super(name);
     }
 
-    // ------------------------------------------------------------------------
+    
 
     /**
      * Return the expected type
diff --git a/src/test/java/org/apache/commons/beanutils2/converters/SqlTimeConverterTestCase.java b/src/test/java/org/apache/commons/beanutils2/converters/SqlTimeConverterTestCase.java
index a3bae0e..91c1d1b 100644
--- a/src/test/java/org/apache/commons/beanutils2/converters/SqlTimeConverterTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/converters/SqlTimeConverterTestCase.java
@@ -38,7 +38,7 @@
         return new TestSuite(SqlTimeConverterTestCase.class);
     }
 
-    // ------------------------------------------------------------------------
+    
 
     /**
      * Construct a new Date test case.
@@ -48,7 +48,7 @@
         super(name);
     }
 
-    // ------------------------------------------------------------------------
+    
 
     /**
      * Return the expected type
diff --git a/src/test/java/org/apache/commons/beanutils2/converters/SqlTimestampConverterTestCase.java b/src/test/java/org/apache/commons/beanutils2/converters/SqlTimestampConverterTestCase.java
index c1e0d1f..6698abe 100644
--- a/src/test/java/org/apache/commons/beanutils2/converters/SqlTimestampConverterTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/converters/SqlTimestampConverterTestCase.java
@@ -40,7 +40,7 @@
         return new TestSuite(SqlTimestampConverterTestCase.class);
     }
 
-    // ------------------------------------------------------------------------
+    
 
     /**
      * Construct a new Date test case.
@@ -50,7 +50,7 @@
         super(name);
     }
 
-    // ------------------------------------------------------------------------
+    
 
     /**
      * Return the expected type
diff --git a/src/test/java/org/apache/commons/beanutils2/converters/URIConverterTestCase.java b/src/test/java/org/apache/commons/beanutils2/converters/URIConverterTestCase.java
index faad7e0..9858f61 100644
--- a/src/test/java/org/apache/commons/beanutils2/converters/URIConverterTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/converters/URIConverterTestCase.java
@@ -36,11 +36,11 @@
         return new TestSuite(URIConverterTestCase.class);
     }
 
-    // ------------------------------------------------------------------------
+    
 
     private Converter converter = null;
 
-    // ------------------------------------------------------------------------
+    
 
     public URIConverterTestCase(final String name) {
         super(name);
@@ -54,7 +54,7 @@
         return new URIConverter();
     }
 
-    // ------------------------------------------------------------------------
+    
 
     @Override
     public void setUp() throws Exception {
@@ -66,7 +66,7 @@
         converter = null;
     }
 
-    // ------------------------------------------------------------------------
+    
 
     public void testSimpleConversion() throws Exception {
         final String[] message= {
diff --git a/src/test/java/org/apache/commons/beanutils2/converters/URLConverterTestCase.java b/src/test/java/org/apache/commons/beanutils2/converters/URLConverterTestCase.java
index 05241cd..1d89f77 100644
--- a/src/test/java/org/apache/commons/beanutils2/converters/URLConverterTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/converters/URLConverterTestCase.java
@@ -37,11 +37,11 @@
         return new TestSuite(URLConverterTestCase.class);
     }
 
-    // ------------------------------------------------------------------------
+    
 
     private Converter converter = null;
 
-    // ------------------------------------------------------------------------
+    
 
     public URLConverterTestCase(final String name) {
         super(name);
@@ -55,7 +55,7 @@
         return new URLConverter();
     }
 
-    // ------------------------------------------------------------------------
+    
 
     @Override
     public void setUp() throws Exception {
@@ -67,7 +67,7 @@
         converter = null;
     }
 
-    // ------------------------------------------------------------------------
+    
 
     public void testSimpleConversion() throws Exception {
         final String[] message= {
diff --git a/src/test/java/org/apache/commons/beanutils2/converters/UUIDConverterTestCase.java b/src/test/java/org/apache/commons/beanutils2/converters/UUIDConverterTestCase.java
index bb08b8a..6ae4b93 100644
--- a/src/test/java/org/apache/commons/beanutils2/converters/UUIDConverterTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/converters/UUIDConverterTestCase.java
@@ -37,11 +37,11 @@
         return new TestSuite(UUIDConverterTestCase.class);
     }
 
-    // ------------------------------------------------------------------------
+    
 
     private Converter converter = null;
 
-    // ------------------------------------------------------------------------
+    
 
     public UUIDConverterTestCase(final String name) {
         super(name);
@@ -55,7 +55,7 @@
         return new UUIDConverter();
     }
 
-    // ------------------------------------------------------------------------
+    
 
     @Override
     public void setUp() throws Exception {
@@ -67,7 +67,7 @@
         converter = null;
     }
 
-    // ------------------------------------------------------------------------
+    
 
     public void testSimpleConversion() throws Exception {
         final String[] message= {
diff --git a/src/test/java/org/apache/commons/beanutils2/converters/YearConverterTestCase.java b/src/test/java/org/apache/commons/beanutils2/converters/YearConverterTestCase.java
index 2930c3b..7166247 100644
--- a/src/test/java/org/apache/commons/beanutils2/converters/YearConverterTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/converters/YearConverterTestCase.java
@@ -37,11 +37,11 @@
         return new TestSuite(YearConverterTestCase.class);
     }
 
-    // ------------------------------------------------------------------------
+    
 
     private Converter converter = null;
 
-    // ------------------------------------------------------------------------
+    
 
     public YearConverterTestCase(final String name) {
         super(name);
@@ -55,7 +55,7 @@
         return new YearConverter();
     }
 
-    // ------------------------------------------------------------------------
+    
 
     @Override
     public void setUp() throws Exception {
@@ -67,7 +67,7 @@
         converter = null;
     }
 
-    // ------------------------------------------------------------------------
+    
 
     public void testSimpleConversion() throws Exception {
         final String[] message= {
diff --git a/src/test/java/org/apache/commons/beanutils2/converters/YearMonthConverterTestCase.java b/src/test/java/org/apache/commons/beanutils2/converters/YearMonthConverterTestCase.java
index ba6833e..e9a7355 100644
--- a/src/test/java/org/apache/commons/beanutils2/converters/YearMonthConverterTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/converters/YearMonthConverterTestCase.java
@@ -37,11 +37,11 @@
         return new TestSuite(YearMonthConverterTestCase.class);
     }
 
-    // ------------------------------------------------------------------------
+    
 
     private Converter converter = null;
 
-    // ------------------------------------------------------------------------
+    
 
     public YearMonthConverterTestCase(final String name) {
         super(name);
@@ -55,7 +55,7 @@
         return new YearMonthConverter();
     }
 
-    // ------------------------------------------------------------------------
+    
 
     @Override
     public void setUp() throws Exception {
@@ -67,7 +67,7 @@
         converter = null;
     }
 
-    // ------------------------------------------------------------------------
+    
 
     public void testSimpleConversion() throws Exception {
         final String[] message= {
diff --git a/src/test/java/org/apache/commons/beanutils2/converters/ZoneIdConverterTestCase.java b/src/test/java/org/apache/commons/beanutils2/converters/ZoneIdConverterTestCase.java
index 4021866..03529c7 100644
--- a/src/test/java/org/apache/commons/beanutils2/converters/ZoneIdConverterTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/converters/ZoneIdConverterTestCase.java
@@ -37,11 +37,11 @@
         return new TestSuite(ZoneIdConverterTestCase.class);
     }
 
-    // ------------------------------------------------------------------------
+    
 
     private Converter converter = null;
 
-    // ------------------------------------------------------------------------
+    
 
     public ZoneIdConverterTestCase(final String name) {
         super(name);
@@ -55,7 +55,7 @@
         return new ZoneIdConverter();
     }
 
-    // ------------------------------------------------------------------------
+    
 
     @Override
     public void setUp() throws Exception {
@@ -67,7 +67,7 @@
         converter = null;
     }
 
-    // ------------------------------------------------------------------------
+    
 
     public void testSimpleConversion() throws Exception {
         final String[] message= {
diff --git a/src/test/java/org/apache/commons/beanutils2/converters/ZoneOffsetConverterTestCase.java b/src/test/java/org/apache/commons/beanutils2/converters/ZoneOffsetConverterTestCase.java
index 9b68285..5c02328 100644
--- a/src/test/java/org/apache/commons/beanutils2/converters/ZoneOffsetConverterTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/converters/ZoneOffsetConverterTestCase.java
@@ -37,11 +37,11 @@
         return new TestSuite(ZoneOffsetConverterTestCase.class);
     }
 
-    // ------------------------------------------------------------------------
+    
 
     private Converter converter = null;
 
-    // ------------------------------------------------------------------------
+    
 
     public ZoneOffsetConverterTestCase(final String name) {
         super(name);
@@ -55,7 +55,7 @@
         return new ZoneOffsetConverter();
     }
 
-    // ------------------------------------------------------------------------
+    
 
     @Override
     public void setUp() throws Exception {
@@ -67,7 +67,7 @@
         converter = null;
     }
 
-    // ------------------------------------------------------------------------
+    
 
     public void testSimpleConversion() throws Exception {
         final String[] message= {
diff --git a/src/test/java/org/apache/commons/beanutils2/converters/ZonedDateTimeConverterTestCase.java b/src/test/java/org/apache/commons/beanutils2/converters/ZonedDateTimeConverterTestCase.java
index c6ccb8e..c42f06c 100644
--- a/src/test/java/org/apache/commons/beanutils2/converters/ZonedDateTimeConverterTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/converters/ZonedDateTimeConverterTestCase.java
@@ -37,7 +37,7 @@
         return new TestSuite(ZonedDateTimeConverterTestCase.class);
     }
 
-    // ------------------------------------------------------------------------
+    
 
     /**
      * Construct a new Date test case.
@@ -65,7 +65,7 @@
         return new ZonedDateTimeConverter();
     }
 
-    // ------------------------------------------------------------------------
+    
 
     /**
      * Create the Converter with a default value.
diff --git a/src/test/java/org/apache/commons/beanutils2/expression/DefaultResolverTestCase.java b/src/test/java/org/apache/commons/beanutils2/expression/DefaultResolverTestCase.java
index d72ee34..1e48f5a 100644
--- a/src/test/java/org/apache/commons/beanutils2/expression/DefaultResolverTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/expression/DefaultResolverTestCase.java
@@ -53,7 +53,7 @@
         super(name);
     }
 
-    // ------------------------------------------------------------------------
+    
 
     /**
      * Create Test Suite
@@ -77,7 +77,7 @@
     protected void tearDown() {
     }
 
-    // ------------------------------------------------------------------------
+    
 
     /**
      * Test getIndex() method.
diff --git a/src/test/java/org/apache/commons/beanutils2/locale/LocaleBeanUtilsTestCase.java b/src/test/java/org/apache/commons/beanutils2/locale/LocaleBeanUtilsTestCase.java
index 56aff1d..3bc6562 100644
--- a/src/test/java/org/apache/commons/beanutils2/locale/LocaleBeanUtilsTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/locale/LocaleBeanUtilsTestCase.java
@@ -42,7 +42,7 @@
     }
 
 
-    // -------------------------------------------------- Overall Test Methods
+    
 
 
     /**
@@ -70,7 +70,7 @@
     }
 
 
-    // ------------------------------------------------ Individual Test Methods
+    
 
     /**
      * Test setting a nested simple property
diff --git a/src/test/java/org/apache/commons/beanutils2/locale/LocaleBeanificationTestCase.java b/src/test/java/org/apache/commons/beanutils2/locale/LocaleBeanificationTestCase.java
index cdc9a26..05969f3 100644
--- a/src/test/java/org/apache/commons/beanutils2/locale/LocaleBeanificationTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/locale/LocaleBeanificationTestCase.java
@@ -46,15 +46,15 @@
 
 public class LocaleBeanificationTestCase extends TestCase {
 
-    // ---------------------------------------------------- Constants
+    
 
     /** Maximum number of iterations before our test fails */
     public static final int MAX_GC_ITERATIONS = 50;
 
-    // ---------------------------------------------------- Instance Variables
+    
 
 
-    // ---------------------------------------------------------- Constructors
+    
 
 
     /**
@@ -67,7 +67,7 @@
     }
 
 
-    // -------------------------------------------------- Overall Test Methods
+    
 
 
     /**
@@ -98,7 +98,7 @@
     }
 
 
-    // ------------------------------------------------ Individual Test Methods
+    
 
     /** Test of the methodology we'll use for some of the later tests */
     public void testMemoryTestMethodology() throws Exception {
diff --git a/src/test/java/org/apache/commons/beanutils2/locale/LocaleConvertUtilsTestCase.java b/src/test/java/org/apache/commons/beanutils2/locale/LocaleConvertUtilsTestCase.java
index 87d0d78..6706181 100644
--- a/src/test/java/org/apache/commons/beanutils2/locale/LocaleConvertUtilsTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/locale/LocaleConvertUtilsTestCase.java
@@ -41,11 +41,11 @@
 
 public class LocaleConvertUtilsTestCase extends TestCase {
 
-    // ---------------------------------------------------- Instance Variables
+    
 
     private char m_decimalSeparator;
 
-    // ---------------------------------------------------------- Constructors
+    
 
 
     /**
@@ -58,7 +58,7 @@
     }
 
 
-    // -------------------------------------------------- Overall Test Methods
+    
 
 
     /**
@@ -96,7 +96,7 @@
     }
 
 
-    // ------------------------------------------------ Individual Test Methods
+    
 
 
     /**
@@ -638,7 +638,7 @@
                 LocaleConvertUtils.convert(value.toString(), getClass()));
     }
 
-    // -------------------------------------------------------- Private Methods
+    
 
 
     private void checkIntegerArray(final Object value, final int intArray[]) {
diff --git a/src/test/java/org/apache/commons/beanutils2/locale/converters/BaseLocaleConverterTestCase.java b/src/test/java/org/apache/commons/beanutils2/locale/converters/BaseLocaleConverterTestCase.java
index 452a55f..85afc97 100644
--- a/src/test/java/org/apache/commons/beanutils2/locale/converters/BaseLocaleConverterTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/locale/converters/BaseLocaleConverterTestCase.java
@@ -62,13 +62,13 @@
     protected String expectedDecimalValue;
     protected String expectedIntegerValue;
 
-    // ---------------------------------------------------------- Constructors
+    
 
     public BaseLocaleConverterTestCase(final String name) {
         super(name);
     }
 
-    // -------------------------------------------------- Overall Test Methods
+    
 
     /**
      * Set up instance variables required by this test case.
@@ -133,7 +133,7 @@
     }
 
 
-    // -------------------------------------------------- Generic Test Methods
+    
 
     /**
      * Test Converting Value WITH a pattern
diff --git a/src/test/java/org/apache/commons/beanutils2/locale/converters/BigDecimalLocaleConverterTestCase.java b/src/test/java/org/apache/commons/beanutils2/locale/converters/BigDecimalLocaleConverterTestCase.java
index 0be63e5..18eb556 100644
--- a/src/test/java/org/apache/commons/beanutils2/locale/converters/BigDecimalLocaleConverterTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/locale/converters/BigDecimalLocaleConverterTestCase.java
@@ -28,13 +28,13 @@
 
 
 
-    // ---------------------------------------------------------- Constructors
+    
 
     public BigDecimalLocaleConverterTestCase(final String name) {
         super(name);
     }
 
-    // -------------------------------------------------- Overall Test Methods
+    
 
     /**
      * Set up instance variables required by this test case.
@@ -58,7 +58,7 @@
     }
 
 
-    // ------------------------------------------------------------------------
+    
 
     /**
      * Test Converter(defaultValue, locale, pattern, localizedPattern) constructor
diff --git a/src/test/java/org/apache/commons/beanutils2/locale/converters/BigIntegerLocaleConverterTestCase.java b/src/test/java/org/apache/commons/beanutils2/locale/converters/BigIntegerLocaleConverterTestCase.java
index c7bf892..978c170 100644
--- a/src/test/java/org/apache/commons/beanutils2/locale/converters/BigIntegerLocaleConverterTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/locale/converters/BigIntegerLocaleConverterTestCase.java
@@ -30,13 +30,13 @@
 
 
 
-    // ---------------------------------------------------------- Constructors
+    
 
     public BigIntegerLocaleConverterTestCase(final String name) {
         super(name);
     }
 
-    // -------------------------------------------------- Overall Test Methods
+    
 
     /**
      * Set up instance variables required by this test case.
@@ -60,7 +60,7 @@
     }
 
 
-    // ------------------------------------------------------------------------
+    
 
     /**
      * Test Converter(defaultValue, locale, pattern, localizedPattern) constructor
diff --git a/src/test/java/org/apache/commons/beanutils2/locale/converters/ByteLocaleConverterTestCase.java b/src/test/java/org/apache/commons/beanutils2/locale/converters/ByteLocaleConverterTestCase.java
index 458e10a..8f50474 100644
--- a/src/test/java/org/apache/commons/beanutils2/locale/converters/ByteLocaleConverterTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/locale/converters/ByteLocaleConverterTestCase.java
@@ -24,13 +24,13 @@
 
 public class ByteLocaleConverterTestCase extends BaseLocaleConverterTestCase {
 
-    // ---------------------------------------------------------- Constructors
+    
 
     public ByteLocaleConverterTestCase(final String name) {
         super(name);
     }
 
-    // -------------------------------------------------- Overall Test Methods
+    
 
     /**
      * Set up instance variables required by this test case.
@@ -65,7 +65,7 @@
     }
 
 
-    // ------------------------------------------------------------------------
+    
 
     /**
      * Test Converter(defaultValue, locale, pattern, localizedPattern) constructor
diff --git a/src/test/java/org/apache/commons/beanutils2/locale/converters/DateLocaleConverterTestCase.java b/src/test/java/org/apache/commons/beanutils2/locale/converters/DateLocaleConverterTestCase.java
index 8dfe325..507e1f5 100644
--- a/src/test/java/org/apache/commons/beanutils2/locale/converters/DateLocaleConverterTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/locale/converters/DateLocaleConverterTestCase.java
@@ -45,13 +45,13 @@
 
     protected boolean validLocalDateSymbols;
 
-    // ------------------------------------------------------------------------
+    
 
     public DateLocaleConverterTestCase(final String name) {
         super(name);
     }
 
-    // -------------------------------------------------- Overall Test Methods
+    
 
     /**
      * Set up instance variables required by this test case.
@@ -111,7 +111,7 @@
     }
 
 
-    // ------------------------------------------------------------------------
+    
 
     public void testSetLenient() {
         // make sure that date format works as expected
diff --git a/src/test/java/org/apache/commons/beanutils2/locale/converters/DoubleLocaleConverterTestCase.java b/src/test/java/org/apache/commons/beanutils2/locale/converters/DoubleLocaleConverterTestCase.java
index fd144ec..e6082c6 100644
--- a/src/test/java/org/apache/commons/beanutils2/locale/converters/DoubleLocaleConverterTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/locale/converters/DoubleLocaleConverterTestCase.java
@@ -26,13 +26,13 @@
 
 
 
-    // ---------------------------------------------------------- Constructors
+    
 
     public DoubleLocaleConverterTestCase(final String name) {
         super(name);
     }
 
-    // -------------------------------------------------- Overall Test Methods
+    
 
     /**
      * Set up instance variables required by this test case.
@@ -56,7 +56,7 @@
     }
 
 
-    // ------------------------------------------------------------------------
+    
 
     /**
      * Test Converter(defaultValue, locale, pattern, localizedPattern) constructor
diff --git a/src/test/java/org/apache/commons/beanutils2/locale/converters/FloatLocaleConverterTestCase.java b/src/test/java/org/apache/commons/beanutils2/locale/converters/FloatLocaleConverterTestCase.java
index f3f857c..621ec7f 100644
--- a/src/test/java/org/apache/commons/beanutils2/locale/converters/FloatLocaleConverterTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/locale/converters/FloatLocaleConverterTestCase.java
@@ -32,13 +32,13 @@
 
 
 
-    // ---------------------------------------------------------- Constructors
+    
 
     public FloatLocaleConverterTestCase(final String name) {
         super(name);
     }
 
-    // -------------------------------------------------- Overall Test Methods
+    
 
     /**
      * Set up instance variables required by this test case.
@@ -62,7 +62,7 @@
     }
 
 
-    // ------------------------------------------------------------------------
+    
 
     /**
      * Test Converter(defaultValue, locale, pattern, localizedPattern) constructor
diff --git a/src/test/java/org/apache/commons/beanutils2/locale/converters/IntegerLocaleConverterTestCase.java b/src/test/java/org/apache/commons/beanutils2/locale/converters/IntegerLocaleConverterTestCase.java
index f9605b3..ed1970c 100644
--- a/src/test/java/org/apache/commons/beanutils2/locale/converters/IntegerLocaleConverterTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/locale/converters/IntegerLocaleConverterTestCase.java
@@ -26,13 +26,13 @@
 
 
 
-    // ---------------------------------------------------------- Constructors
+    
 
     public IntegerLocaleConverterTestCase(final String name) {
         super(name);
     }
 
-    // -------------------------------------------------- Overall Test Methods
+    
 
     /**
      * Set up instance variables required by this test case.
@@ -56,7 +56,7 @@
     }
 
 
-    // ------------------------------------------------------------------------
+    
 
     /**
      * Test Converter(defaultValue, locale, pattern, localizedPattern) constructor
diff --git a/src/test/java/org/apache/commons/beanutils2/locale/converters/LongLocaleConverterTestCase.java b/src/test/java/org/apache/commons/beanutils2/locale/converters/LongLocaleConverterTestCase.java
index f21e61a..cad28de 100644
--- a/src/test/java/org/apache/commons/beanutils2/locale/converters/LongLocaleConverterTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/locale/converters/LongLocaleConverterTestCase.java
@@ -26,13 +26,13 @@
 
 
 
-    // ---------------------------------------------------------- Constructors
+    
 
     public LongLocaleConverterTestCase(final String name) {
         super(name);
     }
 
-    // -------------------------------------------------- Overall Test Methods
+    
 
     /**
      * Set up instance variables required by this test case.
@@ -56,7 +56,7 @@
     }
 
 
-    // ------------------------------------------------------------------------
+    
 
     /**
      * Test Converter(defaultValue, locale, pattern, localizedPattern) constructor
diff --git a/src/test/java/org/apache/commons/beanutils2/locale/converters/ShortLocaleConverterTestCase.java b/src/test/java/org/apache/commons/beanutils2/locale/converters/ShortLocaleConverterTestCase.java
index cdce445..45efbb5 100644
--- a/src/test/java/org/apache/commons/beanutils2/locale/converters/ShortLocaleConverterTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/locale/converters/ShortLocaleConverterTestCase.java
@@ -26,13 +26,13 @@
 
 
 
-    // ---------------------------------------------------------- Constructors
+    
 
     public ShortLocaleConverterTestCase(final String name) {
         super(name);
     }
 
-    // -------------------------------------------------- Overall Test Methods
+    
 
     /**
      * Set up instance variables required by this test case.
@@ -56,7 +56,7 @@
     }
 
 
-    // ------------------------------------------------------------------------
+    
 
     /**
      * Test Converter(defaultValue, locale, pattern, localizedPattern) constructor
diff --git a/src/test/java/org/apache/commons/beanutils2/memoryleaktests/MemoryLeakTestCase.java b/src/test/java/org/apache/commons/beanutils2/memoryleaktests/MemoryLeakTestCase.java
index c011c2a..9bde71d 100644
--- a/src/test/java/org/apache/commons/beanutils2/memoryleaktests/MemoryLeakTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/memoryleaktests/MemoryLeakTestCase.java
@@ -66,7 +66,7 @@
         ClassLoader loader = newClassLoader();
         Class<?> beanClass    = loader.loadClass(className);
         Object bean        = beanClass.newInstance();
-        // -----------------------------------------------------------------------------
+        
 
         final WeakReference<ClassLoader> someRef = new WeakReference<>(loader);
 
@@ -113,7 +113,7 @@
         ClassLoader loader = newClassLoader();
         Class<?> beanClass    = loader.loadClass(className);
         Object bean        = beanClass.newInstance();
-        // -----------------------------------------------------------------------------
+        
 
         final WeakReference<ClassLoader> someRef = new WeakReference<>(loader);
 
@@ -165,7 +165,7 @@
         final ClassLoader loader = newClassLoader();
         final Class<?> beanClass    = loader.loadClass(className);
         final Object bean        = beanClass.newInstance();
-        // -----------------------------------------------------------------------------
+        
 
         // Sanity checks only
         assertNotNull("ClassLoader is null", loader);
@@ -211,7 +211,7 @@
         ClassLoader loader = newClassLoader();
         Class<?> beanClass    = loader.loadClass(className);
         Object bean        = beanClass.newInstance();
-        // -----------------------------------------------------------------------------
+        
 
         // Sanity checks only
         assertNotNull("ClassLoader is null", loader);
@@ -263,7 +263,7 @@
         ClassLoader loader = newClassLoader();
         Class<?> beanClass    = loader.loadClass(className);
         Object bean        = beanClass.newInstance();
-        // -----------------------------------------------------------------------------
+        
 
         final WeakReference<ClassLoader> someRef = new WeakReference<>(loader);
 
@@ -311,7 +311,7 @@
         Class<?> beanClass    = loader.loadClass(className);
         Object bean        = beanClass.newInstance();
         WrapDynaBean wrapDynaBean = new WrapDynaBean(bean);
-        // -----------------------------------------------------------------------------
+        
 
         final WeakReference<ClassLoader> someRef = new WeakReference<>(loader);
 
@@ -363,7 +363,7 @@
         ClassLoader loader = newClassLoader();
         Class<?> beanClass    = loader.loadClass(className);
         Object bean        = beanClass.newInstance();
-        // -----------------------------------------------------------------------------
+        
 
         final WeakReference<ClassLoader> someRef = new WeakReference<>(loader);
 
@@ -411,7 +411,7 @@
         ClassLoader loader = newClassLoader();
         Class<?> beanClass    = loader.loadClass(className);
         Object bean        = beanClass.newInstance();
-        // -----------------------------------------------------------------------------
+        
 
         final WeakReference<ClassLoader> someRef = new WeakReference<>(loader);
 
diff --git a/src/test/java/org/apache/commons/beanutils2/priv/PackageBean.java b/src/test/java/org/apache/commons/beanutils2/priv/PackageBean.java
index 162e594..05d506f 100644
--- a/src/test/java/org/apache/commons/beanutils2/priv/PackageBean.java
+++ b/src/test/java/org/apache/commons/beanutils2/priv/PackageBean.java
@@ -32,7 +32,7 @@
 class PackageBean {
 
 
-    // ----------------------------------------------------------- Constructors
+    
 
 
     /**
@@ -46,7 +46,7 @@
     }
 
 
-    // ------------------------------------------------------------- Properties
+    
 
 
     /**
diff --git a/src/test/java/org/apache/commons/beanutils2/priv/PrivateBean.java b/src/test/java/org/apache/commons/beanutils2/priv/PrivateBean.java
index 56314ed..2d4203e 100644
--- a/src/test/java/org/apache/commons/beanutils2/priv/PrivateBean.java
+++ b/src/test/java/org/apache/commons/beanutils2/priv/PrivateBean.java
@@ -33,7 +33,7 @@
 class PrivateBean implements PrivateDirect {
 
 
-    // ----------------------------------------------------------- Constructors
+    
 
 
     /**
@@ -47,7 +47,7 @@
     }
 
 
-    // ------------------------------------------------------------- Properties
+    
 
 
     /**
diff --git a/src/test/java/org/apache/commons/beanutils2/priv/PrivateBeanSubclass.java b/src/test/java/org/apache/commons/beanutils2/priv/PrivateBeanSubclass.java
index a38340d..da95cb1 100644
--- a/src/test/java/org/apache/commons/beanutils2/priv/PrivateBeanSubclass.java
+++ b/src/test/java/org/apache/commons/beanutils2/priv/PrivateBeanSubclass.java
@@ -28,7 +28,7 @@
 class PrivateBeanSubclass extends PrivateBean {
 
 
-    // ----------------------------------------------------------- Constructors
+    
 
 
     /**
@@ -41,7 +41,7 @@
     }
 
 
-    // ------------------------------------------------------------- Properties
+    
 
 
     /**
diff --git a/src/test/java/org/apache/commons/beanutils2/priv/PrivateDirect.java b/src/test/java/org/apache/commons/beanutils2/priv/PrivateDirect.java
index 8f8f252..3a5bba4 100644
--- a/src/test/java/org/apache/commons/beanutils2/priv/PrivateDirect.java
+++ b/src/test/java/org/apache/commons/beanutils2/priv/PrivateDirect.java
@@ -27,7 +27,7 @@
 public interface PrivateDirect extends PrivateIndirect {
 
 
-    // ------------------------------------------------------------- Properties
+    
 
 
     /**
diff --git a/src/test/java/org/apache/commons/beanutils2/priv/PrivateIndirect.java b/src/test/java/org/apache/commons/beanutils2/priv/PrivateIndirect.java
index 84a17fb..f665e1d 100644
--- a/src/test/java/org/apache/commons/beanutils2/priv/PrivateIndirect.java
+++ b/src/test/java/org/apache/commons/beanutils2/priv/PrivateIndirect.java
@@ -27,7 +27,7 @@
 public interface PrivateIndirect {
 
 
-    // ------------------------------------------------------------- Properties
+    
 
 
     /**
diff --git a/src/test/java/org/apache/commons/beanutils2/priv/PublicSubBean.java b/src/test/java/org/apache/commons/beanutils2/priv/PublicSubBean.java
index 093a19e..c7b3605 100644
--- a/src/test/java/org/apache/commons/beanutils2/priv/PublicSubBean.java
+++ b/src/test/java/org/apache/commons/beanutils2/priv/PublicSubBean.java
@@ -32,7 +32,7 @@
 public class PublicSubBean extends PackageBean {
 
 
-    // ----------------------------------------------------------- Constructors
+    
 
 
     /**
@@ -46,7 +46,7 @@
     }
 
 
-    // ------------------------------------------------------------- Properties
+    
 
 
     /**
