diff --git a/dbws/org.eclipse.persistence.dbws/src/it/java/dbws/testing/xrdynamicentity/Incompatible.java b/dbws/org.eclipse.persistence.dbws/src/it/java/dbws/testing/xrdynamicentity/Incompatible.java
index fa4a67d..300cb68 100644
--- a/dbws/org.eclipse.persistence.dbws/src/it/java/dbws/testing/xrdynamicentity/Incompatible.java
+++ b/dbws/org.eclipse.persistence.dbws/src/it/java/dbws/testing/xrdynamicentity/Incompatible.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -15,7 +15,7 @@
 package dbws.testing.xrdynamicentity;
 
 /**
- * Test class - when created by a {@link XRDynamicClassLoader}, should throw {@link IllegalArgumentException}
+ * Test class - when created by a {@link org.eclipse.persistence.internal.xr.XRDynamicClassLoader}, should throw {@link IllegalArgumentException}
  * @author mnorman
  *
  */
diff --git a/dbws/org.eclipse.persistence.dbws/src/main/java/org/eclipse/persistence/jpa/rs/util/PreLoginMappingAdapter.java b/dbws/org.eclipse.persistence.dbws/src/main/java/org/eclipse/persistence/jpa/rs/util/PreLoginMappingAdapter.java
index 51bbf5e..363a35a 100644
--- a/dbws/org.eclipse.persistence.dbws/src/main/java/org/eclipse/persistence/jpa/rs/util/PreLoginMappingAdapter.java
+++ b/dbws/org.eclipse.persistence.dbws/src/main/java/org/eclipse/persistence/jpa/rs/util/PreLoginMappingAdapter.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2011, 2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2011, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -253,7 +253,7 @@
      * the newly created XMLInverseMapping in jaxbDescriptor
      * @param jaxbDescriptor
      * @param mapping
-     * @param mappedBy
+     * @param jpaMapping
      */
     private static void convertMappingToXMLInverseReferenceMapping(ClassDescriptor jaxbDescriptor, DatabaseMapping mapping, ForeignReferenceMapping jpaMapping) {
         if ((mapping != null) && (jaxbDescriptor != null)) {
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/aggregate/Address1.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/aggregate/Address1.java
index ac84780..72d22a5 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/aggregate/Address1.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/aggregate/Address1.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -75,7 +75,6 @@
 
     /**
      * This method was created in VisualAge.
-     * @return java.lang.String
      */
     public void setBuildingNumber(int thisBuildingNumber) {
         buildingNumber = thisBuildingNumber;
@@ -83,7 +82,6 @@
 
     /**
      * This method was created in VisualAge.
-     * @return java.lang.String
      */
     public void setCity(String thisCity) {
         city = thisCity;
@@ -91,7 +89,6 @@
 
     /**
      * This method was created in VisualAge.
-     * @return java.lang.String
      */
     public void setCountry(String thisCountry) {
         country = thisCountry;
@@ -99,7 +96,6 @@
 
     /**
      * This method was created in VisualAge.
-     * @return java.lang.String
      */
     public void setPostalCode(String thisPostalCode) {
         postalCode = thisPostalCode;
@@ -107,7 +103,6 @@
 
     /**
      * This method was created in VisualAge.
-     * @return java.lang.String
      */
     public void setStreetName(String thisStreetName) {
         streetName = thisStreetName;
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/aggregate/Dependant.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/aggregate/Dependant.java
index 9ba3341..8bedddf 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/aggregate/Dependant.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/aggregate/Dependant.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -105,7 +105,7 @@
     /**
      * Insert the method's description here.
      * Creation date: (04/12/2000 9:51:54 AM)
-     * @param newName java.lang.String
+     * @param firstName java.lang.String
      */
     public void setFirstName(java.lang.String firstName) {
         this.firstName = firstName;
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/aggregate/GolfClub.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/aggregate/GolfClub.java
index 8a4cc62..54a74f4 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/aggregate/GolfClub.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/aggregate/GolfClub.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -19,9 +19,9 @@
 
 /**
  *  The following is the object structure of this model:
- *  GolfClub - AggregateObject -> GolfClubShaft
- *  GolfClub - One-To-One -> Manufacturer
- *  GolfClubShaft - One-To-One -> Manufacturer
+ *  GolfClub - AggregateObject -{@literal >} GolfClubShaft
+ *  GolfClub - One-To-One -{@literal >} Manufacturer
+ *  GolfClubShaft - One-To-One -{@literal >} Manufacturer
  *  This structure is special because both GolfClub and GolfClubShaft have an attribute
  *  called manufacturer.  This is useful for joining tests.
  */
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/aggregate/GolfClubShaft.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/aggregate/GolfClubShaft.java
index 59902d2..781b301 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/aggregate/GolfClubShaft.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/aggregate/GolfClubShaft.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -17,9 +17,9 @@
 
 /**
  *  The following is the object structure of this model:
- *  GolfClub - AggregateObject -> GolfClubShaft
- *  GolfClub - One-To-One -> Manufacturer
- *  GolfClubShaft - One-To-One -> Manufacturer
+ *  GolfClub - AggregateObject -{@literal >} GolfClubShaft
+ *  GolfClub - One-To-One -{@literal >} Manufacturer
+ *  GolfClubShaft - One-To-One -{@literal >} Manufacturer
  *  This structure is special because both GolfClub and GolfClubShaft have an attribute
  *  called manufacturer.  This is useful for joining tests.
  */
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/aggregate/Manufacturer.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/aggregate/Manufacturer.java
index 7b1b4de..321dadd 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/aggregate/Manufacturer.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/aggregate/Manufacturer.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -19,9 +19,9 @@
 
 /**
  *  The following is the object structure of this model:
- *  GolfClub - AggregateObject -> GolfClubShaft
- *  GolfClub - One-To-One -> Manufacturer
- *  GolfClubShaft - One-To-One -> Manufacturer
+ *  GolfClub - AggregateObject -{@literal >} GolfClubShaft
+ *  GolfClub - One-To-One -{@literal >} Manufacturer
+ *  GolfClubShaft - One-To-One -{@literal >} Manufacturer
  *  This structure is special because both GolfClub and GolfClubShaft have an attribute
  *  called manufacturer.  This is useful for joining tests.
  */
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/employee/domain/Child.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/employee/domain/Child.java
index c750b99..48776da 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/employee/domain/Child.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/employee/domain/Child.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -21,13 +21,13 @@
 
 public class Child implements Serializable{
     public BigDecimal id;
-    /** Direct-to-field mapping, String -> VARCHAR. */
+    /** Direct-to-field mapping, String -{@literal >} VARCHAR. */
     public String firstName;
 
-    /** Direct-to-field mapping, String -> VARCHAR. */
+    /** Direct-to-field mapping, String -{@literal >} VARCHAR. */
     public String lastName;
 
-    /** Object-type mapping, maps "Male" -> "M", "Female" -> "F". */
+    /** Object-type mapping, maps "Male" -{@literal >} "M", "Female" -{@literal >} "F". */
     public String gender;
 
     /** Direct-to-field mapping */
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/employee/domain/Employee.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/employee/domain/Employee.java
index 9413eca..319b27a 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/employee/domain/Employee.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/employee/domain/Employee.java
@@ -38,19 +38,19 @@
 public class Employee implements org.eclipse.persistence.testing.models.employee.interfaces.Employee, Serializable, ChangeTracker {
     // implements ChangeTracker for testing
 
-    /** Primary key, mapped as a direct-to-field, BigDecimal -> NUMBER, that makes use of sequence numbers to generate the id. */
+    /** Primary key, mapped as a direct-to-field, BigDecimal -{@literal >} NUMBER, that makes use of sequence numbers to generate the id. */
     public BigDecimal id;
 
-    /** Direct-to-field mapping, String -> VARCHAR. */
+    /** Direct-to-field mapping, String -{@literal >} VARCHAR. */
     public String firstName;
 
-    /** Direct-to-field mapping, String -> VARCHAR. */
+    /** Direct-to-field mapping, String -{@literal >} VARCHAR. */
     public String lastName;
 
-    /** Object-type mapping, maps "Male" -> "M", "Female" -> "F". */
+    /** Object-type mapping, maps "Male" -{@literal >} "M", "Female" -{@literal >} "F". */
     public String gender;
 
-    /** Primary key, mapped as a direct-to-field, BigDecimal -> NUMBER. */
+    /** Primary key, mapped as a direct-to-field, BigDecimal -{@literal >} NUMBER. */
     public BigDecimal addressId;
 
     /** Aggregate-object mapping, stores the object in the employee's table. */
@@ -74,11 +74,11 @@
     /** Direct-collection mapping, employee stores its collection of plain Strings in an intermediate table. */
     public ValueHolderInterface responsibilitiesList;
 
-    /** Transformation mapping, a two(2) element array holding the employee's normal working hours (START_TIME & END_TIME),
+    /** Transformation mapping, a two(2) element array holding the employee's normal working hours (START_TIME &amp; END_TIME),
         this is stored into two different fields in the employee table. */
     public Time[] normalHours;
 
-    /** Direct-to-field mapping, int -> NUMBER, salary of the employee in dollars. */
+    /** Direct-to-field mapping, int -{@literal >} NUMBER, salary of the employee in dollars. */
     public int salary;
 
     /** One-to-many mapping, employee references its collection of children arranged by age.
@@ -523,7 +523,7 @@
     }
 
     /**
-     * Print the first & last name
+     * Print the first &amp; last name
      */
     public String toString() {
         StringWriter writer = new StringWriter();
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/employee/domain/EmploymentPeriod.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/employee/domain/EmploymentPeriod.java
index 501df57..00329cc 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/employee/domain/EmploymentPeriod.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/employee/domain/EmploymentPeriod.java
@@ -102,7 +102,7 @@
     }
 
     /**
-     * Print the start & end date
+     * Print the start &amp; end date
      */
     public String toString() {
         StringWriter writer = new StringWriter();
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/employee/domain/LargeProject.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/employee/domain/LargeProject.java
index d12c316..3c55848 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/employee/domain/LargeProject.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/employee/domain/LargeProject.java
@@ -20,7 +20,7 @@
 /**
  * <b>Purpose</b>: Larger scale projects within the Employee Demo
  * <p><b>Description</b>: LargeProject is a concrete subclass of Project. It is instantiated for Projects with type = 'L'. The additional
- * information (budget, & milestoneVersion) are mapped from the LPROJECT table.
+ * information (budget, &amp; milestoneVersion) are mapped from the LPROJECT table.
  * @see Project
  */
 public class LargeProject extends Project implements org.eclipse.persistence.testing.models.employee.interfaces.LargeProject {
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/employee/domain/Project.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/employee/domain/Project.java
index ef198a5..0ff41de 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/employee/domain/Project.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/employee/domain/Project.java
@@ -22,7 +22,7 @@
 import org.eclipse.persistence.descriptors.changetracking.*;
 
 /**
- * <b>Purpose</b>: Abstract superclass for Large & Small projects in Employee Demo
+ * <b>Purpose</b>: Abstract superclass for Large &amp; Small projects in Employee Demo
  * <p><b>Description</b>:     Project is an example of an abstract superclass. It demonstrates how class inheritance can be mapped to database tables.
  * It's subclasses are concrete and may or may not add columns through additional tables. The PROJ_TYPE field in the
  * database table indicates which subclass to instantiate. Projects are involved in a M:M relationship with employees.
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/employee/interfaces/Employee.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/employee/interfaces/Employee.java
index df789b3..794b32e 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/employee/interfaces/Employee.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/employee/interfaces/Employee.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -21,7 +21,7 @@
 import org.eclipse.persistence.testing.models.employee.domain.*;
 
 /**
- * <p><b>Purpose</b>: Represent a employee of a fictional organization for eaxample & testing purposes.
+ * <p><b>Purpose</b>: Represent a employee of a fictional organization for eaxample &amp; testing purposes.
  * <p><b>Description</b>: An Employee is a root object in the EmployeeDemo. It maintains relationships to all
  * of the other objects in the system.
  */
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/employee/interfaces/LargeProject.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/employee/interfaces/LargeProject.java
index 87bdbe4..45a34a5 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/employee/interfaces/LargeProject.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/employee/interfaces/LargeProject.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -19,7 +19,7 @@
 /**
  * <b>Purpose</b>: Larger scale projects within the Employee Demo
  * <p><b>Description</b>: LargeProject is a concrete subclass of Project. It is instantiated for Projects with type = 'L'. The additional
- * information (budget, & milestoneVersion) are mapped from the LPROJECT table.
+ * information (budget, &amp; milestoneVersion) are mapped from the LPROJECT table.
  */
 public interface LargeProject extends Project {
     double getBudget();
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/employee/interfaces/Project.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/employee/interfaces/Project.java
index 1e8a233..a2093fa 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/employee/interfaces/Project.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/employee/interfaces/Project.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -18,7 +18,7 @@
 import java.io.Serializable;
 
 /**
- * <b>Purpose</b>:         Abstract superclass for Large & Small projects in Employee Demo
+ * <b>Purpose</b>:         Abstract superclass for Large &amp; Small projects in Employee Demo
  *    <p><b>Description</b>:     Project is an example of an abstract superclass. It demonstrates how class inheritance can be mapped to database tables.
  * It's subclasses are concrete and may or may not add columns through additional tables. The PROJ_TYPE field in the
  * database table indicates which subclass to instantiate. Projects are involved in a M:M relationship with employees.
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/forceupdate/AddressTLIC.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/forceupdate/AddressTLIC.java
index bd04e29..4e26b52 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/forceupdate/AddressTLIC.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/forceupdate/AddressTLIC.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -21,7 +21,7 @@
 /**
  * <p><b>Purpose</b>: Represents the mailing address on an Employee
  * <p><b>Description</b>: Held in a private 1:1 relationship from Employee
- * @see Employee
+ * @see EmployeeTLIC
  */
 public class AddressTLIC implements Serializable {
     public BigDecimal id;
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/forceupdate/AddressTLIO.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/forceupdate/AddressTLIO.java
index 3e1226c..3ad68db 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/forceupdate/AddressTLIO.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/forceupdate/AddressTLIO.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -21,7 +21,7 @@
 /**
  * <p><b>Purpose</b>: Represents the mailing address on an Employee
  * <p><b>Description</b>: Held in a private 1:1 relationship from Employee
- * @see Employee
+ * @see EmployeeTLIO
  */
 public class AddressTLIO implements Serializable {
     public BigDecimal id;
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/forceupdate/AddressVLIC.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/forceupdate/AddressVLIC.java
index 40b3c90..c2e9739 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/forceupdate/AddressVLIC.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/forceupdate/AddressVLIC.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -21,7 +21,7 @@
 /**
  * <p><b>Purpose</b>: Represents the mailing address on an Employee
  * <p><b>Description</b>: Held in a private 1:1 relationship from Employee
- * @see Employee
+ * @see EmployeeVLIC
  */
 public class AddressVLIC implements Serializable {
     public BigDecimal id;
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/forceupdate/AddressVLIO.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/forceupdate/AddressVLIO.java
index 7063d07..238619f 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/forceupdate/AddressVLIO.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/forceupdate/AddressVLIO.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -21,7 +21,7 @@
 /**
  * <p><b>Purpose</b>: Represents the mailing address on an Employee
  * <p><b>Description</b>: Held in a private 1:1 relationship from Employee
- * @see Employee
+ * @see EmployeeVLIO
  */
 public class AddressVLIO implements Serializable {
     public BigDecimal id;
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/forceupdate/EmployeeTLIC.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/forceupdate/EmployeeTLIC.java
index 0b82c15..52b9d36 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/forceupdate/EmployeeTLIC.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/forceupdate/EmployeeTLIC.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -20,16 +20,16 @@
 import org.eclipse.persistence.indirection.*;
 
 public class EmployeeTLIC implements Serializable {
-    /** Primary key, maped as a direct-to-field, BigDecimal -> NUMBER, that makes use of sequence numbers to generate the id. */
+    /** Primary key, maped as a direct-to-field, BigDecimal -{@literal >} NUMBER, that makes use of sequence numbers to generate the id. */
     public BigDecimal id;
 
-    /** Direct-to-field mapping, String -> VARCHAR. */
+    /** Direct-to-field mapping, String -{@literal >} VARCHAR. */
     public String firstName;
 
-    /** Direct-to-field mapping, String -> VARCHAR. */
+    /** Direct-to-field mapping, String -{@literal >} VARCHAR. */
     public String lastName;
 
-    /** Object-type mapping, maps "Male" -> "M", "Female" -> "F". */
+    /** Object-type mapping, maps "Male" -{@literal >} "M", "Female" -{@literal >} "F". */
     public String gender;
 
     /** One-to-one mapping, employee references its address through a foreign key. */
@@ -38,7 +38,7 @@
     /** One-to-many mapping, employee references its collection of phone numbers using a foreign key in the phone's table. */
     public ValueHolderInterface phoneNumbers;
 
-    /** Direct-to-field mapping, int -> NUMBER, salary of the employee in dollars. */
+    /** Direct-to-field mapping, int -{@literal >} NUMBER, salary of the employee in dollars. */
     public int salary;
 
     public EmployeeTLIC() {
@@ -122,7 +122,7 @@
     }
 
     /**
-     * Print the first & last name
+     * Print the first &amp; last name
      */
     public String toString() {
         StringWriter writer = new StringWriter();
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/forceupdate/EmployeeTLIO.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/forceupdate/EmployeeTLIO.java
index c4ce68d..b4d35d8 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/forceupdate/EmployeeTLIO.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/forceupdate/EmployeeTLIO.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -20,16 +20,16 @@
 import org.eclipse.persistence.indirection.*;
 
 public class EmployeeTLIO implements Serializable {
-    /** Primary key, maped as a direct-to-field, BigDecimal -> NUMBER, that makes use of sequence numbers to generate the id. */
+    /** Primary key, maped as a direct-to-field, BigDecimal -{@literal >} NUMBER, that makes use of sequence numbers to generate the id. */
     public BigDecimal id;
 
-    /** Direct-to-field mapping, String -> VARCHAR. */
+    /** Direct-to-field mapping, String -{@literal >} VARCHAR. */
     public String firstName;
 
-    /** Direct-to-field mapping, String -> VARCHAR. */
+    /** Direct-to-field mapping, String -{@literal >} VARCHAR. */
     public String lastName;
 
-    /** Object-type mapping, maps "Male" -> "M", "Female" -> "F". */
+    /** Object-type mapping, maps "Male" -{@literal >} "M", "Female" -{@literal >} "F". */
     public String gender;
 
     /** One-to-one mapping, employee references its address through a foreign key. */
@@ -38,7 +38,7 @@
     /** One-to-many mapping, employee references its collection of phone numbers using a foreign key in the phone's table. */
     public ValueHolderInterface phoneNumbers;
 
-    /** Direct-to-field mapping, int -> NUMBER, salary of the employee in dollars. */
+    /** Direct-to-field mapping, int -{@literal >} NUMBER, salary of the employee in dollars. */
     public int salary;
     public java.sql.Timestamp version;
 
@@ -123,7 +123,7 @@
     }
 
     /**
-     * Print the first & last name
+     * Print the first &amp; last name
      */
     public String toString() {
         StringWriter writer = new StringWriter();
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/forceupdate/EmployeeVLIC.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/forceupdate/EmployeeVLIC.java
index 327c4d5..d845ca8 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/forceupdate/EmployeeVLIC.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/forceupdate/EmployeeVLIC.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -20,16 +20,16 @@
 import org.eclipse.persistence.indirection.*;
 
 public class EmployeeVLIC implements Serializable {
-    /** Primary key, maped as a direct-to-field, BigDecimal -> NUMBER, that makes use of sequence numbers to generate the id. */
+    /** Primary key, maped as a direct-to-field, BigDecimal -{@literal >} NUMBER, that makes use of sequence numbers to generate the id. */
     public BigDecimal id;
 
-    /** Direct-to-field mapping, String -> VARCHAR. */
+    /** Direct-to-field mapping, String -{@literal >} VARCHAR. */
     public String firstName;
 
-    /** Direct-to-field mapping, String -> VARCHAR. */
+    /** Direct-to-field mapping, String -{@literal >} VARCHAR. */
     public String lastName;
 
-    /** Object-type mapping, maps "Male" -> "M", "Female" -> "F". */
+    /** Object-type mapping, maps "Male" -{@literal >} "M", "Female" -{@literal >} "F". */
     public String gender;
 
     /** One-to-one mapping, employee references its address through a foreign key. */
@@ -38,7 +38,7 @@
     /** One-to-many mapping, employee references its collection of phone numbers using a foreign key in the phone's table. */
     public ValueHolderInterface phoneNumbers;
 
-    /** Direct-to-field mapping, int -> NUMBER, salary of the employee in dollars. */
+    /** Direct-to-field mapping, int -{@literal >} NUMBER, salary of the employee in dollars. */
     public int salary;
 
     public EmployeeVLIC() {
@@ -122,7 +122,7 @@
     }
 
     /**
-     * Print the first & last name
+     * Print the first &amp; last name
      */
     public String toString() {
         StringWriter writer = new StringWriter();
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/forceupdate/EmployeeVLIO.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/forceupdate/EmployeeVLIO.java
index a994c2b..a7470ac 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/forceupdate/EmployeeVLIO.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/forceupdate/EmployeeVLIO.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -20,16 +20,16 @@
 import org.eclipse.persistence.indirection.*;
 
 public class EmployeeVLIO implements Serializable {
-    /** Primary key, maped as a direct-to-field, BigDecimal -> NUMBER, that makes use of sequence numbers to generate the id. */
+    /** Primary key, maped as a direct-to-field, BigDecimal -{@literal >} NUMBER, that makes use of sequence numbers to generate the id. */
     public BigDecimal id;
 
-    /** Direct-to-field mapping, String -> VARCHAR. */
+    /** Direct-to-field mapping, String -{@literal >} VARCHAR. */
     public String firstName;
 
-    /** Direct-to-field mapping, String -> VARCHAR. */
+    /** Direct-to-field mapping, String -{@literal >} VARCHAR. */
     public String lastName;
 
-    /** Object-type mapping, maps "Male" -> "M", "Female" -> "F". */
+    /** Object-type mapping, maps "Male" -{@literal >} "M", "Female" -{@literal >} "F". */
     public String gender;
 
     /** One-to-one mapping, employee references its address through a foreign key. */
@@ -38,7 +38,7 @@
     /** One-to-many mapping, employee references its collection of phone numbers using a foreign key in the phone's table. */
     public ValueHolderInterface phoneNumbers;
 
-    /** Direct-to-field mapping, int -> NUMBER, salary of the employee in dollars. */
+    /** Direct-to-field mapping, int -{@literal >} NUMBER, salary of the employee in dollars. */
     public int salary;
     public java.math.BigDecimal version;
 
@@ -123,7 +123,7 @@
     }
 
     /**
-     * Print the first & last name
+     * Print the first &amp; last name
      */
     public String toString() {
         StringWriter writer = new StringWriter();
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/inheritance/BudgettedProject.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/inheritance/BudgettedProject.java
index 06f845a..16903ae 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/inheritance/BudgettedProject.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/inheritance/BudgettedProject.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -19,7 +19,7 @@
 /**
  * <b>Purpose</b>: Larger scale projects within the Employee Demo
  * <p><b>Description</b>:     LargeProject is a concrete subclass of Project. It is instantiated for Projects with type = 'L'. The additional
- *                                information (budget, & milestoneVersion) are mapped from the LPROJECT table.
+ *                                information (budget, &amp; milestoneVersion) are mapped from the LPROJECT table.
  *    @see Project
  */
 /**
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/inheritance/Person.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/inheritance/Person.java
index c8f8244..9afc102 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/inheritance/Person.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/inheritance/Person.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -28,6 +28,7 @@
  * <li> class name indicator usage
  * <li> concreate root class
  * <li> big int as primary key
+ * </ul>
  */
 public class Person implements Serializable {
     public Number id;
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/inheritance/STI_Employee.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/inheritance/STI_Employee.java
index ef3eb52..cfa5ecc 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/inheritance/STI_Employee.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/inheritance/STI_Employee.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -27,13 +27,13 @@
  * STI_Employee is a simplified version of Employee.
  */
 public class STI_Employee implements Serializable {
-    /** Primary key, maped as a direct-to-field, BigDecimal -> NUMBER, that makes use of sequence numbers to generate the id. */
+    /** Primary key, maped as a direct-to-field, BigDecimal -{@literal >} NUMBER, that makes use of sequence numbers to generate the id. */
     public BigDecimal id;
 
-    /** Direct-to-field mapping, String -> VARCHAR. */
+    /** Direct-to-field mapping, String -{@literal >} VARCHAR. */
     public String firstName;
 
-    /** Direct-to-field mapping, String -> VARCHAR. */
+    /** Direct-to-field mapping, String -{@literal >} VARCHAR. */
     public String lastName;
 
     /** One-to-one mapping (same class relationship), employee references its manager through a foreign key. */
@@ -159,7 +159,7 @@
     }
 
     /**
-     * Print the first & last name
+     * Print the first &amp; last name
      */
     public String toString() {
         StringWriter writer = new StringWriter();
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/insurance/InsuranceProject.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/insurance/InsuranceProject.java
index b3d2a90..c2f3b18 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/insurance/InsuranceProject.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/insurance/InsuranceProject.java
@@ -22,7 +22,7 @@
 /**
  * This class was generated by the TopLink project class generator.
  * It stores the meta-data (descriptors) that define the TopLink mappings.
- * @see org.eclipse.persistence.tools.workbench.ProjectClassGenerator
+ * @see org.eclipse.persistence.sessions.factories.ProjectClassGenerator
  */
 public class InsuranceProject extends org.eclipse.persistence.sessions.Project {
     public InsuranceProject() {
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/mapping/Peripheral.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/mapping/Peripheral.java
index 12b1a4d..219b0b64 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/mapping/Peripheral.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/mapping/Peripheral.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -21,7 +21,7 @@
 
 /**
  * Added for EL bug 375463
- * (ObjectTypeMapping Boolean->Char/Char->Boolean and additionalJoinCriteria)
+ * (ObjectTypeMapping Boolean-{@literal >}Char/Char-{@literal >}Boolean and additionalJoinCriteria)
  * See the addToDescriptor method
  */
 public class Peripheral {
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/multipletable/BusinessProject.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/multipletable/BusinessProject.java
index ada37c7..11b46f4 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/multipletable/BusinessProject.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/multipletable/BusinessProject.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -20,13 +20,12 @@
 import org.eclipse.persistence.tools.schemaframework.*;
 
 /**
- * <b>Purpose</b>: Abstract superclass for Large & Small projects in Employee Demo
+ * <b>Purpose</b>: Abstract superclass for Large &amp; Small projects in Employee Demo
  * <p><b>Description</b>: Project is an example of an abstract superclass. It demonstrates how class inheritance can be mapped to database tables.
  *                                It's subclasses are concrete and may or may not add columns through additional tables. The PROJ_TYPE field in the
  *                                database table indicates which subclass to instantiate. Projects are involved in a M:M relationship with employees.
  *                                The Employee classs maintains the definition of the relation table
- * @see LargeProject
- * @see SmallProject
+ * @see LargeBusinessProject
  */
 public abstract class BusinessProject implements Serializable {
     public String name;
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/multipletable/LargeBusinessProject.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/multipletable/LargeBusinessProject.java
index b11db30..174a3f2 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/multipletable/LargeBusinessProject.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/multipletable/LargeBusinessProject.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -22,8 +22,8 @@
 /**
  * <b>Purpose</b>: Larger scale projects within the Employee Demo
  * <p><b>Description</b>: LargeProject is a concrete subclass of Project. It is instantiated for Projects with type = 'L'. The additional
- * information (budget, & milestoneVersion) are mapped from the LPROJECT table.
- * @see Project
+ * information (budget, &amp; milestoneVersion) are mapped from the LPROJECT table.
+ * @see BusinessProject
  */
 public class LargeBusinessProject extends BusinessProject {
     public Budget budget;
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/onetoonejointable/Child.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/onetoonejointable/Child.java
index 7e35b28..d244de8 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/onetoonejointable/Child.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/onetoonejointable/Child.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -21,13 +21,13 @@
 
 public class Child implements Serializable{
     public BigDecimal id;
-    /** Direct-to-field mapping, String -> VARCHAR. */
+    /** Direct-to-field mapping, String -{@literal >} VARCHAR. */
     public String firstName;
 
-    /** Direct-to-field mapping, String -> VARCHAR. */
+    /** Direct-to-field mapping, String -{@literal >} VARCHAR. */
     public String lastName;
 
-    /** Object-type mapping, maps "Male" -> "M", "Female" -> "F". */
+    /** Object-type mapping, maps "Male" -{@literal >} "M", "Female" -{@literal >} "F". */
     public String gender;
 
     /** Direct-to-field mapping */
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/onetoonejointable/Employee.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/onetoonejointable/Employee.java
index fbc7ff8..4c38574 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/onetoonejointable/Employee.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/onetoonejointable/Employee.java
@@ -34,16 +34,16 @@
 public class Employee implements Serializable, ChangeTracker {
     // implements ChangeTracker for testing
 
-    /** Primary key, mapped as a direct-to-field, BigDecimal -> NUMBER, that makes use of sequence numbers to generate the id. */
+    /** Primary key, mapped as a direct-to-field, BigDecimal -{@literal >} NUMBER, that makes use of sequence numbers to generate the id. */
     public BigDecimal id;
 
-    /** Direct-to-field mapping, String -> VARCHAR. */
+    /** Direct-to-field mapping, String -{@literal >} VARCHAR. */
     public String firstName;
 
-    /** Direct-to-field mapping, String -> VARCHAR. */
+    /** Direct-to-field mapping, String -{@literal >} VARCHAR. */
     public String lastName;
 
-    /** Object-type mapping, maps "Male" -> "M", "Female" -> "F". */
+    /** Object-type mapping, maps "Male" -{@literal >} "M", "Female" -{@literal >} "F". */
     public String gender;
 
     /** One-to-one mapping, employee references its address through a foreign key. */
@@ -60,7 +60,7 @@
     /** Direct-collection mapping, employee stores its collection of plain Strings in an intermediate table. */
     public List<String> responsibilitiesList;
 
-    /** Direct-to-field mapping, int -> NUMBER, salary of the employee in dollars. */
+    /** Direct-to-field mapping, int -{@literal >} NUMBER, salary of the employee in dollars. */
     public int salary;
 
     /** One-to-many mapping, employee references its collection of children arranged by age.
@@ -316,7 +316,7 @@
     }
 
     /**
-     * Print the first & last name
+     * Print the first &amp; last name
      */
     public String toString() {
         StringWriter writer = new StringWriter();
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/onetoonejointable/LargeProject.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/onetoonejointable/LargeProject.java
index e994af5..5958bc2 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/onetoonejointable/LargeProject.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/onetoonejointable/LargeProject.java
@@ -20,7 +20,7 @@
 /**
  * <b>Purpose</b>: Larger scale projects within the Employee Demo
  * <p><b>Description</b>: LargeProject is a concrete subclass of Project. It is instantiated for Projects with type = 'L'. The additional
- * information (budget, & milestoneVersion) are mapped from the LPROJECT table.
+ * information (budget, &amp; milestoneVersion) are mapped from the LPROJECT table.
  * @see Project
  */
 public class LargeProject extends Project {
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/onetoonejointable/Project.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/onetoonejointable/Project.java
index ad76790..f25ea89 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/onetoonejointable/Project.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/onetoonejointable/Project.java
@@ -24,7 +24,7 @@
 import org.eclipse.persistence.descriptors.changetracking.*;
 
 /**
- * <b>Purpose</b>: Abstract superclass for Large & Small projects in Employee Demo
+ * <b>Purpose</b>: Abstract superclass for Large &amp; Small projects in Employee Demo
  * <p><b>Description</b>:     Project is an example of an abstract superclass. It demonstrates how class inheritance can be mapped to database tables.
  * It's subclasses are concrete and may or may not add columns through additional tables. The PROJ_TYPE field in the
  * database table indicates which subclass to instantiate. Projects are involved in a M:M relationship with employees.
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/orderedlist/Child.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/orderedlist/Child.java
index bc5cda9..02fde3f 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/orderedlist/Child.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/orderedlist/Child.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -20,7 +20,7 @@
 
 public class Child {
     public BigDecimal id;
-    /** Direct-to-field mapping, String -> VARCHAR. */
+    /** Direct-to-field mapping, String -{@literal >} VARCHAR. */
     public String firstName;
     public String lastName;
     public int allowance;
@@ -74,7 +74,7 @@
     }
 
     /**
-     * Print the first & last name
+     * Print the first &amp; last name
      */
     public String toString() {
         StringWriter writer = new StringWriter();
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/orderedlist/Employee.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/orderedlist/Employee.java
index efe754b..8ac1841 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/orderedlist/Employee.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/orderedlist/Employee.java
@@ -29,13 +29,13 @@
 public class Employee implements ChangeTracker {
     // implements ChangeTracker for testing
 
-    /** Primary key, mapped as a direct-to-field, BigDecimal -> NUMBER, that makes use of sequence numbers to generate the id. */
+    /** Primary key, mapped as a direct-to-field, BigDecimal -{@literal >} NUMBER, that makes use of sequence numbers to generate the id. */
     public BigDecimal id;
 
-    /** Direct-to-field mapping, String -> VARCHAR. */
+    /** Direct-to-field mapping, String -{@literal >} VARCHAR. */
     public String firstName;
 
-    /** Direct-to-field mapping, String -> VARCHAR. */
+    /** Direct-to-field mapping, String -{@literal >} VARCHAR. */
     public String lastName;
 
     /** One-to-one mapping (same class relationship), employee references its manager through a foreign key. */
@@ -343,7 +343,7 @@
     }
 
     /**
-     * Print the first & last name
+     * Print the first &amp; last name
      */
     public String toString() {
         StringWriter writer = new StringWriter();
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/orderedlist/LargeProject.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/orderedlist/LargeProject.java
index 6a88c23..6179005 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/orderedlist/LargeProject.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/orderedlist/LargeProject.java
@@ -21,7 +21,7 @@
 /**
  * <b>Purpose</b>: Larger scale projects within the Employee Demo
  * <p><b>Description</b>: LargeProject is a concrete subclass of Project. It is instantiated for Projects with type = 'L'. The additional
- * information (budget, & milestoneVersion) are mapped from the LPROJECT table.
+ * information (budget, &amp; milestoneVersion) are mapped from the LPROJECT table.
  * @see Project
  */
 public class LargeProject extends Project {
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/orderedlist/Project.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/orderedlist/Project.java
index 5a21dec..32c0ab8 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/orderedlist/Project.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/orderedlist/Project.java
@@ -27,7 +27,7 @@
 import org.eclipse.persistence.descriptors.changetracking.*;
 
 /**
- * <b>Purpose</b>: Abstract superclass for Large & Small projects in Employee Demo
+ * <b>Purpose</b>: Abstract superclass for Large &amp; Small projects in Employee Demo
  * <p><b>Description</b>:     Project is an example of an abstract superclass. It demonstrates how class inheritance can be mapped to database tables.
  * It's subclasses are concrete and may or may not add columns through additional tables. The PROJ_TYPE field in the
  * database table indicates which subclass to instantiate. Projects are involved in a M:M relationship with employees.
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/performance/Employee.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/performance/Employee.java
index b415c9c..bafe118 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/performance/Employee.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/performance/Employee.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -198,7 +198,7 @@
     }
 
     /**
-     * Print the first & last name
+     * Print the first &amp; last name
      */
     public String toString() {
         StringWriter writer = new StringWriter();
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/performance/EmploymentPeriod.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/performance/EmploymentPeriod.java
index 748e162..b522ab5 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/performance/EmploymentPeriod.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/performance/EmploymentPeriod.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -60,7 +60,7 @@
     }
 
     /**
-     * Print the start & end date
+     * Print the start &amp; end date
      */
     public String toString() {
         StringWriter writer = new StringWriter();
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/performance/LargeProject.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/performance/LargeProject.java
index 961da77..fc32f8d 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/performance/LargeProject.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/performance/LargeProject.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -20,7 +20,7 @@
 /**
  * <b>Purpose</b>: Larger scale projects within the Employee Demo
  * <p><b>Description</b>: LargeProject is a concrete subclass of Project. It is instantiated for Projects with type = 'L'. The additional
- * information (budget, & milestoneVersion) are mapped from the LPROJECT table.
+ * information (budget, &amp; milestoneVersion) are mapped from the LPROJECT table.
  * @see Project
  */
 public class LargeProject extends Project {
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/performance/Project.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/performance/Project.java
index 18fb833..3089512 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/performance/Project.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/performance/Project.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -17,7 +17,7 @@
 import java.io.*;
 
 /**
- * <b>Purpose</b>: Abstract superclass for Large & Small projects in Employee Demo
+ * <b>Purpose</b>: Abstract superclass for Large &amp; Small projects in Employee Demo
  * <p><b>Description</b>:     Project is an example of an abstract superclass. It demonstrates how class inheritance can be mapped to database tables.
  * It's subclasses are concrete and may or may not add columns through additional tables. The PROJ_TYPE field in the
  * database table indicates which subclass to instantiate. Projects are involved in a M:M relationship with employees.
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/performance/toplink/LargeProject.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/performance/toplink/LargeProject.java
index 205b0a9..fad12f6 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/performance/toplink/LargeProject.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/performance/toplink/LargeProject.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -20,7 +20,7 @@
 /**
  * <b>Purpose</b>: Larger scale projects within the Employee Demo
  * <p><b>Description</b>: LargeProject is a concrete subclass of Project. It is instantiated for Projects with type = 'L'. The additional
- * information (budget, & milestoneVersion) are mapped from the LPROJECT table.
+ * information (budget, &amp; milestoneVersion) are mapped from the LPROJECT table.
  * @see Project
  */
 public class LargeProject extends Project {
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/performance/toplink/Project.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/performance/toplink/Project.java
index 64392bc..fb86f28 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/performance/toplink/Project.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/performance/toplink/Project.java
@@ -17,7 +17,7 @@
 import org.eclipse.persistence.indirection.*;
 
 /**
- * <b>Purpose</b>: Abstract superclass for Large & Small projects in Employee Demo
+ * <b>Purpose</b>: Abstract superclass for Large &amp; Small projects in Employee Demo
  * <p><b>Description</b>:     Project is an example of an abstract superclass. It demonstrates how class inheritance can be mapped to database tables.
  * It's subclasses are concrete and may or may not add columns through additional tables. The PROJ_TYPE field in the
  * database table indicates which subclass to instantiate. Projects are involved in a M:M relationship with employees.
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/readonly/Studio.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/readonly/Studio.java
index 179af2d..5fdc3da 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/readonly/Studio.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/readonly/Studio.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -79,8 +79,8 @@
     public static Studio example4() {
         Studio example = new Studio();
 
-        example.setName("Tall & Short Studio");
-        example.setOwner("Mutt & Jeff");
+        example.setName("Tall &amp; Short Studio");
+        example.setOwner("Mutt &amp; Jeff");
         example.setAddress(Address.example4());
 
         return example;
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/relationshipmaintenance/Dept.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/relationshipmaintenance/Dept.java
index b47602d..ac79409 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/relationshipmaintenance/Dept.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/relationshipmaintenance/Dept.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -21,8 +21,8 @@
 public class Dept implements Serializable {
 
     /**
-     * Map empCollection <-> model.Emp
-     * @associates <{model.Emp}>
+     * Map empCollection {@literal <}-{@literal >} model.Emp
+     * associates {@code <{model.Emp}>}
      */
     public Collection empCollection;
     public Double deptno;
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/relationshipmaintenance/Emp.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/relationshipmaintenance/Emp.java
index 12c85c5..67be71a 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/relationshipmaintenance/Emp.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/relationshipmaintenance/Emp.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -21,8 +21,8 @@
 public class Emp implements Serializable {
 
     /**
-     * Map deptno <-> model.Dept
-     * @associates <{model.Dept}>
+     * Map deptno {@literal <}-{@literal >} model.Dept
+     * associates {@code <{model.Dept}>}
      */
     public ValueHolderInterface deptno;
     public Double empno;
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/unidirectional/Employee.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/unidirectional/Employee.java
index 840c9d1..21c983e 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/unidirectional/Employee.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/unidirectional/Employee.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -23,13 +23,13 @@
  * Everything else (ValueHolderInterface for example) is kept the same as in original Employee to simplify comparative debugging.
  */
 public class Employee implements Serializable {
-    /** Primary key, mapped as a direct-to-field, BigDecimal -> NUMBER, that makes use of sequence numbers to generate the id. */
+    /** Primary key, mapped as a direct-to-field, BigDecimal -{@literal >} NUMBER, that makes use of sequence numbers to generate the id. */
     public int id;
 
-    /** Direct-to-field mapping, String -> VARCHAR. */
+    /** Direct-to-field mapping, String -{@literal >} VARCHAR. */
     public String firstName;
 
-    /** Direct-to-field mapping, String -> VARCHAR. */
+    /** Direct-to-field mapping, String -{@literal >} VARCHAR. */
     public String lastName;
 
     /** One-to-many unidirectional mapping */
@@ -136,7 +136,7 @@
     }
 
     /**
-     * Print the first & last name
+     * Print the first &amp; last name
      */
     public String toString() {
         StringWriter writer = new StringWriter();
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/vehicle/CarOwner.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/vehicle/CarOwner.java
index 387f5e8..cc5c49f 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/vehicle/CarOwner.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/models/vehicle/CarOwner.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2011, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2011, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -18,6 +18,7 @@
  * This tests;
  * <ul>
  * <li> the query populated with wrong select list items.
+ * </ul>
  */
 public class CarOwner implements java.io.Serializable {
     public Number id;
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/aggregate/CheckForNullUnitOfWorkTest.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/aggregate/CheckForNullUnitOfWorkTest.java
index 8605cf2..625f826 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/aggregate/CheckForNullUnitOfWorkTest.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/aggregate/CheckForNullUnitOfWorkTest.java
@@ -48,11 +48,11 @@
  *                                <li>    <i>First and Last Name</i>, Direct To Field
  *                                <li> <i>Project's Description</i>, Aggregate Objects, Direct To Field
  *                                <li>    <i>Period</i>, Third level Aggregate Object replaced
- *                                <li>    <i>Computer<i>, Aggregate Object's 1 to 1 mapped object
+ *                                <li>    <i>Computer</i>, Aggregate Object's 1 to 1 mapped object
  *                                <li>    <i>Responsibilities</i>,Aggregate objects 1:M mapping
  *                                <li> <i>Language Modified</i>, Aggregate objects M:M mapping
  *                                <li> <i>null added to languages</i>, Aggregate objects M:M mapping
- *
+ *                                </ul>
  */
 public class CheckForNullUnitOfWorkTest extends WriteObjectTest {
     public Object unitOfWorkWorkingCopy;
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/aggregate/UnitOfWorkCommitResumeTest.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/aggregate/UnitOfWorkCommitResumeTest.java
index 3950d98..0a7a9aa 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/aggregate/UnitOfWorkCommitResumeTest.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/aggregate/UnitOfWorkCommitResumeTest.java
@@ -51,12 +51,12 @@
  *                                <li>    <i>3 Level Aggregation</i>, modifying object at third level
  *                                <li> <i>1 Level Aggregation's 1:1 Mapping</i>, replacing object with new object
  *                                <li>    <i>1 Level Aggregation's 1:1 Mapping</i>, Replacing with a new object
- *                                <li>    <i>1 Level Aggregation's 1:M Mapping<i>, Deletion of an object
+ *                                <li>    <i>1 Level Aggregation's 1:M Mapping</i>, Deletion of an object
  *                                <li>    <i>1 Level Aggregation's 1:M Mapping</i>,Addition of a new element
  *                                <li> <i>1 Level Aggregation's M:M Mapping </i>, Deleting an Object
  *                                <li> <i>1 Level Aggregation's M:M Mapping</i>, Modifying an object
  *                                <li>    <i>1 Level Aggregation's M:M Mapping</i>, Replacing with a new object
- *
+ *                                </ul>
  * */
 public class UnitOfWorkCommitResumeTest extends WriteObjectTest {
     public Object unitOfWorkWorkingCopy;
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/aggregate/UnitOfWorkTest.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/aggregate/UnitOfWorkTest.java
index 701d548..78c3729 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/aggregate/UnitOfWorkTest.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/aggregate/UnitOfWorkTest.java
@@ -46,11 +46,12 @@
  *                                <li>    <i>3 Level Aggregation</i>, modifying object at third level
  *                                <li> <i>1 Level Aggregation's 1:1 Mapping</i>, replacing object with new object
  *                                <li>    <i>1 Level Aggregation's 1:1 Mapping</i>, Replacing with a new object
- *                                <li>    <i>1 Level Aggregation's 1:M Mapping<i>, Deletion of an object
+ *                                <li>    <i>1 Level Aggregation's 1:M Mapping</i>, Deletion of an object
  *                                <li>    <i>1 Level Aggregation's 1:M Mapping</i>,Addition of a new element
  *                                <li> <i>1 Level Aggregation's M:M Mapping </i>, Deleting an Object
  *                                <li> <i>1 Level Aggregation's M:M Mapping</i>, Modifying an object
  *                                <li>    <i>1 Level Aggregation's M:M Mapping</i>, Replacing with a new object
+ *                                </ul>
  *
  */
 public class UnitOfWorkTest extends WriteObjectTest {
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/clientserver/DeadLockAddress.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/clientserver/DeadLockAddress.java
index 8708a4b..6a3d641 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/clientserver/DeadLockAddress.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/clientserver/DeadLockAddress.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -20,7 +20,7 @@
 /**
  * <p><b>Purpose</b>: Represents the mailing address on an Employee
  * <p><b>Description</b>: Held in a private 1:1 relationship from Employee
- * @see Employee
+ * @see DeadLockEmployee
  */
 public class DeadLockAddress implements Serializable {
     public BigDecimal id;
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/clientserver/DeadLockEmployee.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/clientserver/DeadLockEmployee.java
index 2c6a498..9ba58d6 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/clientserver/DeadLockEmployee.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/clientserver/DeadLockEmployee.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -27,16 +27,16 @@
  */
 public class DeadLockEmployee implements Serializable {
 
-    /** Primary key, maped as a direct-to-field, BigDecimal -> NUMBER, that makes use of sequence numbers to generate the id. */
+    /** Primary key, maped as a direct-to-field, BigDecimal -{@literal >} NUMBER, that makes use of sequence numbers to generate the id. */
     public BigDecimal id;
 
-    /** Direct-to-field mapping, String -> VARCHAR. */
+    /** Direct-to-field mapping, String -{@literal >} VARCHAR. */
     public String firstName;
 
-    /** Direct-to-field mapping, String -> VARCHAR. */
+    /** Direct-to-field mapping, String -{@literal >} VARCHAR. */
     public String lastName;
 
-    /** Object-type mapping, maps "Male" -> "M", "Female" -> "F". */
+    /** Object-type mapping, maps "Male" -{@literal >} "M", "Female" -{@literal >} "F". */
     public String gender;
 
     /** One-to-one mapping, employee references its address through a foreign key. */
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/clientserver/EmployeeForClientServerSession.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/clientserver/EmployeeForClientServerSession.java
index 3f4804e..1342d3ec 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/clientserver/EmployeeForClientServerSession.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/clientserver/EmployeeForClientServerSession.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -21,13 +21,13 @@
 
 public class EmployeeForClientServerSession implements Serializable {
 
-    /** Primary key, maped as a direct-to-field, BigDecimal -> NUMBER, that makes use of sequence numbers to generate the id. */
+    /** Primary key, maped as a direct-to-field, BigDecimal -{@literal >} NUMBER, that makes use of sequence numbers to generate the id. */
     public BigDecimal id;
 
-    /** Direct-to-field mapping, String -> VARCHAR. */
+    /** Direct-to-field mapping, String -{@literal >} VARCHAR. */
     public String firstName;
 
-    /** Direct-to-field mapping, String -> VARCHAR. */
+    /** Direct-to-field mapping, String -{@literal >} VARCHAR. */
     public String lastName;
 
     /** One-to-many mapping, employee references its collection of phone numbers using a foreign key in the phone's table. */
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/distributedservers/Company.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/distributedservers/Company.java
index 4add810..9529e9e 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/distributedservers/Company.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/distributedservers/Company.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -28,7 +28,7 @@
 
     public static Company example1() {
         Company company = new Company();
-        company.name = "Hoser & Hoser International";
+        company.name = "Hoser &amp; Hoser International";
         return company;
     }
 
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/dynamic/MyEntity.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/dynamic/MyEntity.java
index bf955ff..7986bfb 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/dynamic/MyEntity.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/dynamic/MyEntity.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -24,7 +24,7 @@
 
 /**
  * Simple concrete DynamicEntity to test the functionality
- * of EntityType independently of the {@link DynamicClassLoader}
+ * of EntityType independently of the {@link org.eclipse.persistence.dynamic.DynamicClassLoader}
  * functionality which typically generates subclasses.
  */
 public class MyEntity extends DynamicEntityImpl {
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/dynamic/dynamicclassloader/Compatible.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/dynamic/dynamicclassloader/Compatible.java
index 2f9ac76..b8d4a22 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/dynamic/dynamicclassloader/Compatible.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/dynamic/dynamicclassloader/Compatible.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2011, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2011, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -23,7 +23,7 @@
 import org.eclipse.persistence.internal.dynamic.DynamicPropertiesManager;
 
 /**
- * Test class - when created by a {@link DynamicClassLoader}, should <b>not</b> throw {@link IllegalArgumentException}
+ * Test class - when created by a {@link org.eclipse.persistence.dynamic.DynamicClassLoader}, should <b>not</b> throw {@link IllegalArgumentException}
  * @author mnorman
  *
  */
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/dynamic/dynamicclassloader/Incompatible.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/dynamic/dynamicclassloader/Incompatible.java
index cc72e80..310309d 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/dynamic/dynamicclassloader/Incompatible.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/dynamic/dynamicclassloader/Incompatible.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2011, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2011, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -20,7 +20,7 @@
 package org.eclipse.persistence.testing.tests.dynamic.dynamicclassloader;
 
 /**
- * Test class - when created by a {@link DynamicClassLoader}, should throw {@link IllegalArgumentException}
+ * Test class - when created by a {@link org.eclipse.persistence.dynamic.DynamicClassLoader}, should throw {@link IllegalArgumentException}
  * @author mnorman
  *
  */
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/dynamic/entitytype/MyEntity.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/dynamic/entitytype/MyEntity.java
index 4ba02a2..02f7dfc 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/dynamic/entitytype/MyEntity.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/dynamic/entitytype/MyEntity.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -24,7 +24,7 @@
 
 /**
  * Simple concrete DynamicEntity to test the functionality
- * of EntityType independently of the {@link DynamicClassLoader}
+ * of EntityType independently of the {@link org.eclipse.persistence.dynamic.DynamicClassLoader}
  * functionality which typically generates subclasses.
  */
 public class MyEntity extends DynamicEntityImpl {
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/dynamic/projectxml/InvalidConfig.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/dynamic/projectxml/InvalidConfig.java
index 2b5abfe..e3342d7 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/dynamic/projectxml/InvalidConfig.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/dynamic/projectxml/InvalidConfig.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -35,7 +35,7 @@
 
 /**
  * Test cases verifying invalid args passed to
- * {@link DynamicTypeBuilder#loadDynamicProject(String, DatabaseLogin)}
+ * {@link DynamicTypeBuilder#loadDynamicProject(String, DatabaseLogin, DynamicClassLoader)}
  */
 public class InvalidConfig {
 
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/expressions/ReadAllExpressionTest.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/expressions/ReadAllExpressionTest.java
index 418b83d..2125f12 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/expressions/ReadAllExpressionTest.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/expressions/ReadAllExpressionTest.java
@@ -191,11 +191,11 @@
     /**
      * This flag has been added to test adding batch attributes to very
      * complex expressions.  This method assumes that the query is on Employee.
-     * @see ExpressionSubSelectTestSuite#addExistsWithBatchAttributeTest
-     * @see ExpressionSubSelectTestSuite#addObjectComparisonWithBatchAttributeTest
-     * @see ExpressionSubSelectTestSuite#addParallelSelectWithBatchAttributeTest
-     * @see ExpressionSubSelectTestSuite#addSubSelectInWithBatchAttributeTest
-     * @see ExpressionSubSelectTestSuite#addOneToManyJoin2WithBatchReadTest
+     * (see ExpressionSubSelectTestSuite#addOneToManyJoin2WithBatchReadTest)
+     * @see ExpressionSubSelectTestSuite#addExistsWithBatchAttributeTest()
+     * @see ExpressionSubSelectTestSuite#addObjectComparisonWithBatchAttributeTest()
+     * @see ExpressionSubSelectTestSuite#addParallelSelectWithBatchAttributeTest()
+     * @see ExpressionSubSelectTestSuite#addSubSelectInWithBatchAttributeTest()
      */
     public void testBatchAttributesOnEmployee() {
             testBatchAttributesOnEmployee = true;
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/feature/QueryTimeoutBatchDatabaseQueryTest.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/feature/QueryTimeoutBatchDatabaseQueryTest.java
index 07b6f74..82705e3 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/feature/QueryTimeoutBatchDatabaseQueryTest.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/feature/QueryTimeoutBatchDatabaseQueryTest.java
@@ -23,7 +23,7 @@
 import org.eclipse.persistence.sessions.UnitOfWork;
 
 /**
- * Bug 214910:  Add query timeout support to batched update queries (Oracle DB 9.0.1+)</p>
+ * Bug 214910:  Add query timeout support to batched update queries (Oracle DB 9.0.1+)<br>
  * Test the query timeout feature in batch queries.
  * For data queries , a queryTimeout on the largest DatabaseQuery of the batch will be used.
  * For object queries, a queryTimeout on the largest DescriptorQueryManager (parent) or DatabaseQuery
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/feature/QueryTimeoutBatchDescriptorQueryManagerTest.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/feature/QueryTimeoutBatchDescriptorQueryManagerTest.java
index 95a6cd2..dfb8c2f 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/feature/QueryTimeoutBatchDescriptorQueryManagerTest.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/feature/QueryTimeoutBatchDescriptorQueryManagerTest.java
@@ -25,7 +25,7 @@
 import org.eclipse.persistence.testing.models.employee.domain.Employee;
 
 /**
- * Bug 214910:  Add query timeout support to batched update queries (Oracle DB 9.0.1+)</p>
+ * Bug 214910:  Add query timeout support to batched update queries (Oracle DB 9.0.1+)<br>
  * Test the query timeout feature in batch queries.
  * For data queries , a queryTimeout on the largest DatabaseQuery of the batch will be used.
  * For object queries, a queryTimeout on the largest DescriptorQueryManager (parent) or DatabaseQuery
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/feature/QueryTimeoutBatchDynamicDataModifyDatabaseQueryParentRefExceptionTest.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/feature/QueryTimeoutBatchDynamicDataModifyDatabaseQueryParentRefExceptionTest.java
index ee87e61..7af0948 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/feature/QueryTimeoutBatchDynamicDataModifyDatabaseQueryParentRefExceptionTest.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/feature/QueryTimeoutBatchDynamicDataModifyDatabaseQueryParentRefExceptionTest.java
@@ -17,7 +17,7 @@
 import org.eclipse.persistence.testing.framework.TestErrorException;
 
 /**
- * Bug 214910:  Add query timeout support to batched update queries (Oracle DB 9.0.1+)</p>
+ * Bug 214910:  Add query timeout support to batched update queries (Oracle DB 9.0.1+)<br>
  * Test the query timeout feature in batch queries.
  * For data queries , a queryTimeout on the largest DatabaseQuery of the batch will be used.
  * For object queries, a queryTimeout on the largest DescriptorQueryManager (parent) or DatabaseQuery
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/feature/QueryTimeoutBatchDynamicDatabaseQueryTest.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/feature/QueryTimeoutBatchDynamicDatabaseQueryTest.java
index 6fa9c52..9bbf3c4 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/feature/QueryTimeoutBatchDynamicDatabaseQueryTest.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/feature/QueryTimeoutBatchDynamicDatabaseQueryTest.java
@@ -17,7 +17,7 @@
 import org.eclipse.persistence.testing.framework.TestErrorException;
 
 /**
- * Bug 214910:  Add query timeout support to batched update queries (Oracle DB 9.0.1+)</p>
+ * Bug 214910:  Add query timeout support to batched update queries (Oracle DB 9.0.1+)<br>
  * Test the query timeout feature in batch queries.
  * For data queries , a queryTimeout on the largest DatabaseQuery of the batch will be used.
  * For object queries, a queryTimeout on the largest DescriptorQueryManager (parent) or DatabaseQuery
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/feature/QueryTimeoutBatchDynamicDescriptorQueryManagerTest.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/feature/QueryTimeoutBatchDynamicDescriptorQueryManagerTest.java
index 8490034..09bb17d 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/feature/QueryTimeoutBatchDynamicDescriptorQueryManagerTest.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/feature/QueryTimeoutBatchDynamicDescriptorQueryManagerTest.java
@@ -17,7 +17,7 @@
 import org.eclipse.persistence.testing.framework.TestErrorException;
 
 /**
- * Bug 214910:  Add query timeout support to batched update queries (Oracle DB 9.0.1+)</p>
+ * Bug 214910:  Add query timeout support to batched update queries (Oracle DB 9.0.1+)<br>
  * Test the query timeout feature in batch queries.
  * For data queries , a queryTimeout on the largest DatabaseQuery of the batch will be used.
  * For object queries, a queryTimeout on the largest DescriptorQueryManager (parent) or DatabaseQuery
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/feature/QueryTimeoutBatchParameterizedDatabaseQueryTest.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/feature/QueryTimeoutBatchParameterizedDatabaseQueryTest.java
index 5914392..8e69ad3 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/feature/QueryTimeoutBatchParameterizedDatabaseQueryTest.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/feature/QueryTimeoutBatchParameterizedDatabaseQueryTest.java
@@ -17,7 +17,7 @@
 import org.eclipse.persistence.testing.framework.TestErrorException;
 
 /**
- * Bug 214910:  Add query timeout support to batched update queries (Oracle DB 9.0.1+)</p>
+ * Bug 214910:  Add query timeout support to batched update queries (Oracle DB 9.0.1+)<br>
  * Test the query timeout feature in batch queries.
  * For data queries , a queryTimeout on the largest DatabaseQuery of the batch will be used.
  * For object queries, a queryTimeout on the largest DescriptorQueryManager (parent) or DatabaseQuery
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/feature/QueryTimeoutBatchParameterizedDescriptorQueryManagerTest.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/feature/QueryTimeoutBatchParameterizedDescriptorQueryManagerTest.java
index 15c768f..2bad101 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/feature/QueryTimeoutBatchParameterizedDescriptorQueryManagerTest.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/feature/QueryTimeoutBatchParameterizedDescriptorQueryManagerTest.java
@@ -17,7 +17,7 @@
 import org.eclipse.persistence.testing.framework.TestErrorException;
 
 /**
- * Bug 214910:  Add query timeout support to batched update queries (Oracle DB 9.0.1+)</p>
+ * Bug 214910:  Add query timeout support to batched update queries (Oracle DB 9.0.1+)<br>
  * Test the query timeout feature in batch queries.
  * For data queries , a queryTimeout on the largest DatabaseQuery of the batch will be used.
  * For object queries, a queryTimeout on the largest DescriptorQueryManager (parent) or DatabaseQuery
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/feature/QueryTimeoutBatchTestCase.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/feature/QueryTimeoutBatchTestCase.java
index 1eeb08a..eeccc7b 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/feature/QueryTimeoutBatchTestCase.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/feature/QueryTimeoutBatchTestCase.java
@@ -31,7 +31,7 @@
 import org.eclipse.persistence.testing.models.employee.domain.Employee;
 
 /**
- * Bug 214910:  Add query timeout support to batched update queries</p>
+ * Bug 214910:  Add query timeout support to batched update queries<br>
  * Test the query timeout feature in batch queries.
  * For data queries , a queryTimeout on the largest DatabaseQuery of the batch will be used.
  * For object queries, a queryTimeout on the largest DescriptorQueryManager (parent) or DatabaseQuery
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/forceupdate/FUVLTimestampLockInCacheTest.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/forceupdate/FUVLTimestampLockInCacheTest.java
index 093c117..6bd0639 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/forceupdate/FUVLTimestampLockInCacheTest.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/forceupdate/FUVLTimestampLockInCacheTest.java
@@ -44,7 +44,7 @@
 
     Test 3: (Test method removeForceUpdateToVersionField())
     UOW1 updates employee's address,
-    calls forceUpdateToVersionField(cloneFromUOW1,true),COMMIT&RESUMEs.
+    calls forceUpdateToVersionField(cloneFromUOW1,true),COMMIT&amp;RESUMEs.
     It calls removeForceUpdateToVersionField(cloneFromUOW1),
     updates employee's address again and commits.
     UOW2 reads employee after the first commit of UOW1,updates the emplyee's salary
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/forceupdate/FUVLTimestampLockInObjectTest.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/forceupdate/FUVLTimestampLockInObjectTest.java
index d971025..1efbab2 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/forceupdate/FUVLTimestampLockInObjectTest.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/forceupdate/FUVLTimestampLockInObjectTest.java
@@ -44,7 +44,7 @@
 
     Test 3: (Test method removeForceUpdateToVersionField())
     UOW1 updates employee's address,
-    calls forceUpdateToVersionField(cloneFromUOW1,true),COMMIT&RESUMEs.
+    calls forceUpdateToVersionField(cloneFromUOW1,true),COMMIT&amp;RESUMEs.
     It calls removeForceUpdateToVersionField(cloneFromUOW1),
     updates employee's address again and commits.
     UOW2 reads employee after the first commit of UOW1,updates the emplyee's salary
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/forceupdate/FUVLVersionLockInCacheTest.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/forceupdate/FUVLVersionLockInCacheTest.java
index dab4f4a..f26f20e 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/forceupdate/FUVLVersionLockInCacheTest.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/forceupdate/FUVLVersionLockInCacheTest.java
@@ -44,7 +44,7 @@
 
     Test 3: (Test method removeForceUpdateToVersionField())
     UOW1 updates employee's address,
-    calls forceUpdateToVersionField(cloneFromUOW1,true),COMMIT&RESUMEs.
+    calls forceUpdateToVersionField(cloneFromUOW1,true),COMMIT&amp;RESUMEs.
     It calls removeForceUpdateToVersionField(cloneFromUOW1),
     updates employee's address again and commits.
     UOW2 reads employee after the first commit of UOW1,updates the emplyee's salary
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/forceupdate/FUVLVersionLockInObjectTest.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/forceupdate/FUVLVersionLockInObjectTest.java
index 695fbef..c0888c3 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/forceupdate/FUVLVersionLockInObjectTest.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/forceupdate/FUVLVersionLockInObjectTest.java
@@ -44,7 +44,7 @@
 
     Test 3: (Test method removeForceUpdateToVersionField())
     UOW1 updates employee's address,
-    calls forceUpdateToVersionField(cloneFromUOW1,true),COMMIT&RESUMEs.
+    calls forceUpdateToVersionField(cloneFromUOW1,true),COMMIT&amp;RESUMEs.
     It calls removeForceUpdateToVersionField(cloneFromUOW1),
     updates employee's address again and commits.
     UOW2 reads employee after the first commit of UOW1,updates the emplyee's salary
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/inheritance/ReinitializeJoiningOnClassDescriptorWithInheritanceTest.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/inheritance/ReinitializeJoiningOnClassDescriptorWithInheritanceTest.java
index e95a75a..45ec316 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/inheritance/ReinitializeJoiningOnClassDescriptorWithInheritanceTest.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/inheritance/ReinitializeJoiningOnClassDescriptorWithInheritanceTest.java
@@ -23,7 +23,7 @@
  *
  * Test to ensure that no exceptions are thrown when reInitializeJoinedAttributes() is
  * invoked on a ClassDescriptor when inheritance is involved.
- * Although this method is internal, it is invoked by OneToOneMapping>>setUsesJoining()
+ * Although this method is internal, it is invoked by OneToOneMapping{@literal >>}setUsesJoining()
  * which is a deprecated method. This test invokes this API directly for this reason.
  * @author dminsky
  */
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/inheritance/UnitOfWorkCommitResumeTest.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/inheritance/UnitOfWorkCommitResumeTest.java
index 4ec9c13..ff073b2 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/inheritance/UnitOfWorkCommitResumeTest.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/inheritance/UnitOfWorkCommitResumeTest.java
@@ -53,6 +53,7 @@
  *                                <li>    <i>Bus added to vehicles</i>, 2L inheritance from vehicle, has own table
  *                                <li>    <i>Vehicle deleted</i>, deletion with inheritance
  *                                <li>    <i>Company name adjusted</i>,
+ *                                </ul>
  *
  * */
 public class UnitOfWorkCommitResumeTest extends WriteObjectTest {
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/inheritance/UnitOfWorkTest.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/inheritance/UnitOfWorkTest.java
index 847182e..3ddc56c 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/inheritance/UnitOfWorkTest.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/inheritance/UnitOfWorkTest.java
@@ -49,7 +49,8 @@
  *                                <li>    <i>Bicycle added to vehicles</i>, 2L inheritance from vehicle, on same table
  *                                <li> <i>Car added to vehicles</i>, 2L inheritance from vehicle, has own table
  *                                <li>    <i>Bus added to vehicles</i>, 2L inheritance from vehicle, has own table
- *                                <li>    <i>Vehicle deleted<i>, deletion with inheritance
+ *                                <li>    <i>Vehicle deleted</i>, deletion with inheritance
+ *                                </ul>
  *
  * */
 public class UnitOfWorkTest extends WriteObjectTest {
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/isolatedsession/IsolatedAddress.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/isolatedsession/IsolatedAddress.java
index 45f5c8d..a1f5bf9 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/isolatedsession/IsolatedAddress.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/isolatedsession/IsolatedAddress.java
@@ -26,7 +26,7 @@
 /**
  * <p><b>Purpose</b>: Represents the mailing address on an Employee
  * <p><b>Description</b>: Held in a private 1:1 relationship from Employee
- * @see Employee
+ * @see IsolatedEmployee
  */
 public class IsolatedAddress implements Serializable, ChangeTracker {
     // implements ChangeTracker for testing
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/isolatedsession/IsolatedEmployee.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/isolatedsession/IsolatedEmployee.java
index 63cda46..d11ce53 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/isolatedsession/IsolatedEmployee.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/isolatedsession/IsolatedEmployee.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -34,16 +34,16 @@
  */
 public class IsolatedEmployee implements Serializable {
 
-    /** Primary key, maped as a direct-to-field, BigDecimal -> NUMBER, that makes use of sequence numbers to generate the id. */
+    /** Primary key, maped as a direct-to-field, BigDecimal -{@literal >} NUMBER, that makes use of sequence numbers to generate the id. */
     public BigDecimal id;
 
-    /** Direct-to-field mapping, String -> VARCHAR. */
+    /** Direct-to-field mapping, String -{@literal >} VARCHAR. */
     public String firstName;
 
-    /** Direct-to-field mapping, String -> VARCHAR. */
+    /** Direct-to-field mapping, String -{@literal >} VARCHAR. */
     public String lastName;
 
-    /** Object-type mapping, maps "Male" -> "M", "Female" -> "F". */
+    /** Object-type mapping, maps "Male" -{@literal >} "M", "Female" -{@literal >} "F". */
     public String gender;
 
     /** Aggregate-object mapping, stores the object in the employee's table. */
@@ -67,11 +67,11 @@
     /** Direct-collection mapping, employee stores its collection of plain Strings in an intermediate table. */
     public ValueHolderInterface responsibilitiesList;
 
-    /** Transformation mapping, a two(2) element array holding the employee's normal working hours (START_TIME & END_TIME),
+    /** Transformation mapping, a two(2) element array holding the employee's normal working hours (START_TIME &amp; END_TIME),
         this is stored into two different fields in the employee table. */
     public Time[] normalHours;
 
-    /** Direct-to-field mapping, int -> NUMBER, salary of the employee in dollars. */
+    /** Direct-to-field mapping, int -{@literal >} NUMBER, salary of the employee in dollars. */
     public int salary;
     public boolean hasChanges = false;
 
@@ -647,7 +647,7 @@
     }
 
     /**
-     * Print the first & last name
+     * Print the first &amp; last name
      */
     public String toString() {
         StringWriter writer = new StringWriter();
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/isolatedsession/IsolatedEmploymentPeriod.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/isolatedsession/IsolatedEmploymentPeriod.java
index 851a399..5d767b1 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/isolatedsession/IsolatedEmploymentPeriod.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/isolatedsession/IsolatedEmploymentPeriod.java
@@ -27,7 +27,7 @@
  * <p><b>Purpose</b>: Defines the period an Employee worked for the organization
  *    <p><b>Description</b>: The period holds the start date and optionally the end date if the employee has left (null otherwise).
  *                                Maintained in an aggregate relationship of Employee
- *    @see Employee
+ *    @see IsolatedEmployee
  */
 public class IsolatedEmploymentPeriod implements Serializable, ChangeTracker {
     // implements ChangeTracker for testing
@@ -94,7 +94,7 @@
     }
 
     /**
-     * Print the start & end date
+     * Print the start &amp; end date
      */
     public String toString() {
         StringWriter writer = new StringWriter();
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/nls/japanese/NLSEmployee.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/nls/japanese/NLSEmployee.java
index de09286..f543640 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/nls/japanese/NLSEmployee.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/nls/japanese/NLSEmployee.java
@@ -37,16 +37,16 @@
 //public class Employee implements org.eclipse.persistence.testing.models.employee.interfaces.Employee, Serializable {
 public class NLSEmployee implements org.eclipse.persistence.testing.models.employee.interfaces.Employee, Serializable {
 
-    /** Primary key, maped as a direct-to-field, BigDecimal -> NUMBER, that makes use of sequence numbers to generate the id. */
+    /** Primary key, maped as a direct-to-field, BigDecimal -{@literal >} NUMBER, that makes use of sequence numbers to generate the id. */
     public BigDecimal id;
 
-    /** Direct-to-field mapping, String -> VARCHAR. */
+    /** Direct-to-field mapping, String -{@literal >} VARCHAR. */
     public String firstName;
 
-    /** Direct-to-field mapping, String -> VARCHAR. */
+    /** Direct-to-field mapping, String -{@literal >} VARCHAR. */
     public String lastName;
 
-    /** Object-type mapping, maps "Male" -> "M", "Female" -> "F". */
+    /** Object-type mapping, maps "Male" -{@literal >} "M", "Female" -{@literal >} "F". */
     public String gender;
 
     /** Aggregate-object mapping, stores the object in the employee's table. */
@@ -70,11 +70,11 @@
     /** Direct-collection mapping, employee stores its collection of plain Strings in an intermediate table. */
     public ValueHolderInterface responsibilitiesList;
 
-    /** Transformation mapping, a two(2) element array holding the employee's normal working hours (START_TIME & END_TIME),
+    /** Transformation mapping, a two(2) element array holding the employee's normal working hours (START_TIME &amp; END_TIME),
         this is stored into two different fields in the employee table. */
     public Time[] normalHours;
 
-    /** Direct-to-field mapping, int -> NUMBER, salary of the employee in dollars. */
+    /** Direct-to-field mapping, int -{@literal >} NUMBER, salary of the employee in dollars. */
     public int salary;
 
     /**
@@ -397,7 +397,7 @@
     }
 
     /**
-     * Print the first & last name
+     * Print the first &amp; last name
      */
     public String toString() {
         StringWriter writer = new StringWriter();
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/optimisticlocking/cascaded/CascadedVersionLockingMultiplePrivateOwnedTest.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/optimisticlocking/cascaded/CascadedVersionLockingMultiplePrivateOwnedTest.java
index a519004..fc20715 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/optimisticlocking/cascaded/CascadedVersionLockingMultiplePrivateOwnedTest.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/optimisticlocking/cascaded/CascadedVersionLockingMultiplePrivateOwnedTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -28,10 +28,11 @@
 import org.eclipse.persistence.mappings.ForeignReferenceMapping;
 
 /**
+ * <pre>{@code
  * Project --\
  *            ---> Employee --> PhoneNumber
  * Child ----/
- *
+ *}</pre>
  * EL bug 342632
  */
 public class CascadedVersionLockingMultiplePrivateOwnedTest extends TestCase {
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/performance/reading/ReadAllComplexvsConformTest.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/performance/reading/ReadAllComplexvsConformTest.java
index d84ae7c..54cf7a0 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/performance/reading/ReadAllComplexvsConformTest.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/performance/reading/ReadAllComplexvsConformTest.java
@@ -51,7 +51,7 @@
     }
 
     /**
-     * Read all employees with salary > 0.
+     * Read all employees with salary {@literal >} 0.
      */
     @Override
     public void test() throws Exception {
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/performance/reading/ReadAllvsConformNewUnitOfWorkTest.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/performance/reading/ReadAllvsConformNewUnitOfWorkTest.java
index 9a3316b..1f46b46 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/performance/reading/ReadAllvsConformNewUnitOfWorkTest.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/performance/reading/ReadAllvsConformNewUnitOfWorkTest.java
@@ -41,7 +41,7 @@
     }
 
     /**
-     * Read all employees with salary > 0.
+     * Read all employees with salary {@literal >} 0.
      */
     @Override
     public void test() throws Exception {
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/performance/reading/ReadAllvsConformTest.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/performance/reading/ReadAllvsConformTest.java
index a476f9d..e4e513e 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/performance/reading/ReadAllvsConformTest.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/performance/reading/ReadAllvsConformTest.java
@@ -46,7 +46,7 @@
     }
 
     /**
-     * Read all employees with salary > 0.
+     * Read all employees with salary {@literal >} 0.
      */
     @Override
     public void test() throws Exception {
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/performance/reading/ReadAllvsInMemoryTest.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/performance/reading/ReadAllvsInMemoryTest.java
index 9688490..5d4e694 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/performance/reading/ReadAllvsInMemoryTest.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/performance/reading/ReadAllvsInMemoryTest.java
@@ -40,7 +40,7 @@
     }
 
     /**
-     * Read all employees with salary > 0.
+     * Read all employees with salary {@literal >} 0.
      */
     @Override
     public void test() throws Exception {
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/queries/ConformResultsPerformanceTest.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/queries/ConformResultsPerformanceTest.java
index 0f418db..316df43 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/queries/ConformResultsPerformanceTest.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/queries/ConformResultsPerformanceTest.java
@@ -22,7 +22,7 @@
 
 /**
  * Test for bug 2612366: Conform results in UnitOfWork extremely slow.
- * <p><b>Test Description:<b>
+ * <p><b>Test Description:</b>
  * <ul>
  * <li>Conform results test using a wrapper policy.
  * <li>Insure that the number of times unwrap is called is linear to the
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/queries/Country.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/queries/Country.java
index 87cf40b..1217e75 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/queries/Country.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/queries/Country.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -72,7 +72,6 @@
 
     /**
      * This method was created in VisualAge.
-     * @return org.eclipse.persistence.testing.tests.queries.Country
      */
     public void setName(String countryName) {
         name = countryName;
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/queries/CursoredStreamReadWriteClientSessionTest.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/queries/CursoredStreamReadWriteClientSessionTest.java
index e6be60d..0c6f332 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/queries/CursoredStreamReadWriteClientSessionTest.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/queries/CursoredStreamReadWriteClientSessionTest.java
@@ -22,7 +22,7 @@
 import org.eclipse.persistence.sessions.server.*;
 
 /**
- * This test verifies if a transaction is committed while using read & write
+ * This test verifies if a transaction is committed while using read &amp; write
  * connections in same client session with cursored stream used in read.
  */
 public class CursoredStreamReadWriteClientSessionTest extends TestCase {
@@ -35,7 +35,7 @@
      * CursoredStreamReadWriteClientSessionTest constructor.
      */
     public CursoredStreamReadWriteClientSessionTest() {
-        setDescription("Verifies if a transaction is committed while using read & write connections in same client session with cursored stream used in read.");
+        setDescription("Verifies if a transaction is committed while using read &amp; write connections in same client session with cursored stream used in read.");
     }
 
     @Override
@@ -50,7 +50,7 @@
             new org.eclipse.persistence.testing.models.employee.relational.EmployeeProject();
         proj.setDatasourceLogin(getSession().getDatasourceLogin().clone());
 
-        // Set initial & min size of connection in pool to ZERO.
+        // Set initial &amp; min size of connection in pool to ZERO.
         this.serverSession = proj.createServerSession(0, 0, 1);
         this.serverSession.setSessionLog(getSession().getSessionLog());
         this.serverSession.login();
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/queries/ObjectLevelReadQueryTest.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/queries/ObjectLevelReadQueryTest.java
index 9697fef..6d64137 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/queries/ObjectLevelReadQueryTest.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/queries/ObjectLevelReadQueryTest.java
@@ -97,7 +97,7 @@
 
     /**
      * {@code [ObjectLevelReadQuery].isCustomQueryUsed} value changer
-     * for {@link #testCheckForCustomQueryRaceConditions()}.
+     * for checkCustomQueryRaceConditionsInReadObjectQuery.
      */
     private static final class ValueChanger extends Thread {
 
@@ -213,7 +213,7 @@
     /**
      * Call {@code [ObjectLevelReadQuery].checkForCustomQuery(AbstractSession, AbstractRecord)} method.
      * @param instance ObjectLevelReadQuery instance on which method is called.
-     * @param mathod   {@code [ObjectLevelReadQuery].checkForCustomQuery(AbstractSession, AbstractRecord)}
+     * @param method   {@code [ObjectLevelReadQuery].checkForCustomQuery(AbstractSession, AbstractRecord)}
      *                 method accessor.
      * @throws Throwable when any exception except NPE in invoked method occurs.
      */
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/queries/report/BarBeerProject.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/queries/report/BarBeerProject.java
index c0d9a65..2b93c32 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/queries/report/BarBeerProject.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/queries/report/BarBeerProject.java
@@ -23,7 +23,7 @@
  * This class was generated by the TopLink project class generator.
  * It stores the meta-data (descriptors) that define the TopLink mappings.
  * ## TopLink - 4.6.0 (Build 417) ##
- * @see com.webgain.integrator.tools.workbench.ProjectClassGenerator
+ * @see org.eclipse.persistence.sessions.factories.ProjectClassGenerator
  */
 public class BarBeerProject extends Project {
     public BarBeerProject() {
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/relationshipmaintenance/RemoveObjectTest.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/relationshipmaintenance/RemoveObjectTest.java
index 109b471..e1caa04 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/relationshipmaintenance/RemoveObjectTest.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/relationshipmaintenance/RemoveObjectTest.java
@@ -19,9 +19,6 @@
 import org.eclipse.persistence.testing.models.relationshipmaintenance.FieldOffice;
 import org.eclipse.persistence.testing.models.relationshipmaintenance.SalesPerson;
 
-/**
- * <class>
- */
 public class RemoveObjectTest extends org.eclipse.persistence.testing.framework.AutoVerifyTestCase {
     public FieldOffice fieldOfficeClone;
     public SalesPerson sales = null;
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/remote/rmi/RMIRemoteSessionControllerDispatcherForTestingExceptions.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/remote/rmi/RMIRemoteSessionControllerDispatcherForTestingExceptions.java
index c632419..53ad8ad 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/remote/rmi/RMIRemoteSessionControllerDispatcherForTestingExceptions.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/remote/rmi/RMIRemoteSessionControllerDispatcherForTestingExceptions.java
@@ -14,13 +14,13 @@
 //     Oracle - initial API and implementation from Oracle TopLink
 package org.eclipse.persistence.testing.tests.remote.rmi;
 
-import java.rmi.*;
-
-import org.eclipse.persistence.internal.sessions.remote.*;
-import org.eclipse.persistence.sessions.remote.rmi.*;
-import org.eclipse.persistence.sessions.*;
+import org.eclipse.persistence.internal.sessions.remote.Transporter;
+import org.eclipse.persistence.sessions.Session;
+import org.eclipse.persistence.sessions.remote.rmi.RMIRemoteSessionControllerDispatcher;
 import org.eclipse.persistence.testing.tests.remote.TransporterGenerator;
 
+import java.rmi.RemoteException;
+
 /**
  * RemoteSessionController sits between the remote session and the session. Any interaction between these
  * two classes takes place through this object. As the object extends unicast remote object it listens to
@@ -30,589 +30,600 @@
 public class RMIRemoteSessionControllerDispatcherForTestingExceptions extends RMIRemoteSessionControllerDispatcher {
     protected TransporterGenerator generator;
 
-public RMIRemoteSessionControllerDispatcherForTestingExceptions(Session session) throws RemoteException
-{
-    // This call to the super is required in RMI.
-    this(session, (TransporterGenerator)session.getProperty("TransporterGenerator"));
-}
-public RMIRemoteSessionControllerDispatcherForTestingExceptions(Session session, TransporterGenerator generator) throws RemoteException
-{
-    // This call to the super is required in RMI.
-    super(session);
-    this.controller = null;
-    this.generator = generator;
-}
+    public RMIRemoteSessionControllerDispatcherForTestingExceptions(Session session) throws RemoteException {
+        // This call to the super is required in RMI.
+        this(session, (TransporterGenerator) session.getProperty("TransporterGenerator"));
+    }
 
-protected Transporter handleByMode() {
-    return generator.generate();
-}
+    public RMIRemoteSessionControllerDispatcherForTestingExceptions(Session session, TransporterGenerator generator) throws RemoteException {
+        // This call to the super is required in RMI.
+        super(session);
+        this.controller = null;
+        this.generator = generator;
+    }
 
-/**
- * INTERNAL:
- * This method is intended to be used by by sessions that wish to execute a command on a
- * remote session
- * @param remoteCommand RemoteCommand The command to be executed on the remote session
- */
+    protected Transporter handleByMode() {
+        return generator.generate();
+    }
 
-@Override
-public Transporter processCommand(Transporter remoteTransporter)
-{
-    return handleByMode();
-}
-/**
- * Begin a transaction on the database.
- */
+    /**
+     * INTERNAL:
+     * This method is intended to be used by by sessions that wish to execute a command on a
+     * remote session
+     *
+     * @param remoteTransporter RemoteCommand The command to be executed on the remote session
+     */
 
-@Override
-public Transporter beginTransaction()
-{
-    return handleByMode();
-}
-/**
- * Begin a transaction on the database.
- */
+    @Override
+    public Transporter processCommand(Transporter remoteTransporter) {
+        return handleByMode();
+    }
 
-@Override
-public Transporter beginEarlyTransaction()
-{
-    return handleByMode();
-}
-/**
- * Remote unit of work after serialization is commited locally.
- */
+    /**
+     * Begin a transaction on the database.
+     */
 
-@Override
-public Transporter commitRootUnitOfWork(Transporter remoteUnitOfWork)
-{
-    return handleByMode();
-}
-/**
- * Commit a transaction on the database.
- */
+    @Override
+    public Transporter beginTransaction() {
+        return handleByMode();
+    }
 
-@Override
-public Transporter commitTransaction()
-{
-    return handleByMode();
-}
-/**
- * TESTING:
- * Return if the two object match completely.
- * This checks the objects attributes and their private parts.
- */
+    /**
+     * Begin a transaction on the database.
+     */
 
-public Transporter compareObjects(Transporter firstObject, Transporter secondObject)
-{
-    return handleByMode();
-}
-/**
- * TESTING:
- * Return true if the object do not match.
- * This checks the objects attributes and their private parts.
- */
+    @Override
+    public Transporter beginEarlyTransaction() {
+        return handleByMode();
+    }
 
-public Transporter compareObjectsDontMatch(Transporter firstObject, Transporter secondObject)
-{
-    return handleByMode();
-}
-/**
- * ADVANCED:
- * Return if their is an object for the primary key.
- */
+    /**
+     * Remote unit of work after serialization is commited locally.
+     */
 
-public Transporter containsObjectInIdentityMap(Transporter domainObject)
-{
-    return handleByMode();
-}
-/**
- * ADVANCED:
- * Return if their is an object for the primary key.
- */
+    @Override
+    public Transporter commitRootUnitOfWork(Transporter remoteUnitOfWork) {
+        return handleByMode();
+    }
 
-public Transporter containsObjectInIdentityMap(Transporter primaryKey, Transporter theClass)
-{
-    return handleByMode();
-}
-/**
- * Used for closing cursored streams across RMI.
- */
+    /**
+     * Commit a transaction on the database.
+     */
 
-@Override
-public Transporter cursoredStreamClose(Transporter remoteCursoredStreamID) {
-    return handleByMode();
-}
-/**
- * Retrieve next page size of objects from the remote cursored stream
- */
+    @Override
+    public Transporter commitTransaction() {
+        return handleByMode();
+    }
 
-@Override
-public Transporter cursoredStreamNextPage(Transporter remoteCursoredStream, int pageSize) {
-    return handleByMode();
-}
-/**
- * Return the cursored stream size
- */
+    /**
+     * TESTING:
+     * Return if the two object match completely.
+     * This checks the objects attributes and their private parts.
+     */
 
-@Override
-public Transporter cursoredStreamSize(Transporter remoteCursoredStreamOid) {
-    return handleByMode();
-}
-/**
- * Returns a remote cursor stub in a transporter
- */
+    public Transporter compareObjects(Transporter firstObject, Transporter secondObject) {
+        return handleByMode();
+    }
 
-@Override
-public Transporter cursorSelectObjects(Transporter remoteTransporter)
-{
-    return handleByMode();
-}
-/**
- * A remote query after serialization is executed locally.
- */
+    /**
+     * TESTING:
+     * Return true if the object do not match.
+     * This checks the objects attributes and their private parts.
+     */
 
-@Override
-public Transporter executeNamedQuery(Transporter nameTransporter, Transporter classTransporter, Transporter argumentsTransporter)
-{
-    return handleByMode();
-}
-/**
- * A remote query after serialization is executed locally.
- */
+    public Transporter compareObjectsDontMatch(Transporter firstObject, Transporter secondObject) {
+        return handleByMode();
+    }
 
-@Override
-public Transporter executeQuery(Transporter query)
-{
-    return handleByMode();
-}
+    /**
+     * ADVANCED:
+     * Return if their is an object for the primary key.
+     */
 
-/**
- * Get the default read-only classes
- **/
+    public Transporter containsObjectInIdentityMap(Transporter domainObject) {
+        return handleByMode();
+    }
 
-@Override
-public Transporter getDefaultReadOnlyClasses()
-{
-    return handleByMode();
-}
+    /**
+     * ADVANCED:
+     * Return if their is an object for the primary key.
+     */
 
-/**
- * Extract descriptor from the session
- */
+    public Transporter containsObjectInIdentityMap(Transporter primaryKey, Transporter theClass) {
+        return handleByMode();
+    }
 
-@Override
-public Transporter getDescriptor(Transporter theClass)
-{
-    return handleByMode();
-}
+    /**
+     * Used for closing cursored streams across RMI.
+     */
 
-/**
- * Extract descriptor from the session
- */
+    @Override
+    public Transporter cursoredStreamClose(Transporter remoteCursoredStreamID) {
+        return handleByMode();
+    }
 
-@Override
-public Transporter getDescriptorForAlias(Transporter theClass)
-{
-    return handleByMode();
-}
-/**
- * PUBLIC:
- * Return the ExceptionHandler.Exception handler can catch errors that occur on queries or during database access.
- */
+    /**
+     * Retrieve next page size of objects from the remote cursored stream
+     */
+
+    @Override
+    public Transporter cursoredStreamNextPage(Transporter remoteCursoredStream, int pageSize) {
+        return handleByMode();
+    }
+
+    /**
+     * Return the cursored stream size
+     */
+
+    @Override
+    public Transporter cursoredStreamSize(Transporter remoteCursoredStreamOid) {
+        return handleByMode();
+    }
+
+    /**
+     * Returns a remote cursor stub in a transporter
+     */
+
+    @Override
+    public Transporter cursorSelectObjects(Transporter remoteTransporter) {
+        return handleByMode();
+    }
+
+    /**
+     * A remote query after serialization is executed locally.
+     */
+
+    @Override
+    public Transporter executeNamedQuery(Transporter nameTransporter, Transporter classTransporter, Transporter argumentsTransporter) {
+        return handleByMode();
+    }
+
+    /**
+     * A remote query after serialization is executed locally.
+     */
+
+    @Override
+    public Transporter executeQuery(Transporter query) {
+        return handleByMode();
+    }
+
+    /**
+     * Get the default read-only classes
+     **/
+
+    @Override
+    public Transporter getDefaultReadOnlyClasses() {
+        return handleByMode();
+    }
+
+    /**
+     * Extract descriptor from the session
+     */
+
+    @Override
+    public Transporter getDescriptor(Transporter theClass) {
+        return handleByMode();
+    }
+
+    /**
+     * Extract descriptor from the session
+     */
+
+    @Override
+    public Transporter getDescriptorForAlias(Transporter theClass) {
+        return handleByMode();
+    }
+
+    /**
+     * PUBLIC:
+     * Return the ExceptionHandler.Exception handler can catch errors that occur on queries or during database access.
+     */
+
+    public Transporter getExceptionHandler() {
+        return handleByMode();
+    }
+
+    /**
+     * ADVANCED:
+     * Return the object from the identity with primary and class of the given object.
+     */
+
+    public Transporter getFromIdentityMap(Transporter domainObject) {
+        return handleByMode();
+    }
+
+    /**
+     * ADVANCED:
+     * Return the object from the identity with the primary and class.
+     */
+
+    public Transporter getFromIdentityMap(Transporter primaryKey, Transporter theClass) {
+        return handleByMode();
+    }
+
+    /**
+     * Get the associated session login.
+     */
+
+    @Override
+    public Transporter getLogin() {
+        return handleByMode();
+    }
+
+    /**
+     * PUBLIC:
+     * Return the profiler.
+     * The profiler is a tool that can be used to determine performance bottlenecks.
+     * The profiler can be queries to print summaries and configure for logging purposes.
+     */
+
+    public Transporter getProfiler() {
+        return handleByMode();
+    }
+
+    /**
+     * PUBLIC:
+     * Return the writer to which an accessor writes logged messages and SQL.
+     * If not set, this reference defaults to a writer on System.out.
+     * To enable logging, logMessages must be turned on.
+     */
+    public Transporter getRemoteLog() {
+        return handleByMode();
+    }
+
+    /**
+     * INTERNAL:
+     * Get the value returned by remote function call
+     */
+    @Override
+    public Transporter getSequenceNumberNamed(Transporter remoteFunctionCall) {
+        return handleByMode();
+    }
+
+    /**
+     * PUBLIC:
+     * Return the session log to which an accessor logs messages and SQL.
+     * If not set, this will default to a session log on a writer on System.out.
+     * To enable logging, logMessages must be turned on.
+     *
+     * @see #setShouldLogMessages(Transporter)
+     */
+
+    public Transporter getSessionLog() {
+        return handleByMode();
+    }
+
+    /**
+     * PUBLIC:
+     * Reset the identity map for only the instances of the class.
+     * For inheritance the user must make sure that they only use the root class.
+     * Caution must be used in doing this to ensure that the objects within the identity map
+     * are not referenced from other objects of other classes or from the application.
+     */
+
+    public Transporter initializeIdentityMap(Transporter theClass) {
+        return handleByMode();
+    }
+
+    @Override
+    public Transporter initializeIdentityMapsOnServerSession() {
+        return handleByMode();
+    }
+
+    /**
+     * The corresponding original value holder is instantiated.
+     */
+
+    @Override
+    public Transporter instantiateRemoteValueHolderOnServer(Transporter remoteValueHolder) {
+        return handleByMode();
+    }
+
+    /**
+     * Return if this session is connected.
+     */
+
+    public Transporter isConnected() {
+        return handleByMode();
+    }
+
+    /**
+     * Log the log entry.
+     */
+
+    public Transporter log(Transporter entry) {
+        return handleByMode();
+    }
+
+    /**
+     * INTERNAL:
+     * This method is used to merge the changes into the session.
+     */
+
+    public Transporter mergeChangesIntoRemoteSession(Transporter remoteTransporter) {
+        return handleByMode();
+    }
+
+    /**
+     * PUBLIC:
+     * Used to print all the objects in the identity map of the passed in class.
+     * The output of this method will go the the Session's log.
+     */
+
+    public Transporter printIdentityMap(Transporter theClass) {
+        return handleByMode();
+    }
+
+    /**
+     * PUBLIC:
+     * Used to print all the objects in every identity map in this session.
+     * The output of this method will go to the Session's log.
+     */
+
+    public Transporter printIdentityMaps() {
+        return handleByMode();
+    }
+
+    /**
+     * ADVANCED:
+     * Remove the object from the object cache.
+     * Caution should be used when calling to avoid violating object identity.
+     * The application should only call this is it knows that no references to the object exist.
+     */
+
+    public Transporter removeFromIdentityMap(Transporter domainObject) {
+        return handleByMode();
+    }
+
+    /**
+     * ADVANCED:
+     * Remove the object from the object cache.
+     * Caution should be used when calling to avoid violating object identity.
+     * The application should only call this is it knows that no references to the object exist.
+     */
+
+    public Transporter removeFromIdentityMap(Transporter key, Transporter theClass) {
+        return handleByMode();
+    }
+
+    /**
+     * Rollback a transaction on the database.
+     */
+
+    @Override
+    public Transporter rollbackTransaction() {
+        return handleByMode();
+    }
+
+    /**
+     * Moves the cursor to the given row number in the result set
+     */
+
+    @Override
+    public Transporter scrollableCursorAbsolute(Transporter remoteScrollableCursorOid, int rows) {
+        return handleByMode();
+    }
+
+    /**
+     * Moves the cursor to the end of the result set, just after the last row.
+     */
+
+    @Override
+    public Transporter scrollableCursorAfterLast(Transporter remoteScrollableCursorOid) {
+        return handleByMode();
+    }
+
+    /**
+     * Moves the cursor to the front of the result set, just before the first row
+     */
 
-public Transporter getExceptionHandler()
-{
-    return handleByMode();
-}
-/**
- * ADVANCED:
- * Return the object from the identity with primary and class of the given object.
- */
+    @Override
+    public Transporter scrollableCursorBeforeFirst(Transporter remoteScrollableCursor) {
+        return handleByMode();
+    }
 
-public Transporter getFromIdentityMap(Transporter domainObject)
-{
-    return handleByMode();
-}
-/**
- * ADVANCED:
- * Return the object from the identity with the primary and class.
- */
+    /**
+     * Used for closing scrollable cursor across RMI.
+     */
 
-public Transporter getFromIdentityMap(Transporter primaryKey, Transporter theClass)
-{
-    return handleByMode();
-}
-/**
- * Get the associated session login.
- */
+    @Override
+    public Transporter scrollableCursorClose(Transporter remoteScrollableCursorOid) {
+        return handleByMode();
+    }
 
-@Override
-public Transporter getLogin()
-{
-    return handleByMode();
-}
-/**
- * PUBLIC:
- * Return the profiler.
- * The profiler is a tool that can be used to determine performance bottlenecks.
- * The profiler can be queries to print summaries and configure for logging purposes.
- */
+    /**
+     * Retrieves the current row index number
+     */
 
-public Transporter getProfiler()
-{
-    return handleByMode();
-}
-/**
- * PUBLIC:
- * Return the writer to which an accessor writes logged messages and SQL.
- * If not set, this reference defaults to a writer on System.out.
- * To enable logging, logMessages must be turned on.
- *
- * @see #logMessages()
- */
+    @Override
+    public Transporter scrollableCursorCurrentIndex(Transporter remoteScrollableCursor) {
+        return handleByMode();
+    }
 
-public Transporter getRemoteLog()
-{
-    return handleByMode();
-}
-/**
- * INTERNAL:
- * Get the value returned by remote function call
- */
+    /**
+     * Moves the cursor to the first row in the result set
+     */
 
-@Override
-public Transporter getSequenceNumberNamed(Transporter remoteFunctionCall) {
-    return handleByMode();
-}
-/**
- * PUBLIC:
- * Return the session log to which an accessor logs messages and SQL.
- * If not set, this will default to a session log on a writer on System.out.
- * To enable logging, logMessages must be turned on.
- *
- * @see #logMessages()
- */
+    @Override
+    public Transporter scrollableCursorFirst(Transporter remoteScrollableCursor) {
+        return handleByMode();
+    }
 
-public Transporter getSessionLog()
-{
-    return handleByMode();
-}
-/**
- * PUBLIC:
- * Reset the identity map for only the instances of the class.
- * For inheritance the user must make sure that they only use the root class.
- * Caution must be used in doing this to ensure that the objects within the identity map
- * are not referenced from other objects of other classes or from the application.
- */
+    /**
+     * Indicates whether the cursor is after the last row in the result set.
+     */
 
-public Transporter initializeIdentityMap(Transporter theClass)
-{
-    return handleByMode();
-}
-@Override
-public Transporter initializeIdentityMapsOnServerSession()
-{
-    return handleByMode();
-}
-/**
- * The corresponding original value holder is instantiated.
- */
+    @Override
+    public Transporter scrollableCursorIsAfterLast(Transporter remoteScrollableCursor) {
+        return handleByMode();
+    }
 
-@Override
-public Transporter instantiateRemoteValueHolderOnServer(Transporter remoteValueHolder)
-{
-    return handleByMode();
-}
-/**
- * Return if this session is connected.
- */
+    /**
+     * Indicates whether the cursor is before the first row in the result set.
+     */
 
-public Transporter isConnected()
-{
-    return handleByMode();
-}
-/**
- * Log the log entry.
- */
+    @Override
+    public Transporter scrollableCursorIsBeforeFirst(Transporter remoteScrollableCursor) {
+        return handleByMode();
+    }
 
-public Transporter log(Transporter entry)
-{
-    return handleByMode();
-}
-/**
- * INTERNAL:
- * This method is used to merge the changes into the session.
- */
+    /**
+     * Indicates whether the cursor is on the first row of the result set.
+     */
 
-public Transporter mergeChangesIntoRemoteSession(Transporter remoteTransporter){
-    return handleByMode();
-}
-/**
- * PUBLIC:
- * Used to print all the objects in the identity map of the passed in class.
- * The output of this method will go the the Session's log.
- */
+    @Override
+    public Transporter scrollableCursorIsFirst(Transporter remoteScrollableCursor) {
+        return handleByMode();
+    }
 
-public Transporter printIdentityMap(Transporter theClass)
-{
-    return handleByMode();
-}
-/**
- * PUBLIC:
- * Used to print all the objects in every identity map in this session.
- * The output of this method will go to the Session's log.
- */
+    /**
+     * Indicates whether the cursor is on the last row of the result set.
+     */
 
-public Transporter printIdentityMaps()
-{
-    return handleByMode();
-}
-/**
- * ADVANCED:
- * Remove the object from the object cache.
- * Caution should be used when calling to avoid violating object identity.
- * The application should only call this is it knows that no references to the object exist.
- */
+    @Override
+    public Transporter scrollableCursorIsLast(Transporter remoteScrollableCursor) {
+        return handleByMode();
+    }
 
-public Transporter removeFromIdentityMap(Transporter domainObject)
-{
-    return handleByMode();
-}
-/**
- * ADVANCED:
- * Remove the object from the object cache.
- * Caution should be used when calling to avoid violating object identity.
- * The application should only call this is it knows that no references to the object exist.
- */
+    /**
+     * Moves the cursor to the last row in the result set
+     */
 
-public Transporter removeFromIdentityMap(Transporter key, Transporter theClass)
-{
-    return handleByMode();
-}
-/**
- * Rollback a transaction on the database.
- */
+    @Override
+    public Transporter scrollableCursorLast(Transporter remoteScrollableCursor) {
+        return handleByMode();
+    }
 
-@Override
-public Transporter rollbackTransaction()
-{
-    return handleByMode();
-}
-/**
- * Moves the cursor to the given row number in the result set
- */
+    /**
+     * Retrieve next object from the scrollable cursor
+     */
 
-@Override
-public Transporter scrollableCursorAbsolute(Transporter remoteScrollableCursorOid, int rows) {
-    return handleByMode();
-}
-/**
- * Moves the cursor to the end of the result set, just after the last row.
- */
+    @Override
+    public Transporter scrollableCursorNextObject(Transporter scrollableCursorOid) {
+        return handleByMode();
+    }
 
-@Override
-public Transporter scrollableCursorAfterLast(Transporter remoteScrollableCursorOid){
-    return handleByMode();
-}
-/**
- * Moves the cursor to the front of the result set, just before the first row
- */
+    /**
+     * Retrieve previous object from the scrollable cursor
+     */
 
-@Override
-public Transporter scrollableCursorBeforeFirst(Transporter remoteScrollableCursor) {
-    return handleByMode();
-}
-/**
- * Used for closing scrollable cursor across RMI.
- */
+    @Override
+    public Transporter scrollableCursorPreviousObject(Transporter scrollableCursorOid) {
+        return handleByMode();
+    }
 
-@Override
-public Transporter scrollableCursorClose(Transporter remoteScrollableCursorOid)  {
-    return handleByMode();
-}
-/**
- * Retrieves the current row index number
- */
+    /**
+     * Moves the cursor to the given row number in the result set
+     */
 
-@Override
-public Transporter scrollableCursorCurrentIndex(Transporter remoteScrollableCursor) {
-    return handleByMode();
-}
-/**
- * Moves the cursor to the first row in the result set
- */
+    @Override
+    public Transporter scrollableCursorRelative(Transporter remoteScrollableCursor, int rows) {
+        return handleByMode();
+    }
 
-@Override
-public Transporter scrollableCursorFirst(Transporter remoteScrollableCursor) {
-    return handleByMode();
-}
-/**
- * Indicates whether the cursor is after the last row in the result set.
- */
+    /**
+     * Return the cursor size
+     */
 
-@Override
-public Transporter scrollableCursorIsAfterLast(Transporter remoteScrollableCursor) {
-    return handleByMode();
-}
-/**
- * Indicates whether the cursor is before the first row in the result set.
- */
+    @Override
+    public Transporter scrollableCursorSize(Transporter remoteCursorOid) {
+        return handleByMode();
+    }
 
-@Override
-public Transporter scrollableCursorIsBeforeFirst(Transporter remoteScrollableCursor) {
-    return handleByMode();
-}
-/**
- * Indicates whether the cursor is on the first row of the result set.
- */
+    /**
+     * PUBLIC:
+     * Set the exceptionHandler.
+     * Exception handler can catch errors that occur on queries or during database access.
+     */
 
-@Override
-public Transporter scrollableCursorIsFirst(Transporter remoteScrollableCursor) {
-    return handleByMode();
-}
-/**
- * Indicates whether the cursor is on the last row of the result set.
- */
+    public Transporter setExceptionHandler(Transporter exceptionHandler) {
+        return handleByMode();
+    }
 
-@Override
-public Transporter scrollableCursorIsLast(Transporter remoteScrollableCursor)  {
-    return handleByMode();
-}
-/**
- * Moves the cursor to the last row in the result set
- */
+    /**
+     * PUBLIC:
+     * Set the writer to which an accessor writes logged messages and SQL.
+     * If not set, this reference defaults to a writer on System.out.
+     * To enable logging logMessages() is used.
+     *
+     * @see #setShouldLogMessages(Transporter)
+     */
 
-@Override
-public Transporter scrollableCursorLast(Transporter remoteScrollableCursor)  {
-    return handleByMode();
-}
-/**
- * Retrieve next object from the scrollable cursor
- */
+    public Transporter setLog(Transporter log) {
+        return handleByMode();
+    }
 
-@Override
-public Transporter scrollableCursorNextObject(Transporter scrollableCursorOid) {
-    return handleByMode();
-}
-/**
- * Retrieve previous object from the scrollable cursor
- */
+    /**
+     * INTERNAL:
+     * Set the login.
+     */
 
-@Override
-public Transporter scrollableCursorPreviousObject(Transporter scrollableCursorOid) {
-    return handleByMode();
-}
+    public Transporter setLogin(Transporter login) {
+        return handleByMode();
+    }
 
-/**
- * Moves the cursor to the given row number in the result set
- */
+    /**
+     * PUBLIC:
+     * Set the profiler for the session.
+     * This allows for performance operations to be profiled.
+     */
 
-@Override
-public Transporter scrollableCursorRelative(Transporter remoteScrollableCursor, int rows)  {
-    return handleByMode();
-}
-/**
- * Return the cursor size
- */
+    public Transporter setProfiler(Transporter profiler) {
+        return handleByMode();
+    }
 
-@Override
-public Transporter scrollableCursorSize(Transporter remoteCursorOid) {
-    return handleByMode();
-}
-/**
- * PUBLIC:
- * Set the exceptionHandler.
- * Exception handler can catch errors that occur on queries or during database access.
- */
+    /**
+     * PUBLIC:
+     * Set the session log to which an accessor logs messages and SQL.
+     * If not set, this will default to a session log on a writer on System.out.
+     * To enable logging, logMessages must be turned on.
+     *
+     * @see #setShouldLogMessages(Transporter)
+     */
 
-public Transporter setExceptionHandler(Transporter exceptionHandler)
-{
-    return handleByMode();
-}
-/**
- * PUBLIC:
- * Set the writer to which an accessor writes logged messages and SQL.
- * If not set, this reference defaults to a writer on System.out.
- * To enable logging logMessages() is used.
- *
- * @see #logMessages()
- */
+    public Transporter setSessionLog(Transporter sessionLog) {
+        return handleByMode();
+    }
 
-public Transporter setLog(Transporter log)
-{
-    return handleByMode();
-}
-/**
- * INTERNAL:
- * Set the login.
- */
+    /**
+     * PUBLIC:
+     * Set messages logging.
+     * Message logging will dump all SQL executed through TopLink to the session's
+     * log. By default this is System.out, but can be set to any Writer.
+     *
+     * @see #setLog(Transporter)
+     */
 
-public Transporter setLogin(Transporter login)
-{
-    return handleByMode();
-}
-/**
- * PUBLIC:
- * Set the profiler for the session.
- * This allows for performance operations to be profiled.
- */
+    public Transporter setShouldLogMessages(Transporter shouldLogMessages) {
+        return handleByMode();
+    }
 
-public Transporter setProfiler(Transporter profiler)
-{
-    return handleByMode();
-}
-/**
- * PUBLIC:
- * Set the session log to which an accessor logs messages and SQL.
- * If not set, this will default to a session log on a writer on System.out.
- * To enable logging, logMessages must be turned on.
- *
- * @see #logMessages()
- */
+    /**
+     * Return if all messages such as executed SQL commands should be logged.
+     */
 
-public Transporter setSessionLog(Transporter sessionLog)
-{
-    return handleByMode();
-}
-/**
- * PUBLIC:
- * Set messages logging.
- * Message logging will dump all SQL executed through TopLink to the session's
- * log. By default this is System.out, but can be set to any Writer.
- *
- * @see #setLog(Writer)
- */
+    public Transporter shouldLogMessages() {
+        return handleByMode();
+    }
 
-public Transporter setShouldLogMessages(Transporter shouldLogMessages)
-{
-    return handleByMode();
-}
-/**
- * Return if all messages such as executed SQL commands should be logged.
- */
+    /**
+     * ADVANCED:
+     * This can be used to help debugging an object identity problem.
+     * An object identity problem is when an object in the cache references an object not in the cache.
+     * This method will validate that all cached objects are in a correct state.
+     */
 
-public Transporter shouldLogMessages()
-{
-    return handleByMode();
-}
-/**
- * ADVANCED:
- * This can be used to help debugging an object identity problem.
- * An object identity problem is when an object in the cache references an object not in the cache.
- * This method will validate that all cached objects are in a correct state.
- */
+    public Transporter validateCache() {
+        return handleByMode();
+    }
 
-public Transporter validateCache()
-{
-    return handleByMode();
-}
-/**
- * INTERNAL:
- * TESTING:
- * This is used by testing code to ensure that a deletion was successful.
- */
+    /**
+     * INTERNAL:
+     * TESTING:
+     * This is used by testing code to ensure that a deletion was successful.
+     */
 
-public Transporter verifyDelete(Transporter domainObject)
-{
-    return handleByMode();
-}
+    public Transporter verifyDelete(Transporter domainObject) {
+        return handleByMode();
+    }
 }
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/transactions/ReadingThroughWriteConnectionInTransactionTest.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/transactions/ReadingThroughWriteConnectionInTransactionTest.java
index 7ba4eb8..906c408 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/transactions/ReadingThroughWriteConnectionInTransactionTest.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/transactions/ReadingThroughWriteConnectionInTransactionTest.java
@@ -22,11 +22,12 @@
 import org.eclipse.persistence.testing.models.mapping.*;
 import org.eclipse.persistence.expressions.*;
 import org.eclipse.persistence.queries.*;
+import org.eclipse.persistence.testing.tests.clientserver.ClientServerTest;
 
 /**
  * Tests using the client's write connection when in transaction to
  * maintain the proper isolation levels, even for reads.
- * @see CR#4334, SAM
+ * (see CR#4334, SAM)
  */
 public class ReadingThroughWriteConnectionInTransactionTest extends org.eclipse.persistence.testing.framework.AutoVerifyTestCase {
     protected boolean multipleClients = false;
@@ -352,7 +353,7 @@
 
     /**
      * Creates a new server session with same login and descriptors as test session.
-     * @see ClientServerTest setup()
+     * @see ClientServerTest#setup()
      */
     @Override
     public void setup() {
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/transparentindirection/ZTestSuite.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/transparentindirection/ZTestSuite.java
index 82b727d..a44f3db 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/transparentindirection/ZTestSuite.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/transparentindirection/ZTestSuite.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -62,7 +62,7 @@
     /**
      * Return an enumeration on all the method names for the
      * specified class that begin with "test", removing any duplicates.
-     * @param testCaseClass a subclass of <code>TestCase</code>
+     * @param testClass a subclass of <code>TestCase</code>
      */
     public Enumeration methodNamesStartingWithTestFor(Class testClass) {
         Method[] methods = testClass.getMethods();
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/types/CLOBTester.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/types/CLOBTester.java
index e1320a8..7bc2afc 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/types/CLOBTester.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/types/CLOBTester.java
@@ -23,7 +23,7 @@
 import org.eclipse.persistence.exceptions.*;
 
 /**
- * Tests the use of Long (> 255) strings
+ * Tests the use of Long ({@literal >} 255) strings
  */
 public class CLOBTester extends TypeTester {
     public String longString;
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/types/NumericTester.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/types/NumericTester.java
index 862b410..8fefacb 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/types/NumericTester.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/types/NumericTester.java
@@ -77,7 +77,7 @@
     /**
      * Assumes that if size is allowed that the sum of the scale and the precision
      * must be less than or equal to the maximum precision.
-     *    If building sizes it splits the number (ie. 38 -> 19,19 or 19 -> 10, 9)
+     *    If building sizes it splits the number (ie. 38 -{@literal >} 19,19 or 19 -{@literal >} 10, 9)
      */
     private static void addDoubleField(TableDefinition definition, DatabasePlatform platform) {
         FieldTypeDefinition fieldDef = platform.getFieldTypes().get(Double.class);
@@ -95,7 +95,7 @@
     /**
      * Assumes that if size is allowed that the sum of the scale and the precision
      * must be less than or equal to the maximum precision.
-     *    If building sizes it splits the number (ie. 38 -> 19,19 or 19 -> 10, 9)
+     *    If building sizes it splits the number (ie. 38 -{@literal >} 19,19 or 19 -{@literal >} 10, 9)
      */
     private static void addFloatField(TableDefinition definition, DatabasePlatform platform) {
         FieldTypeDefinition fieldDef = platform.getFieldTypes().get(Float.class);
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/types/TimeDateTester.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/types/TimeDateTester.java
index 9882e9f..1f46925 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/types/TimeDateTester.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/types/TimeDateTester.java
@@ -23,7 +23,7 @@
 import org.eclipse.persistence.testing.framework.*;
 
 /**
- * This class will test Date, Time, & Timestamp capabilities
+ * This class will test Date, Time, &amp; Timestamp capabilities
  */
 public class TimeDateTester extends TypeTester {
     public java.sql.Date sqlDate;
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/types/WriteTypeObjectTest.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/types/WriteTypeObjectTest.java
index 446cb0c..044d056 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/types/WriteTypeObjectTest.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/types/WriteTypeObjectTest.java
@@ -18,7 +18,7 @@
 
 /**
  * Custom WriteObjectTests that will allow the TypeTester object to pass through the calls to:
- * test(), setup(), & verify(). This ius required so the tests can customize according to the platform.
+ * test(), setup(), &amp; verify(). This ius required so the tests can customize according to the platform.
  */
 public class WriteTypeObjectTest extends WriteObjectTest {
 
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/unitofwork/ConcurrentAddress.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/unitofwork/ConcurrentAddress.java
index 1cd3ba3..a73c128 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/unitofwork/ConcurrentAddress.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/unitofwork/ConcurrentAddress.java
@@ -29,7 +29,7 @@
 /**
  * <p><b>Purpose</b>: Represents the mailing address on an Employee
  * <p><b>Description</b>: Held in a private 1:1 relationship from Employee
- * @see Employee
+ * @see ConcurrentPerson
  */
 public class ConcurrentAddress implements Serializable, Cloneable {
     public BigDecimal id;
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/unitofwork/ExceptionsRaisedUnitOfWorkTest.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/unitofwork/ExceptionsRaisedUnitOfWorkTest.java
index 651650e..3e9d6f1 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/unitofwork/ExceptionsRaisedUnitOfWorkTest.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/unitofwork/ExceptionsRaisedUnitOfWorkTest.java
@@ -47,6 +47,7 @@
  * <b>Paths Covered</b>: Within the unit of work, different parts listed below were set to null:
  *                                <ul>
  *                                <li>    <i>1:1 mapping, QueryException caught</i>, parents sessions address assigned to child session's employee
+ *                                </ul>
  *
  *
  *
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/unitofwork/MergeUnitOfWorkTest.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/unitofwork/MergeUnitOfWorkTest.java
index 5543d3f..94127e5 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/unitofwork/MergeUnitOfWorkTest.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/unitofwork/MergeUnitOfWorkTest.java
@@ -45,6 +45,7 @@
  * <li> <i>Address</i> 1:1 Mapping
  * <li> <i>Period</i> Simple Aggregate
  * <li> <i>NormalHours</i>
+ * </ul>
  */
 public class MergeUnitOfWorkTest extends org.eclipse.persistence.testing.framework.WriteObjectTest {
     public Object unitOfWorkWorkingCopy;
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/unitofwork/RegisterationUnitOfWorkTest.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/unitofwork/RegisterationUnitOfWorkTest.java
index 5e89e09..791df1d 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/unitofwork/RegisterationUnitOfWorkTest.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/unitofwork/RegisterationUnitOfWorkTest.java
@@ -38,10 +38,11 @@
  * <p>
  * <b>Paths Covered</b>: Within the unit of work, different parts of the employee were set with clones:
  * <ul>
- * <li><i> Think they are equal but are unequal, clones are different
- * <li> Think they are equal and are equal, clones are identical
- * <li> Think they are unequal but are equal, clones are identical
- * <li> Think they are unequal and are unequal, clones are different </i>
+ * <li> <i>Think they are equal but are unequal, clones are different</i>
+ * <li> <i>Think they are equal and are equal, clones are identical</i>
+ * <li> <i>Think they are unequal but are equal, clones are identical</i>
+ * <li> <i>Think they are unequal and are unequal, clones are different</i>
+ * </ul>
  */
 public class RegisterationUnitOfWorkTest extends WriteObjectTest {
     public Object unitOfWorkWorkingCopy;
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/unitofwork/changeflag/model/ALCTEmployee.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/unitofwork/changeflag/model/ALCTEmployee.java
index 4fdc9c1..b20ac7e 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/unitofwork/changeflag/model/ALCTEmployee.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/unitofwork/changeflag/model/ALCTEmployee.java
@@ -37,16 +37,16 @@
 public class ALCTEmployee implements Serializable, ChangeTracker {
     // implements ChangeTracker for testing
 
-    /** Primary key, maped as a direct-to-field, BigDecimal -> NUMBER, that makes use of sequence numbers to generate the id. */
+    /** Primary key, maped as a direct-to-field, BigDecimal -{@literal >} NUMBER, that makes use of sequence numbers to generate the id. */
     public BigDecimal id;
 
-    /** Direct-to-field mapping, String -> VARCHAR. */
+    /** Direct-to-field mapping, String -{@literal >} VARCHAR. */
     public String firstName;
 
-    /** Direct-to-field mapping, String -> VARCHAR. */
+    /** Direct-to-field mapping, String -{@literal >} VARCHAR. */
     public String lastName;
 
-    /** Object-type mapping, maps "Male" -> "M", "Female" -> "F". */
+    /** Object-type mapping, maps "Male" -{@literal >} "M", "Female" -{@literal >} "F". */
     public String gender;
 
     /** Aggregate-object mapping, stores the object in the employee's table. */
@@ -151,7 +151,7 @@
     }
 
     /**
-     * Print the first & last name
+     * Print the first &amp; last name
      */
     public String toString() {
         StringWriter writer = new StringWriter();
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/unitofwork/changeflag/model/ALCTEmploymentPeriod.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/unitofwork/changeflag/model/ALCTEmploymentPeriod.java
index 597d6e3..e3e4143 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/unitofwork/changeflag/model/ALCTEmploymentPeriod.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/unitofwork/changeflag/model/ALCTEmploymentPeriod.java
@@ -30,7 +30,7 @@
  * <p><b>Purpose</b>: Defines the period an Employee worked for the organization
  * <p><b>Description</b>: The period holds the start date and optionally the end date if the employee has left (null otherwise).
  * Maintained in an aggregate relationship of Employee
- * @see Employee
+ * @see ALCTEmployee
  */
 public class ALCTEmploymentPeriod implements Serializable, ChangeTracker {
     // implements ChangeTracker for testing
@@ -97,7 +97,7 @@
     }
 
     /**
-     * Print the start & end date
+     * Print the start &amp; end date
      */
     public String toString() {
         StringWriter writer = new StringWriter();
diff --git a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/unitofwork/writechanges/UnitOfWorkWriteChangesTestModel.java b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/unitofwork/writechanges/UnitOfWorkWriteChangesTestModel.java
index 24e62a6..8291fe4 100644
--- a/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/unitofwork/writechanges/UnitOfWorkWriteChangesTestModel.java
+++ b/foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/unitofwork/writechanges/UnitOfWorkWriteChangesTestModel.java
@@ -45,7 +45,7 @@
  * Intended for use with external transaction controllers, as any exception can
  * be received directly by the caller, toplink/custom exceptions are often lost
  * in the beforeCompletion/afterCompletion callbacks.
- * @see org.eclipse.persistence.testing.threetier.tests.externaltransaction For more the testing scenarios customers are likely to actually use.
+ * (see org.eclipse.persistence.testing.threetier.tests.externaltransaction For more the testing scenarios customers are likely to actually use.)
  * @see org.eclipse.persistence.sessions.UnitOfWork#writeChanges
  *  @version $Header: UnitOfWorkWriteChangesTestModel.java 17-nov-2005.13:31:29 gyorke Exp $
  *  @author  smcritch
diff --git a/foundation/eclipselink.core.test/src/test/java/org/eclipse/persistence/testing/tests/junit/helper/JavaUtilTest.java b/foundation/eclipselink.core.test/src/test/java/org/eclipse/persistence/testing/tests/junit/helper/JavaUtilTest.java
index faf8589..939d156 100644
--- a/foundation/eclipselink.core.test/src/test/java/org/eclipse/persistence/testing/tests/junit/helper/JavaUtilTest.java
+++ b/foundation/eclipselink.core.test/src/test/java/org/eclipse/persistence/testing/tests/junit/helper/JavaUtilTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -50,7 +50,7 @@
     /** Version numbers result mapping. Covers exceptions.
      * See also {@code JavaSEPlatform.stringValuesMap} initialization code
      * and {@link JavaSEPlatform#toValue(int, int)}.
-     * 1.9 -> 9.0
+     * 1.9 -{@literal >} 9.0
      * @param version source version numbers
      * @return result version numbers
      */
diff --git a/foundation/eclipselink.core.test/src/test/java/org/eclipse/persistence/testing/tests/junit/helper/JavaVersionTest.java b/foundation/eclipselink.core.test/src/test/java/org/eclipse/persistence/testing/tests/junit/helper/JavaVersionTest.java
index 34e1ce9..6d1fefd 100644
--- a/foundation/eclipselink.core.test/src/test/java/org/eclipse/persistence/testing/tests/junit/helper/JavaVersionTest.java
+++ b/foundation/eclipselink.core.test/src/test/java/org/eclipse/persistence/testing/tests/junit/helper/JavaVersionTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -44,7 +44,7 @@
 
     /**
      * Test Java version retrieval from {@code Runtime.Version}. It just calls {@code JavaVersion#runtimeVersion()} method
-     * on current Java SE when >9 and checks that no exception is thrown.
+     * on current Java SE when {@literal>}9 and checks that no exception is thrown.
      */
     @Test
     public void testRuntimeVersion() {
diff --git a/foundation/org.eclipse.persistence.corba/src/it/java/org/eclipse/persistence/testing/tests/remote/rmi/IIOP/RMIRemoteSessionControllerDispatcherForTestingExceptions.java b/foundation/org.eclipse.persistence.corba/src/it/java/org/eclipse/persistence/testing/tests/remote/rmi/IIOP/RMIRemoteSessionControllerDispatcherForTestingExceptions.java
index 15292e6..a4ed3fd 100644
--- a/foundation/org.eclipse.persistence.corba/src/it/java/org/eclipse/persistence/testing/tests/remote/rmi/IIOP/RMIRemoteSessionControllerDispatcherForTestingExceptions.java
+++ b/foundation/org.eclipse.persistence.corba/src/it/java/org/eclipse/persistence/testing/tests/remote/rmi/IIOP/RMIRemoteSessionControllerDispatcherForTestingExceptions.java
@@ -14,12 +14,13 @@
 //     Oracle - initial API and implementation from Oracle TopLink
 package org.eclipse.persistence.testing.tests.remote.rmi.IIOP;
 
-import java.rmi.RemoteException;
 import org.eclipse.persistence.internal.sessions.remote.Transporter;
-import org.eclipse.persistence.sessions.remote.rmi.iiop.RMIRemoteSessionControllerDispatcher;
 import org.eclipse.persistence.sessions.Session;
+import org.eclipse.persistence.sessions.remote.rmi.iiop.RMIRemoteSessionControllerDispatcher;
 import org.eclipse.persistence.testing.tests.remote.TransporterGenerator;
 
+import java.rmi.RemoteException;
+
 /**
  * RemoteSessionController sits between the remote session and the session. Any interaction between these two classes
  * takes place through this object. As the object extends unicast remote object it listens to only single remote session
@@ -47,8 +48,6 @@
 
     /**
      * INTERNAL: This method is intended to be used by by sessions that wish to execute a command on a remote session
-     *
-     * @param remoteCommand RemoteCommand The command to be executed on the remote session
      */
     @Override
     public Transporter processCommand(Transporter remoteTransporter) {
@@ -197,7 +196,6 @@
 
     /**
      * Get the default read-only classes
- *
      */
 
     @Override
@@ -251,8 +249,6 @@
     /**
      * PUBLIC: Return the writer to which an accessor writes logged messages and SQL. If not set, this reference
      * defaults to a writer on System.out. To enable logging, logMessages must be turned on.
-     *
-     * @see #logMessages()
      */
 
     public Transporter getRemoteLog() {
@@ -271,8 +267,6 @@
     /**
      * PUBLIC: Return the session log to which an accessor logs messages and SQL. If not set, this will default to a
      * session log on a writer on System.out. To enable logging, logMessages must be turned on.
-     *
-     * @see #logMessages()
      */
 
     public Transporter getSessionLog() {
@@ -511,8 +505,6 @@
     /**
      * PUBLIC: Set the writer to which an accessor writes logged messages and SQL. If not set, this reference defaults
      * to a writer on System.out. To enable logging logMessages() is used.
-     *
-     * @see #logMessages()
      */
 
     public Transporter setLog(Transporter log) {
@@ -538,8 +530,6 @@
     /**
      * PUBLIC: Set the session log to which an accessor logs messages and SQL. If not set, this will default to a
      * session log on a writer on System.out. To enable logging, logMessages must be turned on.
-     *
-     * @see #logMessages()
      */
 
     public Transporter setSessionLog(Transporter sessionLog) {
@@ -549,8 +539,6 @@
     /**
      * PUBLIC: Set messages logging. Message logging will dump all SQL executed through TopLink to the session's log. By
      * default this is System.out, but can be set to any Writer.
-     *
-     * @see #setLog(Writer)
      */
 
     public Transporter setShouldLogMessages(Transporter shouldLogMessages) {
diff --git a/foundation/org.eclipse.persistence.corba/src/it/java/org/eclipse/persistence/testing/tests/remote/suncorba/CORBARemoteSessionControllerDispatcherForTestingExceptions.java b/foundation/org.eclipse.persistence.corba/src/it/java/org/eclipse/persistence/testing/tests/remote/suncorba/CORBARemoteSessionControllerDispatcherForTestingExceptions.java
index 67e0d88..27c66f7 100644
--- a/foundation/org.eclipse.persistence.corba/src/it/java/org/eclipse/persistence/testing/tests/remote/suncorba/CORBARemoteSessionControllerDispatcherForTestingExceptions.java
+++ b/foundation/org.eclipse.persistence.corba/src/it/java/org/eclipse/persistence/testing/tests/remote/suncorba/CORBARemoteSessionControllerDispatcherForTestingExceptions.java
@@ -15,8 +15,8 @@
 package org.eclipse.persistence.testing.tests.remote.suncorba;
 
 import org.eclipse.persistence.internal.sessions.remote.Transporter;
-import org.eclipse.persistence.sessions.remote.corba.sun.CORBARemoteSessionControllerDispatcher;
 import org.eclipse.persistence.sessions.Session;
+import org.eclipse.persistence.sessions.remote.corba.sun.CORBARemoteSessionControllerDispatcher;
 import org.eclipse.persistence.testing.tests.remote.TransporterGenerator;
 
 /**
@@ -28,581 +28,583 @@
 public class CORBARemoteSessionControllerDispatcherForTestingExceptions extends CORBARemoteSessionControllerDispatcher {
     protected TransporterGenerator generator;
 
-public CORBARemoteSessionControllerDispatcherForTestingExceptions(Session session)
-{
-    // This call to the super is required in RMI.
-    this(session, (TransporterGenerator)session.getProperty("TransporterGenerator"));
-}
-public CORBARemoteSessionControllerDispatcherForTestingExceptions(Session session, TransporterGenerator generator)
-{
-    // This call to the super is required in RMI.
-    super(session);
-    this.controller = null;
-    this.generator = generator;
-}
+    public CORBARemoteSessionControllerDispatcherForTestingExceptions(Session session) {
+        // This call to the super is required in RMI.
+        this(session, (TransporterGenerator) session.getProperty("TransporterGenerator"));
+    }
 
-protected Transporter handleByMode() {
-    return generator.generate();
-}
+    public CORBARemoteSessionControllerDispatcherForTestingExceptions(Session session, TransporterGenerator generator) {
+        // This call to the super is required in RMI.
+        super(session);
+        this.controller = null;
+        this.generator = generator;
+    }
 
-/**
- * INTERNAL:
- * This method is intended to be used by by sessions that wish to execute a command on a
- * remote session
- * @param remoteCommand RemoteCommand The command to be executed on the remote session
- */
+    protected Transporter handleByMode() {
+        return generator.generate();
+    }
 
-@Override
-public Transporter processCommand(Transporter remoteTransporter)
-{
-    return handleByMode();
-}
+    /**
+     * INTERNAL:
+     * This method is intended to be used by by sessions that wish to execute a command on a
+     * remote session
+     */
 
-/**
- * Begin a transaction on the database.
- */
+    @Override
+    public Transporter processCommand(Transporter remoteTransporter) {
+        return handleByMode();
+    }
 
-@Override
-public Transporter beginTransaction()
-{
-    return handleByMode();
-}
+    /**
+     * Begin a transaction on the database.
+     */
 
-/**
- * Begin a transaction on the database.
- */
+    @Override
+    public Transporter beginTransaction() {
+        return handleByMode();
+    }
 
-@Override
-public Transporter beginEarlyTransaction()
-{
-    return handleByMode();
-}
-/**
- * Remote unit of work after serialization is commited locally.
- */
+    /**
+     * Begin a transaction on the database.
+     */
 
-@Override
-public Transporter commitRootUnitOfWork(Transporter remoteUnitOfWork)
-{
-    return handleByMode();
-}
-/**
- * Commit a transaction on the database.
- */
+    @Override
+    public Transporter beginEarlyTransaction() {
+        return handleByMode();
+    }
 
-@Override
-public Transporter commitTransaction()
-{
-    return handleByMode();
-}
-/**
- * TESTING:
- * Return if the two object match completely.
- * This checks the objects attributes and their private parts.
- */
+    /**
+     * Remote unit of work after serialization is commited locally.
+     */
 
-public Transporter compareObjects(Transporter firstObject, Transporter secondObject)
-{
-    return handleByMode();
-}
-/**
- * TESTING:
- * Return true if the object do not match.
- * This checks the objects attributes and their private parts.
- */
+    @Override
+    public Transporter commitRootUnitOfWork(Transporter remoteUnitOfWork) {
+        return handleByMode();
+    }
 
-public Transporter compareObjectsDontMatch(Transporter firstObject, Transporter secondObject)
-{
-    return handleByMode();
-}
-/**
- * ADVANCED:
- * Return if their is an object for the primary key.
- */
+    /**
+     * Commit a transaction on the database.
+     */
 
-public Transporter containsObjectInIdentityMap__oracle_toplink_internal_remote_Transporter(Transporter domainObject)
-{
-    return handleByMode();
-}
-/**
- * ADVANCED:
- * Return if their is an object for the primary key.
- */
+    @Override
+    public Transporter commitTransaction() {
+        return handleByMode();
+    }
 
-public Transporter containsObjectInIdentityMap__oracle_toplink_internal_remote_Transporter__oracle_toplink_internal_remote_Transporter(Transporter primaryKey, Transporter theClass)
-{
-    return handleByMode();
-}
-/**
- * Used for closing cursored streams across RMI.
- */
+    /**
+     * TESTING:
+     * Return if the two object match completely.
+     * This checks the objects attributes and their private parts.
+     */
 
-@Override
-public Transporter cursoredStreamClose(Transporter remoteCursoredStreamID) {
-    return handleByMode();
-}
-/**
- * Retrieve next page size of objects from the remote cursored stream
- */
+    public Transporter compareObjects(Transporter firstObject, Transporter secondObject) {
+        return handleByMode();
+    }
 
-@Override
-public Transporter cursoredStreamNextPage(Transporter remoteCursoredStream, int pageSize) {
-    return handleByMode();
-}
-/**
- * Return the cursored stream size
- */
+    /**
+     * TESTING:
+     * Return true if the object do not match.
+     * This checks the objects attributes and their private parts.
+     */
 
-@Override
-public Transporter cursoredStreamSize(Transporter remoteCursoredStreamOid) {
-    return handleByMode();
-}
-/**
- * Returns a remote cursor stub in a transporter
- */
+    public Transporter compareObjectsDontMatch(Transporter firstObject, Transporter secondObject) {
+        return handleByMode();
+    }
 
-@Override
-public Transporter cursorSelectObjects(Transporter remoteTransporter)
-{
-    return handleByMode();
-}
-/**
- * A remote query after serialization is executed locally.
- */
+    /**
+     * ADVANCED:
+     * Return if their is an object for the primary key.
+     */
 
-@Override
-public Transporter executeNamedQuery(Transporter nameTransporter, Transporter classTransporter, Transporter argumentsTransporter)
-{
-    return handleByMode();
-}
-/**
- * A remote query after serialization is executed locally.
- */
+    public Transporter containsObjectInIdentityMap__oracle_toplink_internal_remote_Transporter(Transporter domainObject) {
+        return handleByMode();
+    }
 
-@Override
-public Transporter executeQuery(Transporter query)
-{
-    return handleByMode();
-}
-/**
- * Extract descriptor from the session
- */
+    /**
+     * ADVANCED:
+     * Return if their is an object for the primary key.
+     */
 
-@Override
-public Transporter getDescriptor(Transporter theClass)
-{
-    return handleByMode();
-}
-/**
- * Extract descriptor from the session
- */
+    public Transporter containsObjectInIdentityMap__oracle_toplink_internal_remote_Transporter__oracle_toplink_internal_remote_Transporter(Transporter primaryKey, Transporter theClass) {
+        return handleByMode();
+    }
 
-@Override
-public Transporter getDescriptorForAlias(Transporter theClass)
-{
-    return handleByMode();
-}
+    /**
+     * Used for closing cursored streams across RMI.
+     */
 
-/**
- * Get the default read-only classes
- **/
+    @Override
+    public Transporter cursoredStreamClose(Transporter remoteCursoredStreamID) {
+        return handleByMode();
+    }
 
-@Override
-public Transporter getDefaultReadOnlyClasses()
-{
-    return handleByMode();
-}
-/**
- * PUBLIC:
- * Return the ExceptionHandler.Exception handler can catch errors that occur on queries or during database access.
- */
+    /**
+     * Retrieve next page size of objects from the remote cursored stream
+     */
+
+    @Override
+    public Transporter cursoredStreamNextPage(Transporter remoteCursoredStream, int pageSize) {
+        return handleByMode();
+    }
+
+    /**
+     * Return the cursored stream size
+     */
+
+    @Override
+    public Transporter cursoredStreamSize(Transporter remoteCursoredStreamOid) {
+        return handleByMode();
+    }
+
+    /**
+     * Returns a remote cursor stub in a transporter
+     */
+
+    @Override
+    public Transporter cursorSelectObjects(Transporter remoteTransporter) {
+        return handleByMode();
+    }
+
+    /**
+     * A remote query after serialization is executed locally.
+     */
+
+    @Override
+    public Transporter executeNamedQuery(Transporter nameTransporter, Transporter classTransporter, Transporter argumentsTransporter) {
+        return handleByMode();
+    }
+
+    /**
+     * A remote query after serialization is executed locally.
+     */
+
+    @Override
+    public Transporter executeQuery(Transporter query) {
+        return handleByMode();
+    }
+
+    /**
+     * Extract descriptor from the session
+     */
+
+    @Override
+    public Transporter getDescriptor(Transporter theClass) {
+        return handleByMode();
+    }
+
+    /**
+     * Extract descriptor from the session
+     */
+
+    @Override
+    public Transporter getDescriptorForAlias(Transporter theClass) {
+        return handleByMode();
+    }
+
+    /**
+     * Get the default read-only classes
+     **/
+
+    @Override
+    public Transporter getDefaultReadOnlyClasses() {
+        return handleByMode();
+    }
+
+    /**
+     * PUBLIC:
+     * Return the ExceptionHandler.Exception handler can catch errors that occur on queries or during database access.
+     */
+
+    public Transporter getExceptionHandler() {
+        return handleByMode();
+    }
+
+    /**
+     * ADVANCED:
+     * Return the object from the identity with primary and class of the given object.
+     */
+
+    public Transporter getFromIdentityMap__oracle_toplink_internal_remote_Transporter(Transporter domainObject) {
+        return handleByMode();
+    }
+
+    /**
+     * ADVANCED:
+     * Return the object from the identity with the primary and class.
+     */
+
+    public Transporter getFromIdentityMap__oracle_toplink_internal_remote_Transporter__oracle_toplink_internal_remote_Transporter(Transporter primaryKey, Transporter theClass) {
+        return handleByMode();
+    }
+
+    /**
+     * Get the associated session login.
+     */
+
+    @Override
+    public Transporter getLogin() {
+        return handleByMode();
+    }
+
+    /**
+     * PUBLIC:
+     * Return the profiler.
+     * The profiler is a tool that can be used to determine performance bottlenecks.
+     * The profiler can be queries to print summaries and configure for logging purposes.
+     */
+
+    public Transporter getProfiler() {
+        return handleByMode();
+    }
+
+    /**
+     * PUBLIC:
+     * Return the writer to which an accessor writes logged messages and SQL.
+     * If not set, this reference defaults to a writer on System.out.
+     * To enable logging, logMessages must be turned on.
+     */
+
+    public Transporter getRemoteLog() {
+        return handleByMode();
+    }
+
+    /**
+     * INTERNAL:
+     * Get the value returned by remote function call
+     */
+
+    @Override
+    public Transporter getSequenceNumberNamed(Transporter remoteFunctionCall) {
+        return handleByMode();
+    }
+
+    /**
+     * PUBLIC:
+     * Return the session log to which an accessor logs messages and SQL.
+     * If not set, this will default to a session log on a writer on System.out.
+     * To enable logging, logMessages must be turned on.
+     */
+
+    public Transporter getSessionLog() {
+        return handleByMode();
+    }
+
+    /**
+     * PUBLIC:
+     * Reset the identity map for only the instances of the class.
+     * For inheritance the user must make sure that they only use the root class.
+     * Caution must be used in doing this to ensure that the objects within the identity map
+     * are not referenced from other objects of other classes or from the application.
+     */
+
+    public Transporter initializeIdentityMap(Transporter theClass) {
+        return handleByMode();
+    }
+
+    @Override
+    public Transporter initializeIdentityMapsOnServerSession() {
+        return handleByMode();
+    }
+
+    /**
+     * The corresponding original value holder is instantiated.
+     */
+
+    @Override
+    public Transporter instantiateRemoteValueHolderOnServer(Transporter remoteValueHolder) {
+        return handleByMode();
+    }
+
+    /**
+     * Return if this session is connected.
+     */
+
+    public Transporter isConnected() {
+        return handleByMode();
+    }
+
+    /**
+     * Log the log entry.
+     */
+
+    public Transporter log(Transporter entry) {
+        return handleByMode();
+    }
+
+    /**
+     * PUBLIC:
+     * Used to print all the objects in the identity map of the passed in class.
+     * The output of this method will go the the Session's log.
+     */
+
+    public Transporter printIdentityMap(Transporter theClass) {
+        return handleByMode();
+    }
+
+    /**
+     * PUBLIC:
+     * Used to print all the objects in every identity map in this session.
+     * The output of this method will go to the Session's log.
+     */
+
+    public Transporter printIdentityMaps() {
+        return handleByMode();
+    }
+
+    /**
+     * ADVANCED:
+     * Remove the object from the object cache.
+     * Caution should be used when calling to avoid violating object identity.
+     * The application should only call this is it knows that no references to the object exist.
+     */
+
+    public Transporter removeFromIdentityMap__oracle_toplink_internal_remote_Transporter(Transporter domainObject) {
+        return handleByMode();
+    }
+
+    /**
+     * ADVANCED:
+     * Remove the object from the object cache.
+     * Caution should be used when calling to avoid violating object identity.
+     * The application should only call this is it knows that no references to the object exist.
+     */
+
+    public Transporter removeFromIdentityMap__oracle_toplink_internal_remote_Transporter__oracle_toplink_internal_remote_Transporter(Transporter key, Transporter theClass) {
+        return handleByMode();
+    }
+
+    /**
+     * Rollback a transaction on the database.
+     */
+
+    @Override
+    public Transporter rollbackTransaction() {
+        return handleByMode();
+    }
+
+    /**
+     * Moves the cursor to the given row number in the result set
+     */
+
+    @Override
+    public Transporter scrollableCursorAbsolute(Transporter remoteScrollableCursorOid, int rows) {
+        return handleByMode();
+    }
+
+    /**
+     * Moves the cursor to the end of the result set, just after the last row.
+     */
+
+    @Override
+    public Transporter scrollableCursorAfterLast(Transporter remoteScrollableCursorOid) {
+        return handleByMode();
+    }
+
+    /**
+     * Moves the cursor to the front of the result set, just before the first row
+     */
+
+    @Override
+    public Transporter scrollableCursorBeforeFirst(Transporter remoteScrollableCursor) {
+        return handleByMode();
+    }
 
-public Transporter getExceptionHandler()
-{
-    return handleByMode();
-}
-/**
- * ADVANCED:
- * Return the object from the identity with primary and class of the given object.
- */
+    /**
+     * Used for closing scrollable cursor across RMI.
+     */
 
-public Transporter getFromIdentityMap__oracle_toplink_internal_remote_Transporter(Transporter domainObject)
-{
-    return handleByMode();
-}
-/**
- * ADVANCED:
- * Return the object from the identity with the primary and class.
- */
+    @Override
+    public Transporter scrollableCursorClose(Transporter remoteScrollableCursorOid) {
+        return handleByMode();
+    }
 
-public Transporter getFromIdentityMap__oracle_toplink_internal_remote_Transporter__oracle_toplink_internal_remote_Transporter(Transporter primaryKey, Transporter theClass)
-{
-    return handleByMode();
-}
-/**
- * Get the associated session login.
- */
+    /**
+     * Retrieves the current row index number
+     */
 
-@Override
-public Transporter getLogin()
-{
-    return handleByMode();
-}
-/**
- * PUBLIC:
- * Return the profiler.
- * The profiler is a tool that can be used to determine performance bottlenecks.
- * The profiler can be queries to print summaries and configure for logging purposes.
- */
+    @Override
+    public Transporter scrollableCursorCurrentIndex(Transporter remoteScrollableCursor) {
+        return handleByMode();
+    }
 
-public Transporter getProfiler()
-{
-    return handleByMode();
-}
-/**
- * PUBLIC:
- * Return the writer to which an accessor writes logged messages and SQL.
- * If not set, this reference defaults to a writer on System.out.
- * To enable logging, logMessages must be turned on.
- *
- * @see #logMessages()
- */
+    /**
+     * Moves the cursor to the first row in the result set
+     */
 
-public Transporter getRemoteLog()
-{
-    return handleByMode();
-}
-/**
- * INTERNAL:
- * Get the value returned by remote function call
- */
+    @Override
+    public Transporter scrollableCursorFirst(Transporter remoteScrollableCursor) {
+        return handleByMode();
+    }
 
-@Override
-public Transporter getSequenceNumberNamed(Transporter remoteFunctionCall) {
-    return handleByMode();
-}
-/**
- * PUBLIC:
- * Return the session log to which an accessor logs messages and SQL.
- * If not set, this will default to a session log on a writer on System.out.
- * To enable logging, logMessages must be turned on.
- *
- * @see #logMessages()
- */
+    /**
+     * Indicates whether the cursor is after the last row in the result set.
+     */
 
-public Transporter getSessionLog()
-{
-    return handleByMode();
-}
-/**
- * PUBLIC:
- * Reset the identity map for only the instances of the class.
- * For inheritance the user must make sure that they only use the root class.
- * Caution must be used in doing this to ensure that the objects within the identity map
- * are not referenced from other objects of other classes or from the application.
- */
+    @Override
+    public Transporter scrollableCursorIsAfterLast(Transporter remoteScrollableCursor) {
+        return handleByMode();
+    }
 
-public Transporter initializeIdentityMap(Transporter theClass)
-{
-    return handleByMode();
-}
-@Override
-public Transporter initializeIdentityMapsOnServerSession()
-{
-    return handleByMode();
-}
-/**
- * The corresponding original value holder is instantiated.
- */
+    /**
+     * Indicates whether the cursor is before the first row in the result set.
+     */
 
-@Override
-public Transporter instantiateRemoteValueHolderOnServer(Transporter remoteValueHolder)
-{
-    return handleByMode();
-}
-/**
- * Return if this session is connected.
- */
+    @Override
+    public Transporter scrollableCursorIsBeforeFirst(Transporter remoteScrollableCursor) {
+        return handleByMode();
+    }
 
-public Transporter isConnected()
-{
-    return handleByMode();
-}
-/**
- * Log the log entry.
- */
+    /**
+     * Indicates whether the cursor is on the first row of the result set.
+     */
 
-public Transporter log(Transporter entry)
-{
-    return handleByMode();
-}
+    @Override
+    public Transporter scrollableCursorIsFirst(Transporter remoteScrollableCursor) {
+        return handleByMode();
+    }
 
-/**
- * PUBLIC:
- * Used to print all the objects in the identity map of the passed in class.
- * The output of this method will go the the Session's log.
- */
+    /**
+     * Indicates whether the cursor is on the last row of the result set.
+     */
 
-public Transporter printIdentityMap(Transporter theClass)
-{
-    return handleByMode();
-}
-/**
- * PUBLIC:
- * Used to print all the objects in every identity map in this session.
- * The output of this method will go to the Session's log.
- */
+    @Override
+    public Transporter scrollableCursorIsLast(Transporter remoteScrollableCursor) {
+        return handleByMode();
+    }
 
-public Transporter printIdentityMaps()
-{
-    return handleByMode();
-}
-/**
- * ADVANCED:
- * Remove the object from the object cache.
- * Caution should be used when calling to avoid violating object identity.
- * The application should only call this is it knows that no references to the object exist.
- */
+    /**
+     * Moves the cursor to the last row in the result set
+     */
 
-public Transporter removeFromIdentityMap__oracle_toplink_internal_remote_Transporter(Transporter domainObject)
-{
-    return handleByMode();
-}
-/**
- * ADVANCED:
- * Remove the object from the object cache.
- * Caution should be used when calling to avoid violating object identity.
- * The application should only call this is it knows that no references to the object exist.
- */
+    @Override
+    public Transporter scrollableCursorLast(Transporter remoteScrollableCursor) {
+        return handleByMode();
+    }
 
-public Transporter removeFromIdentityMap__oracle_toplink_internal_remote_Transporter__oracle_toplink_internal_remote_Transporter(Transporter key, Transporter theClass)
-{
-    return handleByMode();
-}
-/**
- * Rollback a transaction on the database.
- */
+    /**
+     * Retrieve next object from the scrollable cursor
+     */
 
-@Override
-public Transporter rollbackTransaction()
-{
-    return handleByMode();
-}
-/**
- * Moves the cursor to the given row number in the result set
- */
+    @Override
+    public Transporter scrollableCursorNextObject(Transporter scrollableCursorOid) {
+        return handleByMode();
+    }
 
-@Override
-public Transporter scrollableCursorAbsolute(Transporter remoteScrollableCursorOid, int rows) {
-    return handleByMode();
-}
-/**
- * Moves the cursor to the end of the result set, just after the last row.
- */
+    /**
+     * Retrieve previous object from the scrollable cursor
+     */
 
-@Override
-public Transporter scrollableCursorAfterLast(Transporter remoteScrollableCursorOid){
-    return handleByMode();
-}
-/**
- * Moves the cursor to the front of the result set, just before the first row
- */
+    @Override
+    public Transporter scrollableCursorPreviousObject(Transporter scrollableCursorOid) {
+        return handleByMode();
+    }
 
-@Override
-public Transporter scrollableCursorBeforeFirst(Transporter remoteScrollableCursor) {
-    return handleByMode();
-}
-/**
- * Used for closing scrollable cursor across RMI.
- */
+    /**
+     * Moves the cursor to the given row number in the result set
+     */
 
-@Override
-public Transporter scrollableCursorClose(Transporter remoteScrollableCursorOid)  {
-    return handleByMode();
-}
-/**
- * Retrieves the current row index number
- */
+    @Override
+    public Transporter scrollableCursorRelative(Transporter remoteScrollableCursor, int rows) {
+        return handleByMode();
+    }
 
-@Override
-public Transporter scrollableCursorCurrentIndex(Transporter remoteScrollableCursor) {
-    return handleByMode();
-}
-/**
- * Moves the cursor to the first row in the result set
- */
+    /**
+     * Return the cursor size
+     */
 
-@Override
-public Transporter scrollableCursorFirst(Transporter remoteScrollableCursor) {
-    return handleByMode();
-}
-/**
- * Indicates whether the cursor is after the last row in the result set.
- */
+    @Override
+    public Transporter scrollableCursorSize(Transporter remoteCursorOid) {
+        return handleByMode();
+    }
 
-@Override
-public Transporter scrollableCursorIsAfterLast(Transporter remoteScrollableCursor) {
-    return handleByMode();
-}
-/**
- * Indicates whether the cursor is before the first row in the result set.
- */
+    /**
+     * PUBLIC:
+     * Set the exceptionHandler.
+     * Exception handler can catch errors that occur on queries or during database access.
+     */
 
-@Override
-public Transporter scrollableCursorIsBeforeFirst(Transporter remoteScrollableCursor) {
-    return handleByMode();
-}
-/**
- * Indicates whether the cursor is on the first row of the result set.
- */
+    public Transporter setExceptionHandler(Transporter exceptionHandler) {
+        return handleByMode();
+    }
 
-@Override
-public Transporter scrollableCursorIsFirst(Transporter remoteScrollableCursor) {
-    return handleByMode();
-}
-/**
- * Indicates whether the cursor is on the last row of the result set.
- */
+    /**
+     * PUBLIC:
+     * Set the writer to which an accessor writes logged messages and SQL.
+     * If not set, this reference defaults to a writer on System.out.
+     * To enable logging logMessages() is used.
+     */
 
-@Override
-public Transporter scrollableCursorIsLast(Transporter remoteScrollableCursor)  {
-    return handleByMode();
-}
-/**
- * Moves the cursor to the last row in the result set
- */
+    public Transporter setLog(Transporter log) {
+        return handleByMode();
+    }
 
-@Override
-public Transporter scrollableCursorLast(Transporter remoteScrollableCursor)  {
-    return handleByMode();
-}
-/**
- * Retrieve next object from the scrollable cursor
- */
+    /**
+     * INTERNAL:
+     * Set the login.
+     */
 
-@Override
-public Transporter scrollableCursorNextObject(Transporter scrollableCursorOid) {
-    return handleByMode();
-}
-/**
- * Retrieve previous object from the scrollable cursor
- */
+    public Transporter setLogin(Transporter login) {
+        return handleByMode();
+    }
 
-@Override
-public Transporter scrollableCursorPreviousObject(Transporter scrollableCursorOid) {
-    return handleByMode();
-}
-/**
- * Moves the cursor to the given row number in the result set
- */
+    /**
+     * PUBLIC:
+     * Set the profiler for the session.
+     * This allows for performance operations to be profiled.
+     */
 
-@Override
-public Transporter scrollableCursorRelative(Transporter remoteScrollableCursor, int rows)  {
-    return handleByMode();
-}
-/**
- * Return the cursor size
- */
+    public Transporter setProfiler(Transporter profiler) {
+        return handleByMode();
+    }
 
-@Override
-public Transporter scrollableCursorSize(Transporter remoteCursorOid) {
-    return handleByMode();
-}
-/**
- * PUBLIC:
- * Set the exceptionHandler.
- * Exception handler can catch errors that occur on queries or during database access.
- */
+    /**
+     * PUBLIC:
+     * Set the session log to which an accessor logs messages and SQL.
+     * If not set, this will default to a session log on a writer on System.out.
+     * To enable logging, logMessages must be turned on.
+     */
 
-public Transporter setExceptionHandler(Transporter exceptionHandler)
-{
-    return handleByMode();
-}
-/**
- * PUBLIC:
- * Set the writer to which an accessor writes logged messages and SQL.
- * If not set, this reference defaults to a writer on System.out.
- * To enable logging logMessages() is used.
- *
- * @see #logMessages()
- */
+    public Transporter setSessionLog(Transporter sessionLog) {
+        return handleByMode();
+    }
 
-public Transporter setLog(Transporter log)
-{
-    return handleByMode();
-}
-/**
- * INTERNAL:
- * Set the login.
- */
+    /**
+     * PUBLIC:
+     * Set messages logging.
+     * Message logging will dump all SQL executed through TopLink to the session's
+     * log. By default this is System.out, but can be set to any Writer.
+     */
 
-public Transporter setLogin(Transporter login)
-{
-    return handleByMode();
-}
-/**
- * PUBLIC:
- * Set the profiler for the session.
- * This allows for performance operations to be profiled.
- */
+    public Transporter setShouldLogMessages(Transporter shouldLogMessages) {
+        return handleByMode();
+    }
 
-public Transporter setProfiler(Transporter profiler)
-{
-    return handleByMode();
-}
-/**
- * PUBLIC:
- * Set the session log to which an accessor logs messages and SQL.
- * If not set, this will default to a session log on a writer on System.out.
- * To enable logging, logMessages must be turned on.
- *
- * @see #logMessages()
- */
+    /**
+     * Return if all messages such as executed SQL commands should be logged.
+     */
 
-public Transporter setSessionLog(Transporter sessionLog)
-{
-    return handleByMode();
-}
-/**
- * PUBLIC:
- * Set messages logging.
- * Message logging will dump all SQL executed through TopLink to the session's
- * log. By default this is System.out, but can be set to any Writer.
- *
- * @see #setLog(Writer)
- */
+    public Transporter shouldLogMessages() {
+        return handleByMode();
+    }
 
-public Transporter setShouldLogMessages(Transporter shouldLogMessages)
-{
-    return handleByMode();
-}
-/**
- * Return if all messages such as executed SQL commands should be logged.
- */
+    /**
+     * ADVANCED:
+     * This can be used to help debugging an object identity problem.
+     * An object identity problem is when an object in the cache references an object not in the cache.
+     * This method will validate that all cached objects are in a correct state.
+     */
 
-public Transporter shouldLogMessages()
-{
-    return handleByMode();
-}
-/**
- * ADVANCED:
- * This can be used to help debugging an object identity problem.
- * An object identity problem is when an object in the cache references an object not in the cache.
- * This method will validate that all cached objects are in a correct state.
- */
+    public Transporter validateCache() {
+        return handleByMode();
+    }
 
-public Transporter validateCache()
-{
-    return handleByMode();
-}
-/**
- * INTERNAL:
- * TESTING:
- * This is used by testing code to ensure that a deletion was successful.
- */
+    /**
+     * INTERNAL:
+     * TESTING:
+     * This is used by testing code to ensure that a deletion was successful.
+     */
 
-public Transporter verifyDelete(Transporter domainObject)
-{
-    return handleByMode();
-}
+    public Transporter verifyDelete(Transporter domainObject) {
+        return handleByMode();
+    }
 }
diff --git a/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/testing/framework/JUnitTestCase.java b/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/testing/framework/JUnitTestCase.java
index eb38366..fcb84e6 100644
--- a/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/testing/framework/JUnitTestCase.java
+++ b/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/testing/framework/JUnitTestCase.java
@@ -19,7 +19,7 @@
 import java.util.Vector;
 
 /**
- * <p>Purpose<b></b>:This is a JUnit Test wrapper for TopLink.
+ * <p><b>Purpose</b>:This is a JUnit Test wrapper for TopLink.
  * It simply calls the method corresponding to the test name.
  * Setup: Performs setUp().
  * Test: Runs the named Test.
diff --git a/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/testing/framework/ManualVerifyTestCase.java b/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/testing/framework/ManualVerifyTestCase.java
index 1ae8a7a..14ab03e 100644
--- a/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/testing/framework/ManualVerifyTestCase.java
+++ b/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/testing/framework/ManualVerifyTestCase.java
@@ -17,7 +17,7 @@
 import org.eclipse.persistence.logging.SessionLog;
 
 /**
- * <p>Purpose<b></b>:All the test cases are subclassed from this class. Each test case tests single
+ * <p><b>Purpose</b>:All the test cases are subclassed from this class. Each test case tests single
  * feature of TopLink. Ideally a test case consists of five steps.
  * Setup: Performs all the initial setup that is required by the test, such as setting
  *              up database to some state on which test would run.
diff --git a/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/testing/framework/TestCase.java b/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/testing/framework/TestCase.java
index 1f3ba6b..0d3761f 100644
--- a/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/testing/framework/TestCase.java
+++ b/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/testing/framework/TestCase.java
@@ -29,7 +29,7 @@
 import org.eclipse.persistence.sessions.server.ServerSession;
 
 /**
- * <p>Purpose<b></b>:
+ * <p><b>Purpose</b>:
  * All the test cases are subclassed from this class.
  * Each test case tests single feature of TopLink. Ideally a test case consists of five steps.
  * Setup: Performs all the initial setup that is required by the test,
diff --git a/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/testing/framework/TestCollection.java b/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/testing/framework/TestCollection.java
index ee594af..e6b2796 100644
--- a/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/testing/framework/TestCollection.java
+++ b/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/testing/framework/TestCollection.java
@@ -21,7 +21,7 @@
 import org.eclipse.persistence.sessions.*;
 
 /**
- * <p>Purpose<b></b>: TestCollection is a collection of test suites and models. When a test collection is executed
+ * <p><b>Purpose</b>: TestCollection is a collection of test suites and models. When a test collection is executed
  * all the test entities registered with it are executed one by one.
  */
 public abstract class TestCollection extends junit.framework.TestSuite implements TestEntity {
diff --git a/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/testing/framework/TestVariation.java b/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/testing/framework/TestVariation.java
index e11984e..1fdf031 100644
--- a/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/testing/framework/TestVariation.java
+++ b/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/testing/framework/TestVariation.java
@@ -20,7 +20,7 @@
 import java.util.Vector;
 
 /**
- * <p>Purpose<b></b>:Creates several variations of the passed TestCase
+ * <p><b>Purpose</b>:Creates several variations of the passed TestCase
  * (or of each member of a Vector of TestCases) using all combinations
  * of values of the specified boolean attributes on the specified object.
  * Suppose we want to run an existing test with four different DatabasePlatform settings:
diff --git a/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/testing/framework/TestWrapper.java b/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/testing/framework/TestWrapper.java
index 188b263..0099c9b 100644
--- a/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/testing/framework/TestWrapper.java
+++ b/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/testing/framework/TestWrapper.java
@@ -16,7 +16,7 @@
 
 
 /**
- * <p>Purpose<b></b>:A wrapper around TestCase.
+ * <p><b>Purpose</b>:A wrapper around TestCase.
  * Use it to aggregate test instead of inheriting from it.
  * Suppose we need to amend in the same way
  * setup and reset for unspecified number of TestCase's subclasses.
diff --git a/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/testing/framework/WriteObjectTest.java b/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/testing/framework/WriteObjectTest.java
index 68116ae..9b15d5c 100644
--- a/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/testing/framework/WriteObjectTest.java
+++ b/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/testing/framework/WriteObjectTest.java
@@ -119,7 +119,7 @@
          * Not a primary key mapping
          * Must be direct to field
          * Must be a string field
-         * Must not have a converter (i.e. Male-->M, Female-->F, Unknown-->U)
+         * Must not have a converter (i.e. Male--{@literal >}M, Female--{@literal >}F, Unknown--{@literal >}U)
          * The loop exits once an appropriate mapping is found or the list of
          * mappings has been fully parsed (whichever occurs first)
          */
diff --git a/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/testing/framework/ui/LoadBuildBrowserFrame.java b/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/testing/framework/ui/LoadBuildBrowserFrame.java
index 359bc24..944d22a 100644
--- a/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/testing/framework/ui/LoadBuildBrowserFrame.java
+++ b/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/testing/framework/ui/LoadBuildBrowserFrame.java
@@ -199,7 +199,7 @@
     }
 
     /**
-     * connEtoC1:  (QueryButton.action.actionPerformed(java.awt.event.ActionEvent) --> LoadBuildBrowserFrame.query()V)
+     * connEtoC1:  (QueryButton.action.actionPerformed(java.awt.event.ActionEvent) --{@literal >} LoadBuildBrowserFrame.query()V)
      * @param arg1 java.awt.event.ActionEvent
      */
     private void connEtoC1(java.awt.event.ActionEvent arg1) {
@@ -211,7 +211,7 @@
     }
 
     /**
-     * connEtoC2:  (BetweenCheckBox1.change.stateChanged(javax.swing.event.ChangeEvent) --> LoadBuildBrowserFrame.setComponentStates()V)
+     * connEtoC2:  (BetweenCheckBox1.change.stateChanged(javax.swing.event.ChangeEvent) --{@literal >} LoadBuildBrowserFrame.setComponentStates()V)
      * @param arg1 javax.swing.event.ChangeEvent
      */
     private void connEtoC2(javax.swing.event.ChangeEvent arg1) {
@@ -223,7 +223,7 @@
     }
 
     /**
-     * connEtoC3:  (TesterCheckBox1.change.stateChanged(javax.swing.event.ChangeEvent) --> LoadBuildBrowserFrame.testerChange(Ljavax.swing.event.ChangeEvent;)V)
+     * connEtoC3:  (TesterCheckBox1.change.stateChanged(javax.swing.event.ChangeEvent) --{@literal >} LoadBuildBrowserFrame.testerChange(Ljavax.swing.event.ChangeEvent;)V)
      * @param arg1 javax.swing.event.ChangeEvent
      */
     private void connEtoC3(javax.swing.event.ChangeEvent arg1) {
@@ -235,7 +235,7 @@
     }
 
     /**
-     * connEtoC4:  (LoadBuildBrowserFrame.window.windowClosing(java.awt.event.WindowEvent) --> LoadBuildBrowserFrame.loadBuildBrowserFrame_WindowClosing()V)
+     * connEtoC4:  (LoadBuildBrowserFrame.window.windowClosing(java.awt.event.WindowEvent) --{@literal >} LoadBuildBrowserFrame.loadBuildBrowserFrame_WindowClosing()V)
      * @param arg1 java.awt.event.WindowEvent
      */
 
@@ -256,7 +256,7 @@
     }
 
     /**
-     * connEtoC5:  (LogMessageCheckBox.item.itemStateChanged(java.awt.event.ItemEvent) --> LoadBuildBrowserFrame.logMessageCheckBoxhanged()V)
+     * connEtoC5:  (LogMessageCheckBox.item.itemStateChanged(java.awt.event.ItemEvent) --{@literal >} LoadBuildBrowserFrame.logMessageCheckBoxhanged()V)
      * @param arg1 java.awt.event.ItemEvent
      */
 
@@ -277,7 +277,7 @@
     }
 
     /**
-     * connEtoC6:  (InCheckBox.change.stateChanged(javax.swing.event.ChangeEvent) --> LoadBuildBrowserFrame.setComponentStates()V)
+     * connEtoC6:  (InCheckBox.change.stateChanged(javax.swing.event.ChangeEvent) --{@literal >} LoadBuildBrowserFrame.setComponentStates()V)
      * @param arg1 javax.swing.event.ChangeEvent
      */
 
diff --git a/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/testing/framework/ui/LoadBuildDisplayPanel.java b/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/testing/framework/ui/LoadBuildDisplayPanel.java
index 42b7546..4b51c05 100644
--- a/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/testing/framework/ui/LoadBuildDisplayPanel.java
+++ b/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/testing/framework/ui/LoadBuildDisplayPanel.java
@@ -165,7 +165,7 @@
     }
 
     /**
-     * connEtoC1:  (UpButton.action.actionPerformed(java.awt.event.ActionEvent) --> LoadBuildDisplayPanel.up()V)
+     * connEtoC1:  (UpButton.action.actionPerformed(java.awt.event.ActionEvent) --{@literal >} LoadBuildDisplayPanel.up()V)
      * @param arg1 java.awt.event.ActionEvent
      */
     private void connEtoC1(java.awt.event.ActionEvent arg1) {
@@ -177,7 +177,7 @@
     }
 
     /**
-     * connEtoC2:  (LoadErrorTestResultButton.action.actionPerformed(java.awt.event.ActionEvent) --> LoadBuildDisplayPanel.loadErrorTestResults()V)
+     * connEtoC2:  (LoadErrorTestResultButton.action.actionPerformed(java.awt.event.ActionEvent) --{@literal >} LoadBuildDisplayPanel.loadErrorTestResults()V)
      * @param arg1 java.awt.event.ActionEvent
      */
     private void connEtoC2(java.awt.event.ActionEvent arg1) {
@@ -189,7 +189,7 @@
     }
 
     /**
-     * connEtoC3:  (InspectButton1.action.actionPerformed(java.awt.event.ActionEvent) --> LoadBuildDisplayPanel.inspectSelectedLoadBuild()V)
+     * connEtoC3:  (InspectButton1.action.actionPerformed(java.awt.event.ActionEvent) --{@literal >} LoadBuildDisplayPanel.inspectSelectedLoadBuild()V)
      * @param arg1 java.awt.event.ActionEvent
      */
     private void connEtoC3(java.awt.event.ActionEvent arg1) {
@@ -201,7 +201,7 @@
     }
 
     /**
-     * connEtoC4:  (JButton1.action.actionPerformed(java.awt.event.ActionEvent) --> LoadBuildDisplayPanel.viewStackTrace()V)
+     * connEtoC4:  (JButton1.action.actionPerformed(java.awt.event.ActionEvent) --{@literal >} LoadBuildDisplayPanel.viewStackTrace()V)
      * @param arg1 java.awt.event.ActionEvent
      */
 
@@ -222,7 +222,7 @@
     }
 
     /**
-     * connEtoC9:  (DeleteButton.action.actionPerformed(java.awt.event.ActionEvent) --> LoadBuildDisplayPanel.deleteLoadBuild()V)
+     * connEtoC9:  (DeleteButton.action.actionPerformed(java.awt.event.ActionEvent) --{@literal >} LoadBuildDisplayPanel.deleteLoadBuild()V)
      * @param arg1 java.awt.event.ActionEvent
      */
 
diff --git a/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/testing/framework/ui/TestingBrowserFrame.java b/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/testing/framework/ui/TestingBrowserFrame.java
index e23d6bc..120a0d4 100644
--- a/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/testing/framework/ui/TestingBrowserFrame.java
+++ b/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/testing/framework/ui/TestingBrowserFrame.java
@@ -108,7 +108,7 @@
     }
 
     /**
-     * connEtoC1:  (RunMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --> TestingBrowserFrame.testingBrowserPanel1RunTest()V)
+     * connEtoC1:  (RunMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --{@literal >} TestingBrowserFrame.testingBrowserPanel1RunTest()V)
      * @param arg1 java.awt.event.ActionEvent
      */
 
@@ -129,7 +129,7 @@
     }
 
     /**
-     * connEtoC10:  (LogResultsMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --> TestingBrowserFrame.testingBrowserPanel1LogTestResults()V)
+     * connEtoC10:  (LogResultsMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --{@literal >} TestingBrowserFrame.testingBrowserPanel1LogTestResults()V)
      * @param arg1 java.awt.event.ActionEvent
      */
 
@@ -150,7 +150,7 @@
     }
 
     /**
-     * connEtoC2:  (SetupMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --> TestingBrowserFrame.testingBrowserPanel1SetupTest()V)
+     * connEtoC2:  (SetupMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --{@literal >} TestingBrowserFrame.testingBrowserPanel1SetupTest()V)
      * @param arg1 java.awt.event.ActionEvent
      */
 
@@ -171,7 +171,7 @@
     }
 
     /**
-     * connEtoC3:  (ResetMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --> TestingBrowserFrame.testingBrowserPanel1ResetTest()V)
+     * connEtoC3:  (ResetMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --{@literal >} TestingBrowserFrame.testingBrowserPanel1ResetTest()V)
      * @param arg1 java.awt.event.ActionEvent
      */
 
@@ -192,7 +192,7 @@
     }
 
     /**
-     * connEtoC4:  (StopMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --> TestingBrowserFrame.testingBrowserPanel1StopTest()V)
+     * connEtoC4:  (StopMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --{@literal >} TestingBrowserFrame.testingBrowserPanel1StopTest()V)
      * @param arg1 java.awt.event.ActionEvent
      */
 
@@ -213,7 +213,7 @@
     }
 
     /**
-     * connEtoC5:  (QueryResultsMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --> TestingBrowserFrame.testingBrowserPanel1QueryLoadBuild()V)
+     * connEtoC5:  (QueryResultsMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --{@literal >} TestingBrowserFrame.testingBrowserPanel1QueryLoadBuild()V)
      * @param arg1 java.awt.event.ActionEvent
      */
 
@@ -234,7 +234,7 @@
     }
 
     /**
-     * connEtoC6:  (SaveResultsMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --> TestingBrowserFrame.testingBrowserPanel1SaveLoadBuild()V)
+     * connEtoC6:  (SaveResultsMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --{@literal >} TestingBrowserFrame.testingBrowserPanel1SaveLoadBuild()V)
      * @param arg1 java.awt.event.ActionEvent
      */
 
@@ -255,7 +255,7 @@
     }
 
     /**
-     * connEtoC7:  (ResetModelsMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --> TestingBrowserFrame.testingBrowserPanel1RefreshModels()V)
+     * connEtoC7:  (ResetModelsMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --{@literal >} TestingBrowserFrame.testingBrowserPanel1RefreshModels()V)
      * @param arg1 java.awt.event.ActionEvent
      */
 
@@ -276,7 +276,7 @@
     }
 
     /**
-     * connEtoC8:  (RebuildTestsMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --> TestingBrowserFrame.testingBrowserPanel1RefreshTests()V)
+     * connEtoC8:  (RebuildTestsMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --{@literal >} TestingBrowserFrame.testingBrowserPanel1RefreshTests()V)
      * @param arg1 java.awt.event.ActionEvent
      */
 
@@ -297,7 +297,7 @@
     }
 
     /**
-     * connEtoC9:  (KillMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --> TestingBrowserFrame.testingBrowserPanel1KillTest()V)
+     * connEtoC9:  (KillMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --{@literal >} TestingBrowserFrame.testingBrowserPanel1KillTest()V)
      * @param arg1 java.awt.event.ActionEvent
      */
 
diff --git a/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/tools/beans/ExpressionPanel.java b/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/tools/beans/ExpressionPanel.java
index 0150ca6..10d2847 100644
--- a/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/tools/beans/ExpressionPanel.java
+++ b/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/tools/beans/ExpressionPanel.java
@@ -132,7 +132,7 @@
     }
 
     /**
-     * connEtoC1:  (OrButton.action.actionPerformed(java.awt.event.ActionEvent) --> ExpressionPanel.orExpression()V)
+     * connEtoC1:  (OrButton.action.actionPerformed(java.awt.event.ActionEvent) --{@literal >} ExpressionPanel.orExpression()V)
      * @param arg1 java.awt.event.ActionEvent
      */
     private
@@ -153,7 +153,7 @@
     }
 
     /**
-     * connEtoC2:  (AndButton.action.actionPerformed(java.awt.event.ActionEvent) --> ExpressionPanel.andExpression()V)
+     * connEtoC2:  (AndButton.action.actionPerformed(java.awt.event.ActionEvent) --{@literal >} ExpressionPanel.andExpression()V)
      * @param arg1 java.awt.event.ActionEvent
      */
     private
@@ -174,7 +174,7 @@
     }
 
     /**
-     * connEtoC3:  (NotBuuton.action.actionPerformed(java.awt.event.ActionEvent) --> ExpressionPanel.notExpression()V)
+     * connEtoC3:  (NotBuuton.action.actionPerformed(java.awt.event.ActionEvent) --{@literal >} ExpressionPanel.notExpression()V)
      * @param arg1 java.awt.event.ActionEvent
      */
     private
@@ -195,7 +195,7 @@
     }
 
     /**
-     * connEtoC4:  (ClearButton.action.actionPerformed(java.awt.event.ActionEvent) --> ExpressionPanel.clearExpression()V)
+     * connEtoC4:  (ClearButton.action.actionPerformed(java.awt.event.ActionEvent) --{@literal >} ExpressionPanel.clearExpression()V)
      * @param arg1 java.awt.event.ActionEvent
      */
     private
diff --git a/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/tools/beans/MessageDialog.java b/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/tools/beans/MessageDialog.java
index 79c9a4e..21798d8 100644
--- a/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/tools/beans/MessageDialog.java
+++ b/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/tools/beans/MessageDialog.java
@@ -92,7 +92,7 @@
     }
 
     /**
-     * connEtoM1:  (OKButton.action.actionPerformed(java.awt.event.ActionEvent) --> MessageDialog.dispose()V)
+     * connEtoM1:  (OKButton.action.actionPerformed(java.awt.event.ActionEvent) --{@literal >} MessageDialog.dispose()V)
      * @param arg1 java.awt.event.ActionEvent
      */
     private
diff --git a/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/tools/sessionconsole/LoginEditorDialog.java b/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/tools/sessionconsole/LoginEditorDialog.java
index cfe2321..5f7e4c0 100644
--- a/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/tools/sessionconsole/LoginEditorDialog.java
+++ b/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/tools/sessionconsole/LoginEditorDialog.java
@@ -71,7 +71,7 @@
     }
 
     /**
-     * connEtoC1:  (CancelButton.action.actionPerformed(java.awt.event.ActionEvent) --> LoginEditorDialog.markCanceled()V)
+     * connEtoC1:  (CancelButton.action.actionPerformed(java.awt.event.ActionEvent) --{@literal >} LoginEditorDialog.markCanceled()V)
      * @param arg1 java.awt.event.ActionEvent
      */
     private void connEtoC1(java.awt.event.ActionEvent arg1) {
@@ -83,7 +83,7 @@
     }
 
     /**
-     * connEtoC2:  (OKButton.action. --> LoginEditorDialog.loginOK()V)
+     * connEtoC2:  (OKButton.action. --{@literal >} LoginEditorDialog.loginOK()V)
      */
     private void connEtoC2() {
         try {
diff --git a/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/tools/sessionconsole/LoginEditorPanel.java b/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/tools/sessionconsole/LoginEditorPanel.java
index 0793a9f..532b4f6 100644
--- a/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/tools/sessionconsole/LoginEditorPanel.java
+++ b/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/tools/sessionconsole/LoginEditorPanel.java
@@ -205,7 +205,7 @@
     }
 
     /**
-     * connEtoC2:  (NativeSequencingCheckbox.action.actionPerformed(java.awt.event.ActionEvent) --> LoginEditorPanel.resetSequenceButtons()V)
+     * connEtoC2:  (NativeSequencingCheckbox.action.actionPerformed(java.awt.event.ActionEvent) --{@literal >} LoginEditorPanel.resetSequenceButtons()V)
      * @param arg1 java.awt.event.ActionEvent
      */
     private void connEtoC2(java.awt.event.ActionEvent arg1) {
@@ -223,7 +223,7 @@
     }
 
     /**
-     * connEtoC3:  (BridgeChoice.item.itemStateChanged(java.awt.event.ItemEvent) --> LoginEditorPanel.bridgeChanged()V)
+     * connEtoC3:  (BridgeChoice.item.itemStateChanged(java.awt.event.ItemEvent) --{@literal >} LoginEditorPanel.bridgeChanged()V)
      * @param arg1 java.awt.event.ItemEvent
      */
     private void connEtoC3(java.awt.event.ItemEvent arg1) {
@@ -241,7 +241,7 @@
     }
 
     /**
-     * connEtoC4:  (StringBindingCheckbox.action.actionPerformed(java.awt.event.ActionEvent) --> LoginEditorPanel.resetStringButtons()V)
+     * connEtoC4:  (StringBindingCheckbox.action.actionPerformed(java.awt.event.ActionEvent) --{@literal >} LoginEditorPanel.resetStringButtons()V)
      * @param arg1 java.awt.event.ActionEvent
      */
     private void connEtoC4(java.awt.event.ActionEvent arg1) {
@@ -259,7 +259,7 @@
     }
 
     /**
-     * connEtoC5:  (BlobBindingCheckbox.action.actionPerformed(java.awt.event.ActionEvent) --> LoginEditorPanel.resetStringButtons()V)
+     * connEtoC5:  (BlobBindingCheckbox.action.actionPerformed(java.awt.event.ActionEvent) --{@literal >} LoginEditorPanel.resetStringButtons()V)
      * @param arg1 java.awt.event.ActionEvent
      */
     private void connEtoC5(java.awt.event.ActionEvent arg1) {
@@ -277,7 +277,7 @@
     }
 
     /**
-     * connEtoC7:  (PasswordText.caret.caretUpdate(javax.swing.event.CaretEvent) --> LoginEditorPanel.passwordChanged()V)
+     * connEtoC7:  (PasswordText.caret.caretUpdate(javax.swing.event.CaretEvent) --{@literal >} LoginEditorPanel.passwordChanged()V)
      * @param arg1 javax.swing.event.CaretEvent
      */
     private void connEtoC7(javax.swing.event.CaretEvent arg1) {
@@ -295,7 +295,7 @@
     }
 
     /**
-     * connPtoP10SetSource:  (LoginBean.usesStreamsForBinding <--> BlobStreamBinding.selected)
+     * connPtoP10SetSource:  (LoginBean.usesStreamsForBinding {@literal <}--{@literal >} BlobStreamBinding.selected)
      */
     private void connPtoP10SetSource() {
         /* Set the source from the target */
@@ -314,14 +314,14 @@
     }
 
     /**
-     * connPtoP10SetTarget:  (LoginBean.usesStreamsForBinding <--> BlobStreamBinding.selected)
+     * connPtoP10SetTarget:  (LoginBean.usesStreamsForBinding {@literal <}--{@literal >} BlobStreamBinding.selected)
      */
     private void connPtoP10SetTarget() {
         /* Set the target from the source */
     }
 
     /**
-     * connPtoP11SetSource:  (LoginBean.usesNativeSequencing <--> NativeSequencingCheckbox.selected)
+     * connPtoP11SetSource:  (LoginBean.usesNativeSequencing {@literal <}--{@literal >} NativeSequencingCheckbox.selected)
      */
     private void connPtoP11SetSource() {
         /* Set the source from the target */
@@ -346,7 +346,7 @@
     }
 
     /**
-     * connPtoP11SetTarget:  (LoginBean.usesNativeSequencing <--> NativeSequencingCheckbox.selected)
+     * connPtoP11SetTarget:  (LoginBean.usesNativeSequencing {@literal <}--{@literal >} NativeSequencingCheckbox.selected)
      */
     private void connPtoP11SetTarget() {
         /* Set the target from the source */
@@ -365,7 +365,7 @@
     }
 
     /**
-     * connPtoP12SetSource:  (LoginBean.sequencePreallocationSize <--> SequencePreallocationSizeText.text)
+     * connPtoP12SetSource:  (LoginBean.sequencePreallocationSize {@literal <}--{@literal >} SequencePreallocationSizeText.text)
      */
     private void connPtoP12SetSource() {
         /* Set the source from the target */
@@ -384,7 +384,7 @@
     }
 
     /**
-     * connPtoP12SetTarget:  (LoginBean.sequencePreallocationSize <--> SequencePreallocationSizeLabel.text)
+     * connPtoP12SetTarget:  (LoginBean.sequencePreallocationSize {@literal <}--{@literal >} SequencePreallocationSizeLabel.text)
      */
     private void connPtoP12SetTarget() {
         /* Set the target from the source */
@@ -403,7 +403,7 @@
     }
 
     /**
-     * connPtoP13SetSource:  (LoginBean.shouldOptimizeDataConversion <--> OptimizeDataConversionCheckbox.selected)
+     * connPtoP13SetSource:  (LoginBean.shouldOptimizeDataConversion {@literal <}--{@literal >} OptimizeDataConversionCheckbox.selected)
      */
     private void connPtoP13SetSource() {
         /* Set the source from the target */
@@ -422,7 +422,7 @@
     }
 
     /**
-     * connPtoP13SetTarget:  (LoginBean.shouldOptimizeDataConversion <--> OptimizeDataConversionCheckbox.selected)
+     * connPtoP13SetTarget:  (LoginBean.shouldOptimizeDataConversion {@literal <}--{@literal >} OptimizeDataConversionCheckbox.selected)
      */
     private void connPtoP13SetTarget() {
         /* Set the target from the source */
@@ -508,7 +508,7 @@
     }
 
     /**
-     * connPtoP17SetSource:  (LoginBean.shouldOptimizeDataConversion <--> OptimizeDataConversionCheckbox.selected)
+     * connPtoP17SetSource:  (LoginBean.shouldOptimizeDataConversion {@literal <}--{@literal >} OptimizeDataConversionCheckbox.selected)
      */
     private void connPtoP17SetSource() {
         /* Set the source from the target */
@@ -527,7 +527,7 @@
     }
 
     /**
-     * connPtoP17SetTarget:  (LoginBean.shouldOptimizeDataConversion <--> OptimizeDataConversionCheckbox.selected)
+     * connPtoP17SetTarget:  (LoginBean.shouldOptimizeDataConversion {@literal <}--{@literal >} OptimizeDataConversionCheckbox.selected)
      */
     private void connPtoP17SetTarget() {
         /* Set the target from the source */
@@ -546,7 +546,7 @@
     }
 
     /**
-     * connPtoP18SetSource:  (LoginBean.tableQualifier <--> CreatorText.text)
+     * connPtoP18SetSource:  (LoginBean.tableQualifier {@literal <}--{@literal >} CreatorText.text)
      */
     private void connPtoP18SetSource() {
         /* Set the source from the target */
@@ -565,7 +565,7 @@
     }
 
     /**
-     * connPtoP18SetTarget:  (LoginBean.tableQualifier <--> CreatorText.text)
+     * connPtoP18SetTarget:  (LoginBean.tableQualifier {@literal <}--{@literal >} CreatorText.text)
      */
     private void connPtoP18SetTarget() {
         /* Set the target from the source */
@@ -584,7 +584,7 @@
     }
 
     /**
-     * connPtoP19SetSource:  (LoginBean.shouldCacheAllStatements <--> CacheStatementsCheckbox.selected)
+     * connPtoP19SetSource:  (LoginBean.shouldCacheAllStatements {@literal <}--{@literal >} CacheStatementsCheckbox.selected)
      */
     private void connPtoP19SetSource() {
         /* Set the source from the target */
@@ -603,7 +603,7 @@
     }
 
     /**
-     * connPtoP19SetTarget:  (LoginBean.shouldCacheAllStatements <--> CacheStatementsCheckbox.selected)
+     * connPtoP19SetTarget:  (LoginBean.shouldCacheAllStatements {@literal <}--{@literal >} CacheStatementsCheckbox.selected)
      */
     private void connPtoP19SetTarget() {
         /* Set the target from the source */
@@ -622,7 +622,7 @@
     }
 
     /**
-     * connPtoP1SetSource:  (LoginEditorPanel.login <--> LoginBean.this)
+     * connPtoP1SetSource:  (LoginEditorPanel.login {@literal <}--{@literal >} LoginBean.this)
      */
     private void connPtoP1SetSource() {
         /* Set the source from the target */
@@ -648,7 +648,7 @@
     }
 
     /**
-     * connPtoP1SetTarget:  (LoginEditorPanel.login <--> LoginBean.this)
+     * connPtoP1SetTarget:  (LoginEditorPanel.login {@literal <}--{@literal >} LoginBean.this)
      */
     private void connPtoP1SetTarget() {
         /* Set the target from the source */
@@ -671,7 +671,7 @@
     }
 
     /**
-     * connPtoP20SetSource:  (LoginBean.statementCacheSize <--> StatementCacheSizeText.text)
+     * connPtoP20SetSource:  (LoginBean.statementCacheSize {@literal <}--{@literal >} StatementCacheSizeText.text)
      */
     private void connPtoP20SetSource() {
         /* Set the source from the target */
@@ -690,7 +690,7 @@
     }
 
     /**
-     * connPtoP20SetTarget:  (LoginBean.statementCacheSize <--> StatementCacheSizeText.text)
+     * connPtoP20SetTarget:  (LoginBean.statementCacheSize {@literal <}--{@literal >} StatementCacheSizeText.text)
      */
     private void connPtoP20SetTarget() {
         /* Set the target from the source */
@@ -709,7 +709,7 @@
     }
 
     /**
-     * connPtoP21SetSource:  (LoginBean.stringBindingSize <--> StringBindSizeText.text)
+     * connPtoP21SetSource:  (LoginBean.stringBindingSize {@literal <}--{@literal >} StringBindSizeText.text)
      */
     private void connPtoP21SetSource() {
         /* Set the source from the target */
@@ -728,7 +728,7 @@
     }
 
     /**
-     * connPtoP21SetTarget:  (LoginBean.stringBindingSize <--> StringBindSizeText.text)
+     * connPtoP21SetTarget:  (LoginBean.stringBindingSize {@literal <}--{@literal >} StringBindSizeText.text)
      */
     private void connPtoP21SetTarget() {
         /* Set the target from the source */
@@ -747,7 +747,7 @@
     }
 
     /**
-     * connPtoP22SetSource:  (LoginBean.usesStringBinding <--> StringBindingCheckbox.selected)
+     * connPtoP22SetSource:  (LoginBean.usesStringBinding {@literal <}--{@literal >} StringBindingCheckbox.selected)
      */
     private void connPtoP22SetSource() {
         /* Set the source from the target */
@@ -766,7 +766,7 @@
     }
 
     /**
-     * connPtoP22SetTarget:  (LoginBean.usesStringBinding <--> StringBindingCheckbox.selected)
+     * connPtoP22SetTarget:  (LoginBean.usesStringBinding {@literal <}--{@literal >} StringBindingCheckbox.selected)
      */
     private void connPtoP22SetTarget() {
         /* Set the target from the source */
@@ -785,7 +785,7 @@
     }
 
     /**
-     * connPtoP23SetSource:  (LoginBean.shouldTrimStrings <--> TrimStringsCheckbox.selected)
+     * connPtoP23SetSource:  (LoginBean.shouldTrimStrings {@literal <}--{@literal >} TrimStringsCheckbox.selected)
      */
     private void connPtoP23SetSource() {
         /* Set the source from the target */
@@ -804,7 +804,7 @@
     }
 
     /**
-     * connPtoP23SetTarget:  (LoginBean.shouldTrimStrings <--> TrimStringsCheckbox.selected)
+     * connPtoP23SetTarget:  (LoginBean.shouldTrimStrings {@literal <}--{@literal >} TrimStringsCheckbox.selected)
      */
     private void connPtoP23SetTarget() {
         /* Set the target from the source */
@@ -823,7 +823,7 @@
     }
 
     /**
-     * connPtoP24SetSource:  (LoginBean.usesDirectDriverConnect <--> DirectConnectCheckBox.selected)
+     * connPtoP24SetSource:  (LoginBean.usesDirectDriverConnect {@literal <}--{@literal >} DirectConnectCheckBox.selected)
      */
     private void connPtoP24SetSource() {
         /* Set the source from the target */
@@ -846,14 +846,14 @@
     }
 
     /**
-     * connPtoP24SetTarget:  (LoginBean.usesDirectDriverConnect <--> DirectConnectCheckBox.selected)
+     * connPtoP24SetTarget:  (LoginBean.usesDirectDriverConnect {@literal <}--{@literal >} DirectConnectCheckBox.selected)
      */
     private void connPtoP24SetTarget() {
         /* Set the target from the source */
     }
 
     /**
-     * connPtoP25SetSource:  (LoginBean.shouldForceFieldNamesToUpperCase <--> ForceCaseCheckBox.selected)
+     * connPtoP25SetSource:  (LoginBean.shouldForceFieldNamesToUpperCase {@literal <}--{@literal >} ForceCaseCheckBox.selected)
      */
     private void connPtoP25SetSource() {
         /* Set the source from the target */
@@ -872,14 +872,14 @@
     }
 
     /**
-     * connPtoP25SetTarget:  (LoginBean.shouldForceFieldNamesToUpperCase <--> ForceCaseCheckBox.selected)
+     * connPtoP25SetTarget:  (LoginBean.shouldForceFieldNamesToUpperCase {@literal <}--{@literal >} ForceCaseCheckBox.selected)
      */
     private void connPtoP25SetTarget() {
         /* Set the target from the source */
     }
 
     /**
-     * connPtoP2SetSource:  (LoginBean.driverClassName <--> DriverChoice.selectedItem)
+     * connPtoP2SetSource:  (LoginBean.driverClassName {@literal <}--{@literal >} DriverChoice.selectedItem)
      */
     private void connPtoP2SetSource() {
         /* Set the source from the target */
@@ -901,7 +901,7 @@
     }
 
     /**
-     * connPtoP2SetTarget:  (LoginBean.driverClassName <--> DriverChoice.selectedItem)
+     * connPtoP2SetTarget:  (LoginBean.driverClassName {@literal <}--{@literal >} DriverChoice.selectedItem)
      */
     private void connPtoP2SetTarget() {
         /* Set the target from the source */
@@ -920,7 +920,7 @@
     }
 
     /**
-     * connPtoP3SetSource:  (LoginBean.driverURLHeader <--> DriverURLText.text)
+     * connPtoP3SetSource:  (LoginBean.driverURLHeader {@literal <}--{@literal >} DriverURLText.text)
      */
     private void connPtoP3SetSource() {
         /* Set the source from the target */
@@ -942,7 +942,7 @@
     }
 
     /**
-     * connPtoP3SetTarget:  (LoginBean.driverURLHeader <--> DriverURLText.text)
+     * connPtoP3SetTarget:  (LoginBean.driverURLHeader {@literal <}--{@literal >} DriverURLText.text)
      */
     private void connPtoP3SetTarget() {
         /* Set the target from the source */
@@ -961,7 +961,7 @@
     }
 
     /**
-     * connPtoP4SetSource:  (LoginBean.usesBatchWriting <--> BatchWritingCheckBox.selected)
+     * connPtoP4SetSource:  (LoginBean.usesBatchWriting {@literal <}--{@literal >} BatchWritingCheckBox.selected)
      */
     private void connPtoP4SetSource() {
         /* Set the source from the target */
@@ -980,14 +980,14 @@
     }
 
     /**
-     * connPtoP4SetTarget:  (LoginBean.usesBatchWriting <--> BatchWritingCheckBox.selected)
+     * connPtoP4SetTarget:  (LoginBean.usesBatchWriting {@literal <}--{@literal >} BatchWritingCheckBox.selected)
      */
     private void connPtoP4SetTarget() {
         /* Set the target from the source */
     }
 
     /**
-     * connPtoP5SetSource:  (LoginBean.databaseURL <--> DatabaseURLText.text)
+     * connPtoP5SetSource:  (LoginBean.databaseURL {@literal <}--{@literal >} DatabaseURLText.text)
      */
     private void connPtoP5SetSource() {
         /* Set the source from the target */
@@ -1009,7 +1009,7 @@
     }
 
     /**
-     * connPtoP5SetTarget:  (LoginBean.databaseURL <--> DatabaseURLText.text)
+     * connPtoP5SetTarget:  (LoginBean.databaseURL {@literal <}--{@literal >} DatabaseURLText.text)
      */
     private void connPtoP5SetTarget() {
         /* Set the target from the source */
@@ -1028,7 +1028,7 @@
     }
 
     /**
-     * connPtoP6SetSource:  (LoginBean.platformClassName <--> PlatformChoice.selectedItem)
+     * connPtoP6SetSource:  (LoginBean.platformClassName {@literal <}--{@literal >} PlatformChoice.selectedItem)
      */
     private void connPtoP6SetSource() {
         /* Set the source from the target */
@@ -1048,7 +1048,7 @@
     }
 
     /**
-     * connPtoP6SetTarget:  (LoginBean.platformClassName <--> PlatformChoice.selectedItem)
+     * connPtoP6SetTarget:  (LoginBean.platformClassName {@literal <}--{@literal >} PlatformChoice.selectedItem)
      */
     private void connPtoP6SetTarget() {
         /* Set the target from the source */
@@ -1067,7 +1067,7 @@
     }
 
     /**
-     * connPtoP7SetSource:  (LoginBean.userName <--> UserText.text)
+     * connPtoP7SetSource:  (LoginBean.userName {@literal <}--{@literal >} UserText.text)
      */
     private void connPtoP7SetSource() {
         /* Set the source from the target */
@@ -1086,7 +1086,7 @@
     }
 
     /**
-     * connPtoP7SetTarget:  (LoginBean.userName <--> UserText.text)
+     * connPtoP7SetTarget:  (LoginBean.userName {@literal <}--{@literal >} UserText.text)
      */
     private void connPtoP7SetTarget() {
         /* Set the target from the source */
@@ -1105,7 +1105,7 @@
     }
 
     /**
-     * connPtoP8SetSource:  (LoginBean.usesBinding <--> BlobBindingCheckbox.selected)
+     * connPtoP8SetSource:  (LoginBean.usesBinding {@literal <}--{@literal >} BlobBindingCheckbox.selected)
      */
     private void connPtoP8SetSource() {
         /* Set the source from the target */
@@ -1124,7 +1124,7 @@
     }
 
     /**
-     * connPtoP8SetTarget:  (LoginBean.usesBinding <--> BlobBindingCheckbox.selected)
+     * connPtoP8SetTarget:  (LoginBean.usesBinding {@literal <}--{@literal >} BlobBindingCheckbox.selected)
      */
     private void connPtoP8SetTarget() {
         /* Set the target from the source */
@@ -1143,7 +1143,7 @@
     }
 
     /**
-     * connPtoP9SetSource:  (LoginBean.usesNativeSequencing <--> NativeSQLCheckbox.selected)
+     * connPtoP9SetSource:  (LoginBean.usesNativeSequencing {@literal <}--{@literal >} NativeSQLCheckbox.selected)
      */
     private void connPtoP9SetSource() {
         /* Set the source from the target */
@@ -1162,7 +1162,7 @@
     }
 
     /**
-     * connPtoP9SetTarget:  (LoginBean.usesNativeSequencing <--> NativeSQLCheckbox.selected)
+     * connPtoP9SetTarget:  (LoginBean.usesNativeSequencing {@literal <}--{@literal >} NativeSQLCheckbox.selected)
      */
     private void connPtoP9SetTarget() {
         /* Set the target from the source */
diff --git a/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/tools/sessionconsole/ProfileBrowserPanel.java b/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/tools/sessionconsole/ProfileBrowserPanel.java
index 886da8a..2406935 100644
--- a/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/tools/sessionconsole/ProfileBrowserPanel.java
+++ b/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/tools/sessionconsole/ProfileBrowserPanel.java
@@ -255,7 +255,7 @@
     }
 
     /**
-     * connEtoC1:  (QualifyClassNameCheckbox.action.actionPerformed(java.awt.event.ActionEvent) --> ProfileBrowserPanel.resetProfiles()V)
+     * connEtoC1:  (QualifyClassNameCheckbox.action.actionPerformed(java.awt.event.ActionEvent) --{@literal >} ProfileBrowserPanel.resetProfiles()V)
      * @param arg1 java.awt.event.ActionEvent
      */
     private void connEtoC1(java.awt.event.ActionEvent arg1) {
@@ -273,7 +273,7 @@
     }
 
     /**
-     * connEtoC2:  (GroupByChoice.item.itemStateChanged(java.awt.event.ItemEvent) --> ProfileBrowserPanel.resetProfiles()V)
+     * connEtoC2:  (GroupByChoice.item.itemStateChanged(java.awt.event.ItemEvent) --{@literal >} ProfileBrowserPanel.resetProfiles()V)
      * @param arg1 java.awt.event.ItemEvent
      */
     private void connEtoC2(java.awt.event.ItemEvent arg1) {
diff --git a/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/tools/sessionconsole/SessionConsole.java b/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/tools/sessionconsole/SessionConsole.java
index bbc8964..3bcdc1e 100644
--- a/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/tools/sessionconsole/SessionConsole.java
+++ b/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/tools/sessionconsole/SessionConsole.java
@@ -161,7 +161,7 @@
     }
 
     /**
-     * connEtoC1:  (LoadProjectMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --> SessionInspectorFrame.loadProject()V)
+     * connEtoC1:  (LoadProjectMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --{@literal >} SessionInspectorFrame.loadProject()V)
      * @param arg1 java.awt.event.ActionEvent
      */
     private
@@ -182,7 +182,7 @@
     }
 
     /**
-     * connEtoC10:  (ClearSQLMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --> SessionInspectorFrame.clearSQL()V)
+     * connEtoC10:  (ClearSQLMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --{@literal >} SessionInspectorFrame.clearSQL()V)
      * @param arg1 java.awt.event.ActionEvent
      */
     private
@@ -203,7 +203,7 @@
     }
 
     /**
-     * connEtoC11:  (LoginMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --> SessionInspectorFrame.login()V)
+     * connEtoC11:  (LoginMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --{@literal >} SessionInspectorFrame.login()V)
      * @param arg1 java.awt.event.ActionEvent
      */
     private
@@ -224,7 +224,7 @@
     }
 
     /**
-     * connEtoC12:  (LogoutMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --> SessionInspectorFrame.logout()V)
+     * connEtoC12:  (LogoutMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --{@literal >} SessionInspectorFrame.logout()V)
      * @param arg1 java.awt.event.ActionEvent
      */
     private
@@ -245,7 +245,7 @@
     }
 
     /**
-     * connEtoC13:  (InspectSessionMenuItem1.action.actionPerformed(java.awt.event.ActionEvent) --> SessionInspectorFrame.inspectSession()V)
+     * connEtoC13:  (InspectSessionMenuItem1.action.actionPerformed(java.awt.event.ActionEvent) --{@literal >} SessionInspectorFrame.inspectSession()V)
      * @param arg1 java.awt.event.ActionEvent
      */
     private
@@ -266,7 +266,7 @@
     }
 
     /**
-     * connEtoC14:  (ExecuteQueryMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --> SessionInspectorFrame.executeQuery()V)
+     * connEtoC14:  (ExecuteQueryMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --{@literal >} SessionInspectorFrame.executeQuery()V)
      * @param arg1 java.awt.event.ActionEvent
      */
     private
@@ -287,7 +287,7 @@
     }
 
     /**
-     * connEtoC15:  (CutSQLMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --> SessionInspectorFrame.cutSQL()V)
+     * connEtoC15:  (CutSQLMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --{@literal >} SessionInspectorFrame.cutSQL()V)
      * @param arg1 java.awt.event.ActionEvent
      */
     private
@@ -308,7 +308,7 @@
     }
 
     /**
-     * connEtoC16:  (CopySQLMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --> SessionInspectorFrame.copySQL()V)
+     * connEtoC16:  (CopySQLMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --{@literal >} SessionInspectorFrame.copySQL()V)
      * @param arg1 java.awt.event.ActionEvent
      */
     private
@@ -329,7 +329,7 @@
     }
 
     /**
-     * connEtoC17:  (PasteSQLMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --> SessionInspectorFrame.pasteSQL()V)
+     * connEtoC17:  (PasteSQLMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --{@literal >} SessionInspectorFrame.pasteSQL()V)
      * @param arg1 java.awt.event.ActionEvent
      */
     private
@@ -350,7 +350,7 @@
     }
 
     /**
-     * connEtoC18:  (ClearLogMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --> SessionInspectorFrame.clearLog()V)
+     * connEtoC18:  (ClearLogMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --{@literal >} SessionInspectorFrame.clearLog()V)
      * @param arg1 java.awt.event.ActionEvent
      */
     private
@@ -371,7 +371,7 @@
     }
 
     /**
-     * connEtoC19:  (ClearResultsMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --> SessionInspectorFrame.clearResults()V)
+     * connEtoC19:  (ClearResultsMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --{@literal >} SessionInspectorFrame.clearResults()V)
      * @param arg1 java.awt.event.ActionEvent
      */
     private
@@ -392,7 +392,7 @@
     }
 
     /**
-     * connEtoC2:  (ExitMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --> SessionInspectorFrame.exit()V)
+     * connEtoC2:  (ExitMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --{@literal >} SessionInspectorFrame.exit()V)
      * @param arg1 java.awt.event.ActionEvent
      */
     private
@@ -413,7 +413,7 @@
     }
 
     /**
-     * connEtoC20:  (InspectResultMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --> SessionInspectorFrame.inspectResult()V)
+     * connEtoC20:  (InspectResultMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --{@literal >} SessionInspectorFrame.inspectResult()V)
      * @param arg1 java.awt.event.ActionEvent
      */
     private
@@ -434,7 +434,7 @@
     }
 
     /**
-     * connEtoC21:  (InsertSQLMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --> SessionInspectorFrame.templateSQLInsert()V)
+     * connEtoC21:  (InsertSQLMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --{@literal >} SessionInspectorFrame.templateSQLInsert()V)
      * @param arg1 java.awt.event.ActionEvent
      */
     private
@@ -455,7 +455,7 @@
     }
 
     /**
-     * connEtoC22:  (UpdateSQLMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --> SessionInspectorFrame.templateSQLUpdate()V)
+     * connEtoC22:  (UpdateSQLMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --{@literal >} SessionInspectorFrame.templateSQLUpdate()V)
      * @param arg1 java.awt.event.ActionEvent
      */
     private
@@ -476,7 +476,7 @@
     }
 
     /**
-     * connEtoC23:  (DeleteSQLMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --> SessionInspectorFrame.templateSQLDelete()V)
+     * connEtoC23:  (DeleteSQLMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --{@literal >} SessionInspectorFrame.templateSQLDelete()V)
      * @param arg1 java.awt.event.ActionEvent
      */
     private
@@ -497,7 +497,7 @@
     }
 
     /**
-     * connEtoC24:  (SelectSQLMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --> SessionInspectorFrame.templateSQLSelect()V)
+     * connEtoC24:  (SelectSQLMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --{@literal >} SessionInspectorFrame.templateSQLSelect()V)
      * @param arg1 java.awt.event.ActionEvent
      */
     private
@@ -518,7 +518,7 @@
     }
 
     /**
-     * connEtoC25:  (BrowseProfileMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --> SessionInspectorFrame.browseProfile()V)
+     * connEtoC25:  (BrowseProfileMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --{@literal >} SessionInspectorFrame.browseProfile()V)
      * @param arg1 java.awt.event.ActionEvent
      */
     private
@@ -539,7 +539,7 @@
     }
 
     /**
-     * connEtoC28:  (SessionInspectorFrame.window.windowClosing(java.awt.event.WindowEvent) --> SessionConsole.exit()V)
+     * connEtoC28:  (SessionInspectorFrame.window.windowClosing(java.awt.event.WindowEvent) --{@literal >} SessionConsole.exit()V)
      * @param arg1 java.awt.event.WindowEvent
      */
     private
@@ -560,7 +560,7 @@
     }
 
     /**
-     * connEtoC3:  (ResetDescriptorsMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --> SessionInspectorFrame.resetDescriptors()V)
+     * connEtoC3:  (ResetDescriptorsMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --{@literal >} SessionInspectorFrame.resetDescriptors()V)
      * @param arg1 java.awt.event.ActionEvent
      */
     private
@@ -581,7 +581,7 @@
     }
 
     /**
-     * connEtoC4:  (ClearDescriptorsMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --> SessionInspectorFrame.clearDescriptors()V)
+     * connEtoC4:  (ClearDescriptorsMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --{@literal >} SessionInspectorFrame.clearDescriptors()V)
      * @param arg1 java.awt.event.ActionEvent
      */
     private
@@ -602,7 +602,7 @@
     }
 
     /**
-     * connEtoC5:  (InspectDescriptorMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --> SessionInspectorFrame.inspectDescriptor()V)
+     * connEtoC5:  (InspectDescriptorMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --{@literal >} SessionInspectorFrame.inspectDescriptor()V)
      * @param arg1 java.awt.event.ActionEvent
      */
     private
@@ -623,7 +623,7 @@
     }
 
     /**
-     * connEtoC6:  (ClearCacheMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --> SessionInspectorFrame.clearCache()V)
+     * connEtoC6:  (ClearCacheMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --{@literal >} SessionInspectorFrame.clearCache()V)
      * @param arg1 java.awt.event.ActionEvent
      */
     private
@@ -644,7 +644,7 @@
     }
 
     /**
-     * connEtoC7:  (InspectCacheMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --> SessionInspectorFrame.inspectCache()V)
+     * connEtoC7:  (InspectCacheMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --{@literal >} SessionInspectorFrame.inspectCache()V)
      * @param arg1 java.awt.event.ActionEvent
      */
     private
@@ -665,7 +665,7 @@
     }
 
     /**
-     * connEtoC8:  (SQLUpdateMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --> SessionInspectorFrame.executeSQLUpdate()V)
+     * connEtoC8:  (SQLUpdateMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --{@literal >} SessionInspectorFrame.executeSQLUpdate()V)
      * @param arg1 java.awt.event.ActionEvent
      */
     private
@@ -686,7 +686,7 @@
     }
 
     /**
-     * connEtoC9:  (SQLSelectMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --> SessionInspectorFrame.executeSQLSelect()V)
+     * connEtoC9:  (SQLSelectMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --{@literal >} SessionInspectorFrame.executeSQLSelect()V)
      * @param arg1 java.awt.event.ActionEvent
      */
     private
@@ -707,7 +707,7 @@
     }
 
     /**
-     * connEtoM1:  (CloseMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --> SessionInspectorFrame.dispose()V)
+     * connEtoM1:  (CloseMenuItem.action.actionPerformed(java.awt.event.ActionEvent) --{@literal >} SessionInspectorFrame.dispose()V)
      * @param arg1 java.awt.event.ActionEvent
      */
     private
diff --git a/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/tools/sessionconsole/SessionConsolePanel.java b/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/tools/sessionconsole/SessionConsolePanel.java
index dc4f051..ea75786 100644
--- a/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/tools/sessionconsole/SessionConsolePanel.java
+++ b/foundation/org.eclipse.persistence.core.test.framework/src/main/java/org/eclipse/persistence/tools/sessionconsole/SessionConsolePanel.java
@@ -367,7 +367,7 @@
 
     /**
      * connEtoC14:
-     * (LogProfileCheckbox.item.itemStateChanged(java.awt.event.ItemEvent) -->
+     * (LogProfileCheckbox.item.itemStateChanged(java.awt.event.ItemEvent) --{@literal >}
      * SessionInspectorPanel.logProfileChanged()V)
      *
      * @param arg1
@@ -383,7 +383,7 @@
 
     /**
      * connEtoC15:
-     * (ProfileCheckbox.item.itemStateChanged(java.awt.event.ItemEvent) -->
+     * (ProfileCheckbox.item.itemStateChanged(java.awt.event.ItemEvent) --{@literal >}
      * SessionInspectorPanel.profileChanged()V)
      *
      * @param arg1
@@ -405,7 +405,7 @@
 
     /**
      * connEtoC16: (LogCheckbox.item.itemStateChanged(java.awt.event.ItemEvent)
-     * --> SessionInspectorPanel.loggingChanged()V)
+     * --{@literal >} SessionInspectorPanel.loggingChanged()V)
      *
      * @param arg1
      *                java.awt.event.ItemEvent
@@ -425,7 +425,7 @@
     }
 
     /**
-     * connEtoC18: (SQLText.mouse.mouseReleased(java.awt.event.MouseEvent) -->
+     * connEtoC18: (SQLText.mouse.mouseReleased(java.awt.event.MouseEvent) --{@literal >}
      * SessionInspectorPanel.genericPopupDisplay(Ljava.awt.event.MouseEvent;LJPopupMenu;)V)
      *
      * @param arg1
@@ -447,7 +447,7 @@
 
     /**
      * connEtoC19: (CacheTable.mouse.mouseReleased(java.awt.event.MouseEvent)
-     * -->
+     * --{@literal >}
      * SessionInspectorPanel.genericPopupDisplay(Ljava.awt.event.MouseEvent;LJPopupMenu;)V)
      *
      * @param arg1
@@ -463,7 +463,7 @@
 
     /**
      * connEtoC20:
-     * (ResultsScrollPane.mouse.mouseReleased(java.awt.event.MouseEvent) -->
+     * (ResultsScrollPane.mouse.mouseReleased(java.awt.event.MouseEvent) --{@literal >}
      * SessionInspectorPanel.genericPopupDisplay(Ljava.awt.event.MouseEvent;LJPopupMenu;)V)
      *
      * @param arg1
@@ -484,7 +484,7 @@
     }
 
     /**
-     * connEtoC21: (ClassList.mouse.mouseReleased(java.awt.event.MouseEvent) -->
+     * connEtoC21: (ClassList.mouse.mouseReleased(java.awt.event.MouseEvent) --{@literal >}
      * SessionInspectorPanel.genericPopupDisplay(Ljava.awt.event.MouseEvent;LJPopupMenu;)V)
      *
      * @param arg1
@@ -507,7 +507,7 @@
 
     /**
      * connEtoC3:
-     * (ClassList.listSelection.valueChanged(event.ListSelectionEvent) -->
+     * (ClassList.listSelection.valueChanged(event.ListSelectionEvent) --{@literal >}
      * SessionInspectorPanel.resetCache()V)
      *
      * @param arg1
@@ -522,7 +522,7 @@
     }
 
     /**
-     * connEtoC40: (QueryPage.mouse.mouseReleased(java.awt.event.MouseEvent) -->
+     * connEtoC40: (QueryPage.mouse.mouseReleased(java.awt.event.MouseEvent) --{@literal >}
      * SessionInspectorPanel.genericPopupDisplay(Ljava.awt.event.MouseEvent;LJPopupMenu;)V)
      *
      * @param arg1
@@ -544,7 +544,7 @@
     }
 
     /**
-     * connEtoC41: (LogText.mouse.mouseReleased(java.awt.event.MouseEvent) -->
+     * connEtoC41: (LogText.mouse.mouseReleased(java.awt.event.MouseEvent) --{@literal >}
      * SessionInspectorPanel.genericPopupDisplay(Ljava.awt.event.MouseEvent;LJPopupMenu;)V)
      *
      * @param arg1
@@ -566,7 +566,7 @@
     }
 
     /**
-     * connEtoC42: (LoginPage.mouse.mouseReleased(java.awt.event.MouseEvent) -->
+     * connEtoC42: (LoginPage.mouse.mouseReleased(java.awt.event.MouseEvent) --{@literal >}
      * SessionInspectorPanel.genericPopupDisplay(Ljava.awt.event.MouseEvent;LJPopupMenu;)V)
      *
      * @param arg1
@@ -588,7 +588,7 @@
     }
 
     /**
-     * connPtoP1SetTarget: (BrowseProfileMenuItem.enabled <-->
+     * connPtoP1SetTarget: (BrowseProfileMenuItem.enabled {@literal <}--{@literal >}
      * BrowseProfileButton.enabled)
      */
     private/* WARNING: THIS METHOD WILL BE REGENERATED. */
@@ -607,7 +607,7 @@
     }
 
     /**
-     * connPtoP2SetTarget: (LogProfileMenuItem.selected <-->
+     * connPtoP2SetTarget: (LogProfileMenuItem.selected {@literal <}--{@literal >}
      * LogProfileCheckbox.selected)
      */
     private/* WARNING: THIS METHOD WILL BE REGENERATED. */
@@ -626,7 +626,7 @@
     }
 
     /**
-     * connPtoP3SetTarget: (ProfileCheckbox.selected <-->
+     * connPtoP3SetTarget: (ProfileCheckbox.selected {@literal <}--{@literal >}
      * LogProfileMenuItem1.selected)
      */
     private/* WARNING: THIS METHOD WILL BE REGENERATED. */
@@ -645,7 +645,7 @@
     }
 
     /**
-     * connPtoP4SetTarget: (LogSQLMenuItem.selected <--> LogCheckbox.selected)
+     * connPtoP4SetTarget: (LogSQLMenuItem.selected {@literal <}--{@literal >} LogCheckbox.selected)
      */
     private void connPtoP4SetTarget() {
         try {
diff --git a/foundation/org.eclipse.persistence.core/src/main/java/org/eclipse/persistence/internal/codegen/CodeDefinition.java b/foundation/org.eclipse.persistence.core/src/main/java/org/eclipse/persistence/internal/codegen/CodeDefinition.java
index 8a8b0a0..d430157 100644
--- a/foundation/org.eclipse.persistence.core/src/main/java/org/eclipse/persistence/internal/codegen/CodeDefinition.java
+++ b/foundation/org.eclipse.persistence.core/src/main/java/org/eclipse/persistence/internal/codegen/CodeDefinition.java
@@ -158,7 +158,7 @@
      * Assumes that typeName contains only a package name (optional) and a short name,
      * potentially with subtended brackets.
      *
-     * (e.g. int -> int, java.util.Vector -> Vector, java.lang.Boolean[] -> Boolean, etc.)
+     * (e.g. {@code int -> int}, {@code java.util.Vector -> Vector}, {@code java.lang.Boolean[] -> Boolean}, etc.)
      */
     private static String shortName(String typeName) {
         int shortNameStartIndex = typeName.lastIndexOf('.') + 1;
diff --git a/foundation/org.eclipse.persistence.core/src/main/java/org/eclipse/persistence/internal/jpa/jpql/ConstructorQueryMappings.java b/foundation/org.eclipse.persistence.core/src/main/java/org/eclipse/persistence/internal/jpa/jpql/ConstructorQueryMappings.java
index 2f05e10..8c42f5b 100644
--- a/foundation/org.eclipse.persistence.core/src/main/java/org/eclipse/persistence/internal/jpa/jpql/ConstructorQueryMappings.java
+++ b/foundation/org.eclipse.persistence.core/src/main/java/org/eclipse/persistence/internal/jpa/jpql/ConstructorQueryMappings.java
@@ -139,8 +139,8 @@
      * This visitor visits the constructor items and adds the attribute type mapped to the name.
      * </p>
      * <p>Example:</p>
-     * <p>e.name -> "name" : String</p>
-     * <p>e.address.zipcode -> "zipcode" : int</p>
+     * <p>e.name -{@literal >} "name" : String</p>
+     * <p>e.address.zipcode -{@literal >} "zipcode" : int</p>
      */
     private class ConstructorItemVisitor extends AbstractEclipseLinkExpressionVisitor {
 
diff --git a/foundation/org.eclipse.persistence.core/src/main/java/org/eclipse/persistence/internal/jpa/jpql/DeclarationResolver.java b/foundation/org.eclipse.persistence.core/src/main/java/org/eclipse/persistence/internal/jpa/jpql/DeclarationResolver.java
index 809c587..5bb4b30 100644
--- a/foundation/org.eclipse.persistence.core/src/main/java/org/eclipse/persistence/internal/jpa/jpql/DeclarationResolver.java
+++ b/foundation/org.eclipse.persistence.core/src/main/java/org/eclipse/persistence/internal/jpa/jpql/DeclarationResolver.java
@@ -149,8 +149,8 @@
      * Converts the given {@link Declaration} from being set as a range variable declaration to
      * a path expression declaration.
      * <p>
-     * In this query "<code>UPDATE Employee SET firstName = 'MODIFIED' WHERE (SELECT COUNT(m) FROM
-     * managedEmployees m) > 0</code>" <em>managedEmployees</em> is an unqualified collection-valued
+     * In this query "{@code UPDATE Employee SET firstName = 'MODIFIED' WHERE (SELECT COUNT(m) FROM
+     * managedEmployees m) > 0}" <em>managedEmployees</em> is an unqualified collection-valued
      * path expression (<code>employee.managedEmployees</code>).
      *
      * @param declaration The {@link Declaration} that was parsed to range over an abstract schema
diff --git a/foundation/org.eclipse.persistence.core/src/main/java/org/eclipse/persistence/internal/jpa/jpql/RangeDeclaration.java b/foundation/org.eclipse.persistence.core/src/main/java/org/eclipse/persistence/internal/jpa/jpql/RangeDeclaration.java
index e1807fa..6893b27 100644
--- a/foundation/org.eclipse.persistence.core/src/main/java/org/eclipse/persistence/internal/jpa/jpql/RangeDeclaration.java
+++ b/foundation/org.eclipse.persistence.core/src/main/java/org/eclipse/persistence/internal/jpa/jpql/RangeDeclaration.java
@@ -100,8 +100,8 @@
      * Converts the given {@link Declaration} from being set as a range variable declaration to
      * a path expression declaration.
      * <p>
-     * In this query "<code>UPDATE Employee SET firstName = 'MODIFIED' WHERE (SELECT COUNT(m) FROM
-     * managedEmployees m) > 0</code>" <em>managedEmployees</em> is an unqualified collection-valued
+     * In this query "{@code UPDATE Employee SET firstName = 'MODIFIED' WHERE (SELECT COUNT(m) FROM
+     * managedEmployees m) > 0}" <em>managedEmployees</em> is an unqualified collection-valued
      * path expression (<code>employee.managedEmployees</code>).
      */
     private void convertUnqualifiedDeclaration() {
diff --git a/foundation/org.eclipse.persistence.core/src/main/java/org/eclipse/persistence/internal/jpa/parsing/SelectNode.java b/foundation/org.eclipse.persistence.core/src/main/java/org/eclipse/persistence/internal/jpa/parsing/SelectNode.java
index e381266..25f60ea 100644
--- a/foundation/org.eclipse.persistence.core/src/main/java/org/eclipse/persistence/internal/jpa/parsing/SelectNode.java
+++ b/foundation/org.eclipse.persistence.core/src/main/java/org/eclipse/persistence/internal/jpa/parsing/SelectNode.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -210,7 +210,7 @@
      * Answer true if there is a one-to-one relationship selected.
      * This includes a chain of relationships.
      * True: SELECT employee.address FROM ..... //Simple 1:1
-     * True: SELECT a.b.c.d FROM ..... //where a->b, b->c and c->d are all 1:1.
+     * True: SELECT a.b.c.d FROM ..... //where a-{@literal >}b, b-{@literal >}c and c-{@literal >}d are all 1:1.
      * False: SELECT OBJECT(employee) FROM ..... //simple SELECT
      * False: SELECT phoneNumber.areaCode FROM ..... //direct-to-field
      */
diff --git a/foundation/org.eclipse.persistence.core/src/main/java/org/eclipse/persistence/internal/oxm/XMLConversionManager.java b/foundation/org.eclipse.persistence.core/src/main/java/org/eclipse/persistence/internal/oxm/XMLConversionManager.java
index 838a679..784bcf8 100644
--- a/foundation/org.eclipse.persistence.core/src/main/java/org/eclipse/persistence/internal/oxm/XMLConversionManager.java
+++ b/foundation/org.eclipse.persistence.core/src/main/java/org/eclipse/persistence/internal/oxm/XMLConversionManager.java
@@ -1255,7 +1255,7 @@
      * java.util.Date.
      *
      * BC dates {@code (sourceDate.getTime() < YEAR_ONE_AD_TIME)} are handled
-     * as follows: '2007 BC' --> '-2006 AD'
+     * as follows: {@code '2007 BC' --> '-2006 AD'}
      *
      * @param sourceDate
      * @return
@@ -1420,7 +1420,7 @@
      * Timestamp.
      *
      * BC dates {@code (sourceDate.getTime() < YEAR_ONE_AD_TIME)} are handled
-     * as follows: '2007 BC' --> '-2006 AD'
+     * as follows: {@code '2007 BC' --> '-2006 AD'}
      *
      * @param sourceDate
      * @return
@@ -1452,7 +1452,7 @@
      * based on a given schema type QName.
      *
      * BC dates {@code (sourceDate.getTime() < YEAR_ONE_AD_TIME)} are handled
-     * as follows: '2007 BC' --> '-2006 AD'.
+     * as follows: {@code '2007 BC' --> '-2006 AD'}.
      *
      * @param sourceDate
      * @param schemaType
diff --git a/foundation/org.eclipse.persistence.core/src/main/java/org/eclipse/persistence/internal/sequencing/SequencingManager.java b/foundation/org.eclipse.persistence.core/src/main/java/org/eclipse/persistence/internal/sequencing/SequencingManager.java
index 022af71..fd65441 100644
--- a/foundation/org.eclipse.persistence.core/src/main/java/org/eclipse/persistence/internal/sequencing/SequencingManager.java
+++ b/foundation/org.eclipse.persistence.core/src/main/java/org/eclipse/persistence/internal/sequencing/SequencingManager.java
@@ -47,18 +47,18 @@
  *
  * Here's the lifecycle of SequencingManager.
  * InitialState: SequencingManager doesn't exist.
- *   Action: SequencingManager created -> Not connected State.
+ *   Action: SequencingManager created -{@literal >} Not connected State.
  * State: Not connected.
  *        isConnected() returns false;
  *        getSequencingControl() could be used;
  *        getSequencing() == getSequencingServer() == getSequencingCallbackFactory() == null;
- *   Action: onConnect is called -> Connected State.
+ *   Action: onConnect is called -{@literal >} Connected State.
  * State: Connected.
  *        isConnected() returns true;
  *        getSequencingControl() could be used;
  *        getSequencing() could be used;
  *        in case ownwerSession is a ServerSession getSequencingServer() could be used;
- *   Action: onDisconnect is called -> Not connected State.
+ *   Action: onDisconnect is called -{@literal >} Not connected State.
  *
  * Here's a sketch of SequencingManager architecture.
  * The main 4 objects comprising SessionManager are:
diff --git a/foundation/org.eclipse.persistence.nosql/src/it/java/org/eclipse/persistence/testing/tests/eis/xmlfile/EmployeeNSSystem.java b/foundation/org.eclipse.persistence.nosql/src/it/java/org/eclipse/persistence/testing/tests/eis/xmlfile/EmployeeNSSystem.java
index fafba5d..d4ed841 100644
--- a/foundation/org.eclipse.persistence.nosql/src/it/java/org/eclipse/persistence/testing/tests/eis/xmlfile/EmployeeNSSystem.java
+++ b/foundation/org.eclipse.persistence.nosql/src/it/java/org/eclipse/persistence/testing/tests/eis/xmlfile/EmployeeNSSystem.java
@@ -31,7 +31,6 @@
  * Create and populate the database.
  * </li>
  * </ul>
- * </p>
  */
 public class EmployeeNSSystem extends EmployeeSystem {
     public EmployeeNSSystem() {
diff --git a/foundation/org.eclipse.persistence.nosql/src/it/java/org/eclipse/persistence/testing/tests/eis/xmlfile/EmployeeSystem.java b/foundation/org.eclipse.persistence.nosql/src/it/java/org/eclipse/persistence/testing/tests/eis/xmlfile/EmployeeSystem.java
index 2d36e23..278835f 100644
--- a/foundation/org.eclipse.persistence.nosql/src/it/java/org/eclipse/persistence/testing/tests/eis/xmlfile/EmployeeSystem.java
+++ b/foundation/org.eclipse.persistence.nosql/src/it/java/org/eclipse/persistence/testing/tests/eis/xmlfile/EmployeeSystem.java
@@ -37,7 +37,6 @@
  * Create and populate the database.
  * </li>
  * </ul>
- * </p>
  */
 public class EmployeeSystem extends TestSystem {
 
diff --git a/foundation/org.eclipse.persistence.nosql/src/main/java/org/eclipse/persistence/internal/nosql/adapters/mongo/MongoJCAConnectionSpec.java b/foundation/org.eclipse.persistence.nosql/src/main/java/org/eclipse/persistence/internal/nosql/adapters/mongo/MongoJCAConnectionSpec.java
index 185a03e..088e41e 100644
--- a/foundation/org.eclipse.persistence.nosql/src/main/java/org/eclipse/persistence/internal/nosql/adapters/mongo/MongoJCAConnectionSpec.java
+++ b/foundation/org.eclipse.persistence.nosql/src/main/java/org/eclipse/persistence/internal/nosql/adapters/mongo/MongoJCAConnectionSpec.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2011, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2011, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -63,7 +63,7 @@
      * available. A negative value means to wait indefinitely.
      * </p>
      *
-     * <p>Used by {@link org.eclipse.persistence.testing.tests.jpa.mongo.MongoDatabaseTestSuite} only.
+     * <p>Used by {@code org.eclipse.persistence.testing.tests.jpa.mongo.MongoDatabaseTestSuite} only.
      */
     private int serverSelectionTimeout = 1000 * 30;
 
diff --git a/foundation/org.eclipse.persistence.oracle.nosql/src/it/java/org/eclipse/persistence/testing/tests/eis/aq/AQTestSuite.java b/foundation/org.eclipse.persistence.oracle.nosql/src/it/java/org/eclipse/persistence/testing/tests/eis/aq/AQTestSuite.java
index cc93fd5..e9c39de 100644
--- a/foundation/org.eclipse.persistence.oracle.nosql/src/it/java/org/eclipse/persistence/testing/tests/eis/aq/AQTestSuite.java
+++ b/foundation/org.eclipse.persistence.oracle.nosql/src/it/java/org/eclipse/persistence/testing/tests/eis/aq/AQTestSuite.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -32,14 +32,14 @@
  * Test suite requires AQ extension to be installed in Oracle database:<ul>
  * <li>Log in as SYSDBA: {@code sqlplus <admin_user>/<admin_password> as SYSDBA}</li>
  * <li>Install AQ extension: {@code @@<orahome>\rdbms\admin\catproc.sql}</li>
- * <li>Create user and grant him required privileges:</li><ul>
+ * <li>Create user and grant him required privileges:</li>
  * <li>{@code CREATE USER <user> IDENTIFIED BY <password>;}</li>
  * <li>{@code GRANT CONNECT, RESOURCE, AQ_ADMINISTRATOR_ROLE TO <user> IDENTIFIED BY <password>;}</li>
  * <li>{@code GRANT EXECUTE ON dbms_aq TO <user>}</li>
  * <li>{@code GRANT EXECUTE ON dbms_aqin TO <user>}</li>
  * <li>{@code GRANT EXECUTE ON dbms_aqadm TO <user>}</li>
  * <li>{@code GRANT EXECUTE ON dbms_lock TO <user>}</li>
- * </ul></ul>
+ * </ul>
  */
 @RunWith(Suite.class)
 @SuiteClasses({
diff --git a/foundation/org.eclipse.persistence.oracle.nosql/src/it/java/org/eclipse/persistence/testing/tests/nosql/ModelHelper.java b/foundation/org.eclipse.persistence.oracle.nosql/src/it/java/org/eclipse/persistence/testing/tests/nosql/ModelHelper.java
index d7b12d9..7aa15b5 100644
--- a/foundation/org.eclipse.persistence.oracle.nosql/src/it/java/org/eclipse/persistence/testing/tests/nosql/ModelHelper.java
+++ b/foundation/org.eclipse.persistence.oracle.nosql/src/it/java/org/eclipse/persistence/testing/tests/nosql/ModelHelper.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2016, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -23,6 +23,7 @@
 import org.eclipse.persistence.testing.models.order.Address;
 import org.eclipse.persistence.testing.models.order.LineItem;
 import org.eclipse.persistence.testing.models.order.Order;
+import org.eclipse.persistence.testing.tests.eis.aq.JMSDirectInteractionTest;
 
 /**
  * Test model helper methods.
@@ -111,7 +112,7 @@
     }
 
     /**
-     * Setup {@code "order_queue"} for {@link #testReadUOW()}.
+     * Setup {@code "order_queue"} for {@link JMSDirectInteractionTest#testQueue()}.
      * @param session Relational database session (will not work with AQ connection specifications based session).
      */
     public static void setupOrderQueue(final DatabaseSession session) {
@@ -125,7 +126,7 @@
     }
 
     /**
-     * Reset {@code "order_queue"} for {@link #testReadUOW()}.
+     * Reset {@code "order_queue"} for {@link JMSDirectInteractionTest#testQueue()}.
      * @param session Relational database session (will not work with AQ connection specifications based session).
      */
     public static void resetOrderQueue(final DatabaseSession session) {
@@ -138,7 +139,7 @@
     }
 
     /**
-     * Setup {@code "order_topic"} for {@link #testReadUOW()}.
+     * Setup {@code "order_topic"} for {@link JMSDirectInteractionTest#testTopic()}.
      * @param session Relational database session (will not work with AQ connection specifications based session).
      */
     public static void setupOrderTopic(final DatabaseSession session) {
@@ -151,7 +152,7 @@
     }
 
     /**
-     * Reset {@code "order_topic"} for {@link #testReadUOW()}.
+     * Reset {@code "order_topic"} for {@link JMSDirectInteractionTest#testTopic()}.
      * @param session Relational database session (will not work with AQ connection specifications based session).
      */
     public static void resetOrderTopic(final DatabaseSession session) {
diff --git a/foundation/org.eclipse.persistence.oracle.nosql/src/it/java/org/eclipse/persistence/testing/tests/nosql/NoSQLProperties.java b/foundation/org.eclipse.persistence.oracle.nosql/src/it/java/org/eclipse/persistence/testing/tests/nosql/NoSQLProperties.java
index 84925f7..a07ebe9 100644
--- a/foundation/org.eclipse.persistence.oracle.nosql/src/it/java/org/eclipse/persistence/testing/tests/nosql/NoSQLProperties.java
+++ b/foundation/org.eclipse.persistence.oracle.nosql/src/it/java/org/eclipse/persistence/testing/tests/nosql/NoSQLProperties.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2016, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -169,7 +169,7 @@
      * Process and add simple build property.
      * @param properties Test properties {@link Map} being built.
      * @param buildKey   Property key in build properties.
-     * @param puKey      Property key in jUnit test.
+     * @param testKey      Property key in jUnit test.
      */
     private static void processProperty(
             final Map<String, String> properties, final String buildKey, final String testKey) {
@@ -246,7 +246,6 @@
     /**
      * Set EIS login connection information for NoSQL database.
      * @param login      Target {@link EISLogin} instance.
-     * @param properties Persistence unit properties {@link Map}.
      */
     public static void setEISLoginProperties(final EISLogin login) {
         final String hostPort = buildHostPort(
diff --git a/foundation/org.eclipse.persistence.oracle.test/src/it/java/org/eclipse/persistence/testing/tests/distributedservers/rcm/jms/JMSRCMDistributedServersModel.java b/foundation/org.eclipse.persistence.oracle.test/src/it/java/org/eclipse/persistence/testing/tests/distributedservers/rcm/jms/JMSRCMDistributedServersModel.java
index 400c4b9..2f6307b 100644
--- a/foundation/org.eclipse.persistence.oracle.test/src/it/java/org/eclipse/persistence/testing/tests/distributedservers/rcm/jms/JMSRCMDistributedServersModel.java
+++ b/foundation/org.eclipse.persistence.oracle.test/src/it/java/org/eclipse/persistence/testing/tests/distributedservers/rcm/jms/JMSRCMDistributedServersModel.java
@@ -36,7 +36,7 @@
         connect sys/password@james as sysdba
 
         2 - might need to install aq procesures?
-        - in sqlplus - @@<orahome>\ora92\rdbms\admin\catproc.sql
+        - in sqlplus - {@code @@<orahome>\ora92\rdbms\admin\catproc.sql}
 
         3 - create aquser with aquser password
         grant connect, resource , aq_administrator_role to aquser identified by aquser
diff --git a/foundation/org.eclipse.persistence.oracle.test/src/it/java/org/eclipse/persistence/testing/tests/lob/LOBTestModel.java b/foundation/org.eclipse.persistence.oracle.test/src/it/java/org/eclipse/persistence/testing/tests/lob/LOBTestModel.java
index 2ad412f..3810f2d 100644
--- a/foundation/org.eclipse.persistence.oracle.test/src/it/java/org/eclipse/persistence/testing/tests/lob/LOBTestModel.java
+++ b/foundation/org.eclipse.persistence.oracle.test/src/it/java/org/eclipse/persistence/testing/tests/lob/LOBTestModel.java
@@ -25,12 +25,12 @@
  * Object Model: Image [id(int), script(String), picture(byte[]), audio(byte[]), commentary(char[])]
  * Data Schame: IMAGE [id(NUMBER), SCRIPT(CLOB), PICTURE(BLOB)]
  *              CLIP [id(NUMBER), AUDIO(BLOB), COMMENTARY(CLOB)]
- * Descriptor: Image --> (IMAGE, CLIP). i.e. multiple table.
- * Mappings:  id -> ID (direct-to-field mapping).
- *            script -> SCRIPT (TypeConversionMapping, 'converted type': java.sql.Clob).
- *            picture -> PICTURE (TypeConversionMapping, 'converted type': java.sql.Blob).
- *            audio -> AUDIO (TypeConversionMapping, 'converted type': java.sql.Blob).
- *            Commentary -> COMMENTARY (TypeConversionMapping, 'converted type': java.sql.Clob).
+ * Descriptor: Image --{@literal >} (IMAGE, CLIP). i.e. multiple table.
+ * Mappings:  id -{@literal >} ID (direct-to-field mapping).
+ *            script -{@literal >} SCRIPT (TypeConversionMapping, 'converted type': java.sql.Clob).
+ *            picture -{@literal >} PICTURE (TypeConversionMapping, 'converted type': java.sql.Blob).
+ *            audio -{@literal >} AUDIO (TypeConversionMapping, 'converted type': java.sql.Blob).
+ *            Commentary -{@literal >} COMMENTARY (TypeConversionMapping, 'converted type': java.sql.Clob).
  *
  * NOTE: The main purpose of this test model is to test Oracle Thin driver 4k limits. TopLink overally supports
  * BLOB/CLOB well with the proper JDBC drivers. One exception is Oracle thin driver, which has had a well known 4k limits
diff --git a/jpa/eclipselink.jpa.test.jse/src/it/java/org/eclipse/persistence/jpa/test/criteria/TestCoalesceFunction.java b/jpa/eclipselink.jpa.test.jse/src/it/java/org/eclipse/persistence/jpa/test/criteria/TestCoalesceFunction.java
index 2285a2e..8299e73 100644
--- a/jpa/eclipselink.jpa.test.jse/src/it/java/org/eclipse/persistence/jpa/test/criteria/TestCoalesceFunction.java
+++ b/jpa/eclipselink.jpa.test.jse/src/it/java/org/eclipse/persistence/jpa/test/criteria/TestCoalesceFunction.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, 2021 Oracle and/or its affiliates. All rights reserved.
  * Copyright (c) 2020 IBM Corporation. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
@@ -38,7 +38,7 @@
     private EntityManagerFactory emf;
 
     /**
-     * Test for javax.persistence.criteria.CriteriaBuilder.coalesce(Expression<? extends Y> x, Y y)
+     * Test for {@code jakarta.persistence.criteria.CriteriaBuilder.coalesce(Expression<? extends Y> x, Y y)}
      */
     @Test
     public void testCoalesceFunction3Long() throws Exception {
@@ -101,7 +101,7 @@
     }
 
     /**
-     * Test for javax.persistence.criteria.CriteriaBuilder.coalesce(Expression<? extends Y> x, Y y)
+     * Test for {@code jakarta.persistence.criteria.CriteriaBuilder.coalesce(Expression<? extends Y> x, Y y)}
      */
     @Test
     public void testCoalesceFunction3BigDecimal() throws Exception {
@@ -164,7 +164,7 @@
     }
 
     /**
-     * Test for javax.persistence.criteria.CriteriaBuilder.coalesce(Expression<? extends Y> x, Y y)
+     * Test for {@code jakarta.persistence.criteria.CriteriaBuilder.coalesce(Expression<? extends Y> x, Y y)}
      */
     @Test
     public void testCoalesceFunction3Date() throws Exception {
diff --git a/jpa/eclipselink.jpa.test.jse/src/it/java/org/eclipse/persistence/jpa/test/jpql/TestAggregateFunctions.java b/jpa/eclipselink.jpa.test.jse/src/it/java/org/eclipse/persistence/jpa/test/jpql/TestAggregateFunctions.java
index 9a20fe0..054f978 100644
--- a/jpa/eclipselink.jpa.test.jse/src/it/java/org/eclipse/persistence/jpa/test/jpql/TestAggregateFunctions.java
+++ b/jpa/eclipselink.jpa.test.jse/src/it/java/org/eclipse/persistence/jpa/test/jpql/TestAggregateFunctions.java
@@ -42,7 +42,7 @@
      * Complex test of the aggregate functions in JPQL. 
      * For this test, there must be zero results in the entity table and the Entity state field 
      * must be a primitive type.
-     * JPA 2.1 specification; Section 4.8.5 states aggregate functions (MIN, MAX, AVG, & SUM) 
+     * JPA 2.1 specification; Section 4.8.5 states aggregate functions (MIN, MAX, AVG, &amp; SUM)
      * must return a result of NULL if there are no values to apply the aggregate function to
      */
     @Test
@@ -87,7 +87,7 @@
      * Complex test of the aggregate functions in JPQL. 
      * For this test, there must be zero results in the entity table and the Entity state field 
      * must be a primitive wrapper type.
-     * JPA 2.1 specification; Section 4.8.5 states aggregate functions (MIN, MAX, AVG, & SUM) 
+     * JPA 2.1 specification; Section 4.8.5 states aggregate functions (MIN, MAX, AVG, &amp; SUM)
      * must return a result of NULL if there are no values to apply the aggregate function to
      */
     @Test
@@ -130,7 +130,7 @@
 
     /**
      * Complex test of the aggregate functions in JPQL. 
-     * For this test, there must be >0 results in the entity table and the Entity state field 
+     * For this test, there must be {@literal >}0 results in the entity table and the Entity state field
      * must be a primitive type.
      * This test is verification that aggregates return the correct result
      */
@@ -194,7 +194,7 @@
 
     /**
      * Complex test of the aggregate functions in JPQL. 
-     * For this test, there must be >0 results in the entity table and the Entity state field 
+     * For this test, there must be {@literal >}0 results in the entity table and the Entity state field
      * must be a primitive wrapper type.
      * This test is verification that aggregates return the correct result
      */
diff --git a/jpa/eclipselink.jpa.test.jse/src/it/java/org/eclipse/persistence/jpa/test/jpql/TestComplexJPQL.java b/jpa/eclipselink.jpa.test.jse/src/it/java/org/eclipse/persistence/jpa/test/jpql/TestComplexJPQL.java
index 2d51ed2..1ca9a26 100644
--- a/jpa/eclipselink.jpa.test.jse/src/it/java/org/eclipse/persistence/jpa/test/jpql/TestComplexJPQL.java
+++ b/jpa/eclipselink.jpa.test.jse/src/it/java/org/eclipse/persistence/jpa/test/jpql/TestComplexJPQL.java
@@ -1,6 +1,6 @@
 /*
- * Copyright (c) 2018, 2020 Oracle and/or its affiliates. All rights reserved.
- * Copyright (c) 2018, 2020 IBM Corporation. All rights reserved.
+ * Copyright (c) 2018, 2021 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2021 IBM Corporation. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -179,8 +179,8 @@
 
     /**
      * Tests EclipseLink's parsing of a LEFT OUTER JOIN when the condition has no matches. 
-     * EclipseLink should account for the NULL values in the right table.
-     * @see Bug 493804
+     * EclipseLink should account for the NULL values in the right table.<br>
+     * see Bug 493804
      */
     @Test
     public void testLeftOuterJoinWithNullResult() {
diff --git a/jpa/eclipselink.jpa.test.jse/src/it/java/org/eclipse/persistence/jpa/test/query/TestQueryHints.java b/jpa/eclipselink.jpa.test.jse/src/it/java/org/eclipse/persistence/jpa/test/query/TestQueryHints.java
index ec55ba5..c9f6a15 100644
--- a/jpa/eclipselink.jpa.test.jse/src/it/java/org/eclipse/persistence/jpa/test/query/TestQueryHints.java
+++ b/jpa/eclipselink.jpa.test.jse/src/it/java/org/eclipse/persistence/jpa/test/query/TestQueryHints.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2021 Oracle and/or its affiliates. All rights reserved.
  * Copyright (c) 2017, 2019 IBM Corporation. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
@@ -216,7 +216,6 @@
      * Test that setting the Query Hint: QueryHints.SCROLLABLE_CURSOR on a NamedQuery
      * does not cause subsequent Queries, created using the same name, to throw exception.
      *
-     * @throws Exception
      */
     @Test
     public void testMultipleNamedQueryWithScrollableCursor() {
diff --git a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/advanced/Employee.java b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/advanced/Employee.java
index 015435be..d34ec58 100644
--- a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/advanced/Employee.java
+++ b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/advanced/Employee.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  * Copyright (c) 2019 IBM Corporation. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
@@ -312,10 +312,10 @@
     private String m_lastName;
     private String m_firstName;
 
-    /** Transformation mapping, a two(2) element array holding the employee's normal working hours (START_TIME & END_TIME),
+    /** Transformation mapping, a two(2) element array holding the employee's normal working hours (START_TIME &amp; END_TIME),
     this is stored into two different fields in the employee table. */
     private Time[] normalHours;
-    /** Transformation mapping, a two(2) element array holding the employee's overtime hours (OVERTIME_START_TIME & OVERTIME_END_TIME),
+    /** Transformation mapping, a two(2) element array holding the employee's overtime hours (OVERTIME_START_TIME &amp; OVERTIME_END_TIME),
     this is stored into two different fields in the employee table. */
     private Time[] overtimeHours;
 
diff --git a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/advanced/EmploymentPeriod.java b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/advanced/EmploymentPeriod.java
index 077c036..c6233ec 100644
--- a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/advanced/EmploymentPeriod.java
+++ b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/advanced/EmploymentPeriod.java
@@ -89,7 +89,7 @@
     }
 
     /**
-     * Print the start & end date
+     * Print the start &amp; end date
      */
     public String toString() {
         java.io.StringWriter writer = new java.io.StringWriter();
diff --git a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/advanced/customer/RegisteredCustomer.java b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/advanced/customer/RegisteredCustomer.java
index e44f4a9..002aab8 100644
--- a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/advanced/customer/RegisteredCustomer.java
+++ b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/advanced/customer/RegisteredCustomer.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2014, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -108,7 +108,6 @@
 
     /**
      * Set Customer name.
-     * @return Customer name to be set.
      */
     public void setName(final String name) {
         this.name = name;
diff --git a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/advanced/embeddable/Visitor.java b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/advanced/embeddable/Visitor.java
index 812ec4d..be180ea 100644
--- a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/advanced/embeddable/Visitor.java
+++ b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/advanced/embeddable/Visitor.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2009, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2009, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -85,7 +85,7 @@
 
     /**
      * Set entity primary key.
-     * @param id Entity primary key.
+     * @param v Entity primary key.
      */
     public void setId(String v) {
         this.id = v;
diff --git a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/advanced/embeddable/VisitorPopulator.java b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/advanced/embeddable/VisitorPopulator.java
index a76260f..007080c 100644
--- a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/advanced/embeddable/VisitorPopulator.java
+++ b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/advanced/embeddable/VisitorPopulator.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2014, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -25,7 +25,7 @@
 
     /**
      * First sample instance.
-     * @return Initialized sample instance of {@see Visitor} class.
+     * @return Initialized sample instance of {@link Visitor} class.
      */
     public static Visitor visitorExample1() {
         return new Visitor("1", "Alan E. Frechette",
@@ -34,7 +34,7 @@
 
     /**
      * Second sample instance.
-     * @return Initialized sample instance of {@see Visitor} class.
+     * @return Initialized sample instance of {@link Visitor} class.
      */
     public static Visitor visitorExample2() {
         return new Visitor("2", "Arthur D. Frechette",
diff --git a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/advanced/entities/EntyA.java b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/advanced/entities/EntyA.java
index 57db1f7..fffa443 100644
--- a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/advanced/entities/EntyA.java
+++ b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/advanced/entities/EntyA.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -121,7 +121,7 @@
     }
 
     /**
-     * @param entyD the entyD to set
+     * @param entyDs the entyD to set
      */
     public void setEntyDs(Collection<EntyD> entyDs) {
         this.entyDs = entyDs;
@@ -139,7 +139,7 @@
     }
 
     /**
-     * @param entyE the entyE to set
+     * @param entyEs the entyE to set
      */
     public void setEntyEs(Collection<EntyE> entyEs) {
         this.entyEs = entyEs;
diff --git a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/advanced/multitenant/SubTask.java b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/advanced/multitenant/SubTask.java
index 4c60765..f353ad4 100644
--- a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/advanced/multitenant/SubTask.java
+++ b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/advanced/multitenant/SubTask.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2011, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2011, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -23,7 +23,8 @@
  * be picked up from other test persistence unit classes that do not exclude
  * unlisted classes.
  *
- * @see Related mapping file:
+ * <br>
+ * see Related mapping file:
  * trunk\jpa\eclipselink.jpa.test\resource\eclipselink-annotation-model\multitenant-vpd.xml
  *
  * @author gpelleti
diff --git a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/advanced/multitenant/Task.java b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/advanced/multitenant/Task.java
index d6ad13b..6c2a59f 100644
--- a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/advanced/multitenant/Task.java
+++ b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/advanced/multitenant/Task.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2011, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2011, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -51,7 +51,7 @@
  * be picked up from other test persistence unit classes that do not exclude
  * unlisted classes.
  *
- * @see Related mapping file:
+ * see Related mapping file:
  * trunk\jpa\eclipselink.jpa.test\resource\eclipselink-annotation-model\multitenant-vpd.xml
  *
  * Multi-tenant to do list.
diff --git a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/cacheable/CacheableTableCreator.java b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/cacheable/CacheableTableCreator.java
index 27318ce..8b509b1 100644
--- a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/cacheable/CacheableTableCreator.java
+++ b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/cacheable/CacheableTableCreator.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -602,9 +602,9 @@
     }
 
     /**
-     * Build table for {@see org.eclipse.persistence.testing.models.jpa.cacheable.ProductFalse}
+     * Build table for {@link org.eclipse.persistence.testing.models.jpa.cacheable.ProductFalse}
      * class.
-     * @return Initialized {@see TableDefinition} instance.
+     * @return Initialized {@link TableDefinition} instance.
      */
     public static TableDefinition buildProductFalseTable() {
         TableDefinition table = createTable("PRODUCT_FALSE");
@@ -617,9 +617,9 @@
     }
 
     /**
-     * Build table for {@see org.eclipse.persistence.testing.models.jpa.cacheable.ProductTrue}
+     * Build table for {@link org.eclipse.persistence.testing.models.jpa.cacheable.ProductTrue}
      * class.
-     * @return Initialized {@see TableDefinition} instance.
+     * @return Initialized {@link TableDefinition} instance.
      */
     public static TableDefinition buildProductTrueTable() {
         TableDefinition table = createTable("PRODUCT_TRUE");
diff --git a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/composite/advanced/member_2/Employee.java b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/composite/advanced/member_2/Employee.java
index c409ceb..2d80428 100644
--- a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/composite/advanced/member_2/Employee.java
+++ b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/composite/advanced/member_2/Employee.java
@@ -234,10 +234,10 @@
     private String m_lastName;
     private String m_firstName;
 
-    /** Transformation mapping, a two(2) element array holding the employee's normal working hours (START_TIME & END_TIME),
+    /** Transformation mapping, a two(2) element array holding the employee's normal working hours (START_TIME &amp; END_TIME),
     this is stored into two different fields in the employee table. */
     private Time[] normalHours;
-    /** Transformation mapping, a two(2) element array holding the employee's overtime hours (OVERTIME_START_TIME & OVERTIME_END_TIME),
+    /** Transformation mapping, a two(2) element array holding the employee's overtime hours (OVERTIME_START_TIME &amp; OVERTIME_END_TIME),
     this is stored into two different fields in the employee table. */
     private Time[] overtimeHours;
 
diff --git a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/composite/advanced/member_2/EmploymentPeriod.java b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/composite/advanced/member_2/EmploymentPeriod.java
index df274c4..955dc50 100644
--- a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/composite/advanced/member_2/EmploymentPeriod.java
+++ b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/composite/advanced/member_2/EmploymentPeriod.java
@@ -72,7 +72,7 @@
     }
 
     /**
-     * Print the start & end date
+     * Print the start &amp; end date
      */
     public String toString() {
         java.io.StringWriter writer = new java.io.StringWriter();
diff --git a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/delimited/EmploymentPeriod.java b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/delimited/EmploymentPeriod.java
index 2362c64..d57a75e 100644
--- a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/delimited/EmploymentPeriod.java
+++ b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/delimited/EmploymentPeriod.java
@@ -73,7 +73,7 @@
     }
 
     /**
-     * Print the start & end date
+     * Print the start &amp; end date
      */
     public String toString() {
         java.io.StringWriter writer = new java.io.StringWriter();
diff --git a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/fieldaccess/advanced/EmploymentPeriod.java b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/fieldaccess/advanced/EmploymentPeriod.java
index da1e65f..67f45d8 100644
--- a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/fieldaccess/advanced/EmploymentPeriod.java
+++ b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/fieldaccess/advanced/EmploymentPeriod.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -65,7 +65,7 @@
     }
 
     /**
-     * Print the start & end date
+     * Print the start &amp; end date
      */
     public String toString() {
         java.io.StringWriter writer = new java.io.StringWriter();
diff --git a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/inheritance/GenericTestInterface1.java b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/inheritance/GenericTestInterface1.java
index eb8b977..ace4cfb 100644
--- a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/inheritance/GenericTestInterface1.java
+++ b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/inheritance/GenericTestInterface1.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2013, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -20,7 +20,6 @@
  * This interface was added as a test for bug 411560
  * @author tware
  *
- * @param <PK>
  */
 public interface GenericTestInterface1<T> {
 
diff --git a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/inheritance/GenericTestInterface2.java b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/inheritance/GenericTestInterface2.java
index 5a41f6c..3eb3dfc 100644
--- a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/inheritance/GenericTestInterface2.java
+++ b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/inheritance/GenericTestInterface2.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2013, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -18,7 +18,6 @@
  * This interface was added as a test for bug 411560
  * @author tware
  *
- * @param <PK>
  */
 public interface GenericTestInterface2<T1, T2> {
 
diff --git a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/inheritance/Person.java b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/inheritance/Person.java
index 238f8e5..f3824df 100644
--- a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/inheritance/Person.java
+++ b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/inheritance/Person.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -31,6 +31,7 @@
  * <li> class name indicator usage
  * <li> concreate root class
  * <li> big int as primary key
+ * </ul>
  */
 @Entity
 @Table(name="CMP3_PERSON")
diff --git a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/performance/Employee.java b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/performance/Employee.java
index 5bd58c3..f54cec8 100644
--- a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/performance/Employee.java
+++ b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/performance/Employee.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -260,7 +260,7 @@
     }
 
     /**
-     * Print the first & last name
+     * Print the first &amp; last name
      */
     public String toString() {
         StringWriter writer = new StringWriter();
diff --git a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/performance/EmploymentPeriod.java b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/performance/EmploymentPeriod.java
index b05b656..0366798 100644
--- a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/performance/EmploymentPeriod.java
+++ b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/performance/EmploymentPeriod.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -79,7 +79,7 @@
     }
 
     /**
-     * Print the start & end date
+     * Print the start &amp; end date
      */
     public String toString() {
         StringWriter writer = new StringWriter();
diff --git a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/performance/LargeProject.java b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/performance/LargeProject.java
index 2ac0af4..cc56b83 100644
--- a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/performance/LargeProject.java
+++ b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/performance/LargeProject.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -20,7 +20,7 @@
 /**
  * <b>Purpose</b>: Larger scale projects within the Employee Demo
  * <p><b>Description</b>: LargeProject is a concrete subclass of Project. It is instantiated for Projects with type = 'L'. The additional
- * information (budget, & milestoneVersion) are mapped from the LPROJECT table.
+ * information (budget, &amp; milestoneVersion) are mapped from the LPROJECT table.
  * @see Project
  */
 //@org.hibernate.annotations.Cache(usage=org.hibernate.annotations.CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
diff --git a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/performance/Project.java b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/performance/Project.java
index 7c0eec0..45ee998 100644
--- a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/performance/Project.java
+++ b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/performance/Project.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -18,7 +18,7 @@
 
 //import com.tangosol.io.pof.*;
 /**
- * <b>Purpose</b>: Abstract superclass for Large & Small projects in Employee Demo
+ * <b>Purpose</b>: Abstract superclass for Large &amp; Small projects in Employee Demo
  * <p><b>Description</b>:     Project is an example of an abstract superclass. It demonstrates how class inheritance can be mapped to database tables.
  * It's subclasses are concrete and may or may not add columns through additional tables. The PROJ_TYPE field in the
  * database table indicates which subclass to instantiate. Projects are involved in a M:M relationship with employees.
diff --git a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/advanced/CacheAuditor.java b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/advanced/CacheAuditor.java
index 0c19bd6..e3a230e 100644
--- a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/advanced/CacheAuditor.java
+++ b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/advanced/CacheAuditor.java
@@ -133,9 +133,6 @@
         return lastAcquireNoWait;
     }
 
-    /**
-     * @param accessCount the accessCount to set
-     */
     public void resetAccessCount() {
         this.accessCount = 0;
         this.lastAcquireNoWait = null;
diff --git a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/advanced/Employee.java b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/advanced/Employee.java
index 64a858a..718535b 100644
--- a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/advanced/Employee.java
+++ b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/advanced/Employee.java
@@ -93,10 +93,10 @@
     private static final String SCOTIABANK = "Scotiabank";
     private static final String TORONTO_DOMINION = "TorontoDominion";
 
-    /** Transformation mapping, a two(2) element array holding the employee's normal working hours (START_TIME & END_TIME),
+    /** Transformation mapping, a two(2) element array holding the employee's normal working hours (START_TIME &amp; END_TIME),
     this is stored into two different fields in the employee table. */
     private Time[] normalHours;
-    /** Transformation mapping, a two(2) element array holding the employee's overtime hours (OVERTIME_START_TIME & OVERTIME_END_TIME),
+    /** Transformation mapping, a two(2) element array holding the employee's overtime hours (OVERTIME_START_TIME &amp; OVERTIME_END_TIME),
     this is stored into two different fields in the employee table. */
     private Time[] overtimeHours;
 
diff --git a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/advanced/EmploymentPeriod.java b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/advanced/EmploymentPeriod.java
index 831e80d..a12a6fb 100644
--- a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/advanced/EmploymentPeriod.java
+++ b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/advanced/EmploymentPeriod.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -74,7 +74,7 @@
     }
 
     /**
-     * Print the start & end date
+     * Print the start &amp; end date
      */
     public String toString() {
         java.io.StringWriter writer = new java.io.StringWriter();
diff --git a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/advanced/Project.java b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/advanced/Project.java
index 7768b42..0d519fb 100644
--- a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/advanced/Project.java
+++ b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/advanced/Project.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -25,9 +25,9 @@
  * Primary key class: ProjectPK
  * Home interface: ProjectHome
  *
- * >Employees have a many-to-many relationship with Projects through the
+ * {@literal >}Employees have a many-to-many relationship with Projects through the
  *  projects attribute.
- * >Projects refer to Employees through the employees attribute.
+ * {@literal >}Projects refer to Employees through the employees attribute.
  */
 public class Project implements Serializable {
     public int pre_update_count = 0;
diff --git a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/composite/advanced/member_1/Address.java b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/composite/advanced/member_1/Address.java
index ad04a8b..c9f52fb 100644
--- a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/composite/advanced/member_1/Address.java
+++ b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/composite/advanced/member_1/Address.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -24,7 +24,7 @@
  * <p>
  * <b>Description</b>: Held in a private 1:1 relationship from Employee
  *
- * @see Employee
+ * @see Person
  */
 public class Address implements Serializable {
     private Integer id;
diff --git a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/composite/advanced/member_2/Employee.java b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/composite/advanced/member_2/Employee.java
index 6f4842b..964b572 100644
--- a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/composite/advanced/member_2/Employee.java
+++ b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/composite/advanced/member_2/Employee.java
@@ -97,10 +97,10 @@
     private static final String SCOTIABANK = "Scotiabank";
     private static final String TORONTO_DOMINION = "TorontoDominion";
 
-    /** Transformation mapping, a two(2) element array holding the employee's normal working hours (START_TIME & END_TIME),
+    /** Transformation mapping, a two(2) element array holding the employee's normal working hours (START_TIME &amp; END_TIME),
     this is stored into two different fields in the employee table. */
     private Time[] normalHours;
-    /** Transformation mapping, a two(2) element array holding the employee's overtime hours (OVERTIME_START_TIME & OVERTIME_END_TIME),
+    /** Transformation mapping, a two(2) element array holding the employee's overtime hours (OVERTIME_START_TIME &amp; OVERTIME_END_TIME),
     this is stored into two different fields in the employee table. */
     private Time[] overtimeHours;
 
diff --git a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/composite/advanced/member_2/EmploymentPeriod.java b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/composite/advanced/member_2/EmploymentPeriod.java
index cfc677b..2e9b01b 100644
--- a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/composite/advanced/member_2/EmploymentPeriod.java
+++ b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/composite/advanced/member_2/EmploymentPeriod.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -74,7 +74,7 @@
     }
 
     /**
-     * Print the start & end date
+     * Print the start &amp; end date
      */
     public String toString() {
         java.io.StringWriter writer = new java.io.StringWriter();
diff --git a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/composite/advanced/member_3/Project.java b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/composite/advanced/member_3/Project.java
index 635c5a6..5d04889 100644
--- a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/composite/advanced/member_3/Project.java
+++ b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/composite/advanced/member_3/Project.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -27,9 +27,9 @@
  * Primary key class: ProjectPK
  * Home interface: ProjectHome
  *
- * >Employees have a many-to-many relationship with Projects through the
+ * {@literal >}Employees have a many-to-many relationship with Projects through the
  *  projects attribute.
- * >Projects refer to Employees through the employees attribute.
+ * {@literal >}Projects refer to Employees through the employees attribute.
  */
 public class Project implements Serializable {
     public int pre_update_count = 0;
diff --git a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/inheritance/Person.java b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/inheritance/Person.java
index 2d5a110..c991b38 100644
--- a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/inheritance/Person.java
+++ b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/inheritance/Person.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -25,6 +25,7 @@
  * <li> class name indicator usage
  * <li> concreate root class
  * <li> big int as primary key
+ * </ul>
  */
 
 public class Person implements Serializable {
diff --git a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/merge/advanced/EmploymentPeriod.java b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/merge/advanced/EmploymentPeriod.java
index 1ab550f..6e11891 100644
--- a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/merge/advanced/EmploymentPeriod.java
+++ b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/merge/advanced/EmploymentPeriod.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -71,7 +71,7 @@
     }
 
     /**
-     * Print the start & end date
+     * Print the start &amp; end date
      */
     public String toString() {
         java.io.StringWriter writer = new java.io.StringWriter();
diff --git a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/merge/incompletemappings/owning/Project.java b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/merge/incompletemappings/owning/Project.java
index 2c1e9cc..3acdc82 100644
--- a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/merge/incompletemappings/owning/Project.java
+++ b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/merge/incompletemappings/owning/Project.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -26,8 +26,9 @@
  * Bean class: ProjectBean Remote interface: Project Primary key class:
  * ProjectPK Home interface: ProjectHome
  *
- * >Employees have a many-to-many relationship with Projects through the
- * projects attribute. >Projects refer to Employees through the employees
+ * {@literal >}Employees have a many-to-many relationship with Projects through the
+ * projects attribute.
+ * {@literal >}Projects refer to Employees through the employees
  * attribute.
  */
 @Entity(name = "XMLIncompleteMergeProject")
diff --git a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/merge/relationships/Customer.java b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/merge/relationships/Customer.java
index b76cfec..6e2f63c 100644
--- a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/merge/relationships/Customer.java
+++ b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/merge/relationships/Customer.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -101,12 +101,14 @@
 
     /**
      * Order is mapped in XML as follows:
+     * <pre>{@code
      *  <one-to-many name="orders" target-entity="Order" mapped-by="customer">
      *    <cascade>
      *      <cascade-persist/>
      *      <cascade-remove/>
      *    </cascade>
      * </one-to-many>
+     * }</pre>
      * The annotations should be ignored. If OrderBy is processed, the value
      * will cause an exception during processing.
      *
diff --git a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/merge/relationships/Order.java b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/merge/relationships/Order.java
index a2a342b..3a3b530 100644
--- a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/merge/relationships/Order.java
+++ b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/merge/relationships/Order.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -82,7 +82,7 @@
 
     /**
      * Quantity is mapped in XML as follows:
-     *  <basic name="quantity"/>
+     *  {@code <basic name="quantity"/>}
      *
      * Note, no column definition meaning it should default to QUANTITY.
      * The Column annotation below should be ignored. If it is not and is
@@ -109,7 +109,7 @@
 
     /**
      * Customer is mapped in XML as follows:
-     *  <many-to-one name="customer" target-entity="Customer" fetch="LAZY"/>
+     *  <pre>{@code </pre><many-to-one name="customer" target-entity="Customer" fetch="LAZY"/>}</pre>
      *
      * Note, no join columns are specified and therefore they should default
      * and the annotation should be ignored. If JoinColumn is processed, the
diff --git a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/relationships/unidirectional/EmploymentPeriod.java b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/relationships/unidirectional/EmploymentPeriod.java
index cd20912..da076b2 100644
--- a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/relationships/unidirectional/EmploymentPeriod.java
+++ b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/relationships/unidirectional/EmploymentPeriod.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -61,7 +61,7 @@
     }
 
     /**
-     * Print the start & end date
+     * Print the start &amp; end date
      */
     public String toString() {
         java.io.StringWriter writer = new java.io.StringWriter();
diff --git a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/relationships/unidirectional/Project.java b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/relationships/unidirectional/Project.java
index bd445e5..a28ffa3 100644
--- a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/relationships/unidirectional/Project.java
+++ b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa/xml/relationships/unidirectional/Project.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -23,9 +23,9 @@
  * Primary key class: ProjectPK
  * Home interface: ProjectHome
  *
- * >Employees have a many-to-many relationship with Projects through the
+ * {@literal >}Employees have a many-to-many relationship with Projects through the
  *  projects attribute.
- * >Projects refer to Employees through the employees attribute.
+ * {@literal >}Projects refer to Employees through the employees attribute.
  */
 public class Project implements Serializable {
     public int pre_update_count = 0;
diff --git a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa22/jta/AnimalCheck.java b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa22/jta/AnimalCheck.java
index 784d51c..c1df56d 100644
--- a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa22/jta/AnimalCheck.java
+++ b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/models/jpa22/jta/AnimalCheck.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2016, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -37,7 +37,7 @@
     /**
      * Process {@link Animal} entity modification event.
      *
-     * @param event @link Animal} entity modification event
+     * @param event {@link Animal} entity modification event
      */
     @TransactionAttribute(TransactionAttributeType.REQUIRES_NEW)
     public void onEvent(AnimalEvent event) {
diff --git a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/advanced/AdvancedJPAJunitTest.java b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/advanced/AdvancedJPAJunitTest.java
index 4ee1599..7bb0893 100644
--- a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/advanced/AdvancedJPAJunitTest.java
+++ b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/advanced/AdvancedJPAJunitTest.java
@@ -3247,7 +3247,7 @@
     }
     
     /**
-     * Bug 470007 - NPE in normalize() when querying on ElementCollection->CollectionTable, with query results caching enabled
+     * Bug 470007 - NPE in normalize() when querying on ElementCollection-{@literal >}CollectionTable, with query results caching enabled
      * Tests querying across an Entity (ToDoList) containing an ElementCollection with a CollectionTable, referencing a
      * basic type (String). A NullPointerException was previously observed when query results caching is enabled on the query.  
      */
diff --git a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/advanced/EntityManagerJUnitTestSuite.java b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/advanced/EntityManagerJUnitTestSuite.java
index 14a186f..c6041fc 100644
--- a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/advanced/EntityManagerJUnitTestSuite.java
+++ b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/advanced/EntityManagerJUnitTestSuite.java
@@ -3959,7 +3959,7 @@
         }
     }
 
-    /** ToDo: move these to a memory test suite.
+    /* ToDo: move these to a memory test suite.
     // gf3596: transactions never release memory until commit, so JVM eventually crashes.
     // Attempts to compare memory consumption between the two FlushClearCache modes.
     // If the values changed to be big enough (in TopLink I tried nFlashes = 30 , nInsertsPerFlush = 10000)
diff --git a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/advanced/JPARCMLocalChangeSetTestSuite.java b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/advanced/JPARCMLocalChangeSetTestSuite.java
index 05b2e33..84b9f5e 100644
--- a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/advanced/JPARCMLocalChangeSetTestSuite.java
+++ b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/advanced/JPARCMLocalChangeSetTestSuite.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  * Copyright (c) 1998, 2018 IBM Corporation. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
@@ -55,7 +55,7 @@
 
 /**
  * JPARCMLocalChangeSetTestSuite
- * Simple low resource/setup JPA test suite & framework allowing for local 
+ * Simple low resource/setup JPA test suite &amp; framework allowing for local 
  * testing and verification of ChangeSets distributed by RCM.
  * @author dminsky
  */
diff --git a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/cacheable/CacheableModelJunitTest.java b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/cacheable/CacheableModelJunitTest.java
index 96db181..7c0306c 100644
--- a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/cacheable/CacheableModelJunitTest.java
+++ b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/cacheable/CacheableModelJunitTest.java
@@ -884,7 +884,7 @@
     }
 
     /**
-     * Verifies the cacheable settings when caching (from persistence.xml) is set to ALL using <shared-cache-mode>.
+     * Verifies the cacheable settings when caching (from persistence.xml) is set to ALL using {@code <shared-cache-mode>}.
      */
     public void testCachingOnALL() {
         assertCachingOnALL(getPUServerSession("ALL"));
@@ -932,7 +932,7 @@
     }
 
     /**
-     * Verifies the cacheable settings when caching (from persistence.xml) is set to NONE using <shared-cache-mode>.
+     * Verifies the cacheable settings when caching (from persistence.xml) is set to NONE using {@code <shared-cache-mode>}.
      */
     public void testCachingOnNONE() {
         assertCachingOnNONE(getPUServerSession("NONE"));
@@ -957,9 +957,9 @@
     }
     
     /**
-     * Verifies that when the <shared-cache-mode> and jakarta.persistence.sharedCache.mode property
+     * Verifies that when the {@code <shared-cache-mode>} and jakarta.persistence.sharedCache.mode property
      * are set, the jakarta.persistence.sharedCache.mode property will win. In the persistence.xml,
-     * jakarta.persistence.sharedCache.mode property is set to NONE while <shared-cache-mode> is set to
+     * jakarta.persistence.sharedCache.mode property is set to NONE while {@code <shared-cache-mode>} is set to
      * ALL.
      */
     public void testCachingOnNONEPropertyConflict() {
@@ -1001,7 +1001,7 @@
     }
 
     /**
-     * Verifies the cacheable settings when caching (from persistence.xml) is set to ENABLE_SELECTIVE using <shared-cache-mode>.
+     * Verifies the cacheable settings when caching (from persistence.xml) is set to ENABLE_SELECTIVE using {@code <shared-cache-mode>}.
      */
     public void testCachingOnENABLE_SELECTIVE() {
         assertCachingOnENABLE_SELECTIVE(getPUServerSession("ENABLE_SELECTIVE"));
@@ -1046,7 +1046,7 @@
     }
 
     /**
-     * Verifies the cacheable settings when caching (from persistence.xml) is set to DISABLE_SELECTIVE using <shared-cache-mode>.
+     * Verifies the cacheable settings when caching (from persistence.xml) is set to DISABLE_SELECTIVE using {@code <shared-cache-mode>}.
      */
     public void testCachingOnDISABLE_SELECTIVE() {
         assertCachingOnDISABLE_SELECTIVE(getPUServerSession("DISABLE_SELECTIVE"));
@@ -1091,7 +1091,7 @@
     }
 
     /**
-     * Verifies the cacheable settings when caching (from persistence.xml) is set to UNSPECIFIED using <shared-cache-mode>.
+     * Verifies the cacheable settings when caching (from persistence.xml) is set to UNSPECIFIED using {@code <shared-cache-mode>}.
      */
     public void testCachingOnUNSPECIFIED() {
         assertCachingOnUNSPECIFIED(getPUServerSession("UNSPECIFIED"));
diff --git a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/datatypes/arraypks/PrimitiveArrayPKCachingJUnitTestCase.java b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/datatypes/arraypks/PrimitiveArrayPKCachingJUnitTestCase.java
index 080d1f8..86d23bd 100644
--- a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/datatypes/arraypks/PrimitiveArrayPKCachingJUnitTestCase.java
+++ b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/datatypes/arraypks/PrimitiveArrayPKCachingJUnitTestCase.java
@@ -40,7 +40,7 @@
  * <li> Run tests for caching of Entities with primitive array types for primary keys
  * in TopLink's JPA implementation.
  * </ul>
- * @see org.eclipse.persistence.essentials.testing.models.cmp3.datatypes.arraypks.PrimitiveArraysAsPrimaryKeyTableCreator
+ * @see PrimitiveArraysAsPrimaryKeyTableCreator
  */
 public class PrimitiveArrayPKCachingJUnitTestCase extends JUnitTestCase{
     public PrimitiveArrayPKCachingJUnitTestCase() {
diff --git a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/ddlgeneration/DDLGenerationJUnitTestSuite.java b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/ddlgeneration/DDLGenerationJUnitTestSuite.java
index 4e43a8d..5bb303f 100644
--- a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/ddlgeneration/DDLGenerationJUnitTestSuite.java
+++ b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/ddlgeneration/DDLGenerationJUnitTestSuite.java
@@ -1459,7 +1459,7 @@
     /**
      * Returns a List of strings representing the lines within the fileName.
      * @param fileName
-     * @return List<String>
+     * @return {@code List<String>}
      */
     public List<String> getDDLFile(String fileName){
         ArrayList<String> array = new ArrayList();
diff --git a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/jpql/JUnitJPQLUnitTestSuite.java b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/jpql/JUnitJPQLUnitTestSuite.java
index d841307..bec1892 100644
--- a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/jpql/JUnitJPQLUnitTestSuite.java
+++ b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/jpql/JUnitJPQLUnitTestSuite.java
@@ -622,7 +622,7 @@
     /**
      * Bug 501272
      * Test a JPQL query with 'select new' syntax with a named query and query results
-     * cache enabled. Tests if any SQL is generated & correct results after initial query.
+     * cache enabled. Tests if any SQL is generated &amp; correct results after initial query.
      * @see SimpleRoom
      */
     public void testSelectNewJPQLQueryWithQueryResultsCache() {
diff --git a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/metamodel/MetamodelMetamodelTest.java b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/metamodel/MetamodelMetamodelTest.java
index a8ae56d..1d938b3 100644
--- a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/metamodel/MetamodelMetamodelTest.java
+++ b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/metamodel/MetamodelMetamodelTest.java
@@ -4544,7 +4544,7 @@
     /**
      * This test will verify that MapAttribute instance have their elementType set correctly.
      * The elementType corresponds to the 3rd V parameter on the class definition - which is the Map value.
-     * MapAttributeImpl<X, K, V>
+     * {@code MapAttributeImpl<X, K, V>}
      */
     public void testMapAtributeElementTypeWhenMapKeySetButNameAttributeIsDefaulted() {
         boolean exceptionThrown = false;
diff --git a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/metamodel/MetamodelTableCreator.java b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/metamodel/MetamodelTableCreator.java
index 2bf46b5..b1e0850 100644
--- a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/metamodel/MetamodelTableCreator.java
+++ b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/metamodel/MetamodelTableCreator.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -826,8 +826,8 @@
      * This table defines a MappedSuperclass chain that defines a composite PK
      * that is distributed along the MappedSuperclass hierarchy of the form.
      * Root (MappedSuperclass)
-     *   --> Center (MappedSuperclass)
-     *             --> Leaf (Entity)
+     *   --{@literal >} Center (MappedSuperclass)
+     *             --{@literal >} Leaf (Entity)
      */
     public static TableDefinition buildMS_MS_Entity_Leaf_Table() {
         TableDefinition table = new TableDefinition();
diff --git a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/orphanremoval/OrphanRemovalJUnitTestCase.java b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/orphanremoval/OrphanRemovalJUnitTestCase.java
index 318a867..7a538b2 100644
--- a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/orphanremoval/OrphanRemovalJUnitTestCase.java
+++ b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/orphanremoval/OrphanRemovalJUnitTestCase.java
@@ -1007,10 +1007,10 @@
 
     /**
      * use case:
-     * A ---> B : the relationship between A and B is privately owned and cascade persist
+     * A {@literal --->} B : the relationship between A and B is privately owned and cascade persist
      * Create an instance of A and B. Persist A
      * Load A and update an attribute of B. Persist A
-     * => the attribute is not changed in DB.
+     * ={@literal >} the attribute is not changed in DB.
      */
     public void test121ChangeFromExistingObject() {
         EntityManager em = createEntityManager();
diff --git a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/plsql/PLSQLTestSuite.java b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/plsql/PLSQLTestSuite.java
index 9e08268..681fcf2 100644
--- a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/plsql/PLSQLTestSuite.java
+++ b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/plsql/PLSQLTestSuite.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2011, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2011, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -409,7 +409,7 @@
      * Test processing of OracleObject and OracleArray annotations.
      *
      * @see OracleArray
-     * @see OracleObject
+     * @see org.eclipse.persistence.platform.database.oracle.annotations.OracleObject
      */
     public void testOracleTypeProcessing() {
         if (!getServerSession().getPlatform().isOracle()) {
diff --git a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/privateowned/PrivateOwnedJUnitTestCase.java b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/privateowned/PrivateOwnedJUnitTestCase.java
index cf66a98..df2de08 100644
--- a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/privateowned/PrivateOwnedJUnitTestCase.java
+++ b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/privateowned/PrivateOwnedJUnitTestCase.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -953,10 +953,10 @@
 
     /**
      * use case:
-     * A ---> B : the relationship between A and B is privately owned and cascade persist
+     * A {@literal --->} B : the relationship between A and B is privately owned and cascade persist
      * Create an instance of A and B. Persist A
      * Load A and update an attribute of B. Persist A
-     * => the attribute is not changed in DB.
+     * ={@literal >} the attribute is not changed in DB.
      */
     public void testPrivateOwnedOneToOneChangeFromExistingObject() {
         // Step 1 - Create an object and a related object (p-o)
diff --git a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/validation/ValidationTestSuite.java b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/validation/ValidationTestSuite.java
index 91f3e2e..493d2d1 100644
--- a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/validation/ValidationTestSuite.java
+++ b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/validation/ValidationTestSuite.java
@@ -75,7 +75,7 @@
 
     /**
      * This test assumes the persistence unit has the following property set:
-     *       <property name="eclipselink.cache.shared.default" value="false"/>
+     *       <pre>{@code </pre><property name="eclipselink.cache.shared.default" value="false"/>}</pre>
      * @throws Exception
      */
 
diff --git a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/xml/merge/inherited/EntityMappingsMergeInheritedJUnitTestCase.java b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/xml/merge/inherited/EntityMappingsMergeInheritedJUnitTestCase.java
index 2f559ce..ed73fbb 100644
--- a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/xml/merge/inherited/EntityMappingsMergeInheritedJUnitTestCase.java
+++ b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/xml/merge/inherited/EntityMappingsMergeInheritedJUnitTestCase.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -198,7 +198,7 @@
         /**
          * Merge Test:Have a class(TelephoneNumber) that uses a composite primary
          * key (defined partially in annotations and XML) and define a 1-M
-         * (BeerConsumer->TelephoneNumber) for it in XML
+         * (BeerConsumer-{@literal >}TelephoneNumber) for it in XML
          */
     public void testOneToManyRelationships() {
         EntityManager em = createEntityManager("ddlGeneration");
diff --git a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/xml/metadatacomplete/EntityMappingsMetadataCompleteJUnitTestCase.java b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/xml/metadatacomplete/EntityMappingsMetadataCompleteJUnitTestCase.java
index 6e327c3..abd22f9 100644
--- a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/xml/metadatacomplete/EntityMappingsMetadataCompleteJUnitTestCase.java
+++ b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/xml/metadatacomplete/EntityMappingsMetadataCompleteJUnitTestCase.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2011, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2011, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -62,7 +62,7 @@
      *  - Screwdriver : metadata-complete=false (default)
      *  - Tool : metadata-complete=true
      *
-     *  There is NO <xml-mapping-metadata-mapping> setting.
+     *  There is NO {@code <xml-mapping-metadata-mapping>} setting.
      */
     public void testMetadataComplete() {
         ServerSession session = getServerSession("METADATA_COMPLETE");
@@ -132,7 +132,7 @@
      *  - Screwdriver : metadata-complete=false (default)
      *  - Tool : metadata-complete=false
      *
-     *  There is <xml-mapping-metadata-mapping> setting meaning the settings
+     *  There is {@code <xml-mapping-metadata-mapping>} setting meaning the settings
      *  above should be ignored.
      */
     public void testXMLMappingMetadataComplete() {
diff --git a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa22/metadata/MetadataASMFactoryTest.java b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa22/metadata/MetadataASMFactoryTest.java
index 518c3b1..a4c43bc 100644
--- a/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa22/metadata/MetadataASMFactoryTest.java
+++ b/jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa22/metadata/MetadataASMFactoryTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2015, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -61,7 +61,7 @@
     }
 
     /**
-     * Check meta-annotations graph with cycle A -> B -> C -> A
+     * Check meta-annotations graph with cycle A -{@literal >} B -{@literal >} C -{@literal >} A
      */
     public void testAnnotationsWithCycle() {
         try {
@@ -76,7 +76,7 @@
     }
 
     /**
-     * Check meta-annotations graph with primitive cycle Self -> Self
+     * Check meta-annotations graph with primitive cycle Self -{@literal >} Self
      */
     public void testAnnotationsWithPrimitiveCycle() {
         try {
diff --git a/jpa/eclipselink.jpa.wdf.test/src/it/java/org/eclipse/persistence/testing/framework/wdf/server/SerializableFailure.java b/jpa/eclipselink.jpa.wdf.test/src/it/java/org/eclipse/persistence/testing/framework/wdf/server/SerializableFailure.java
index 8c6ba48..ee9da73 100644
--- a/jpa/eclipselink.jpa.wdf.test/src/it/java/org/eclipse/persistence/testing/framework/wdf/server/SerializableFailure.java
+++ b/jpa/eclipselink.jpa.wdf.test/src/it/java/org/eclipse/persistence/testing/framework/wdf/server/SerializableFailure.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2005, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2005, 2021 Oracle and/or its affiliates. All rights reserved.
  * Copyright (c) 2005, 2015 SAP. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
@@ -35,7 +35,7 @@
 
     /**
      * Create a SerializableFailure object from an org.junit.runner.notification.Failure object.
-     * @param the failure object to be converted
+     * @param failure failure object to be converted
      * @return a SerializableFailure object converted from an org.junit.runner.notification.Failure object
      */
     public static SerializableFailure create(Failure failure) {
diff --git a/jpa/eclipselink.jpa.wdf.test/src/it/java/org/eclipse/persistence/testing/models/wdf/jpa1/employee/EmbeddedPropertyAccess.java b/jpa/eclipselink.jpa.wdf.test/src/it/java/org/eclipse/persistence/testing/models/wdf/jpa1/employee/EmbeddedPropertyAccess.java
index 4e5a954..d6170a3 100644
--- a/jpa/eclipselink.jpa.wdf.test/src/it/java/org/eclipse/persistence/testing/models/wdf/jpa1/employee/EmbeddedPropertyAccess.java
+++ b/jpa/eclipselink.jpa.wdf.test/src/it/java/org/eclipse/persistence/testing/models/wdf/jpa1/employee/EmbeddedPropertyAccess.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2005, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2005, 2021 Oracle and/or its affiliates. All rights reserved.
  * Copyright (c) 2005, 2015 SAP. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
@@ -46,7 +46,7 @@
     }
 
     /**
-     * @param date
+     * @param aDate
      *            The date to set.
      */
     public void setDate(Date aDate) {
diff --git a/jpa/eclipselink.jpa.wdf.test/src/it/java/org/eclipse/persistence/testing/models/wdf/jpa1/node/Node.java b/jpa/eclipselink.jpa.wdf.test/src/it/java/org/eclipse/persistence/testing/models/wdf/jpa1/node/Node.java
index fd88b11..1814636 100644
--- a/jpa/eclipselink.jpa.wdf.test/src/it/java/org/eclipse/persistence/testing/models/wdf/jpa1/node/Node.java
+++ b/jpa/eclipselink.jpa.wdf.test/src/it/java/org/eclipse/persistence/testing/models/wdf/jpa1/node/Node.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2005, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2005, 2021 Oracle and/or its affiliates. All rights reserved.
  * Copyright (c) 2005, 2015 SAP. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
@@ -110,7 +110,7 @@
     }
 
     /**
-     * @param parent
+     * @param aParent
      *            The parent to set.
      */
     public void setParent(Node aParent) {
diff --git a/jpa/eclipselink.jpa.wdf.test/src/it/java/org/eclipse/persistence/testing/tests/wdf/jpa1/entitymanager/TestFlush.java b/jpa/eclipselink.jpa.wdf.test/src/it/java/org/eclipse/persistence/testing/tests/wdf/jpa1/entitymanager/TestFlush.java
index 8c3bc2c..ffb61eb 100644
--- a/jpa/eclipselink.jpa.wdf.test/src/it/java/org/eclipse/persistence/testing/tests/wdf/jpa1/entitymanager/TestFlush.java
+++ b/jpa/eclipselink.jpa.wdf.test/src/it/java/org/eclipse/persistence/testing/tests/wdf/jpa1/entitymanager/TestFlush.java
@@ -449,7 +449,7 @@
      * <li>Read Project proj1 and remove it.</li>
      * <li>Read Employee emp1 with relationship to proj1 (lazy loading).</li>
      * <li>Assign the set of emp1's projects to a new employee emp2 (forces implicit loading on flush).</li>
-     * <li>Flush -> IllegalStateException expected because of relation emp2 -> proj1 (removed).</li>
+     * <li>Flush -{@literal >} IllegalStateException expected because of relation emp2 -{@literal >} proj1 (removed).</li>
      * </ul>
      */
     @Test
diff --git a/jpa/eclipselink.jpa.wdf.test/src/it/java/org/eclipse/persistence/testing/tests/wdf/jpa1/query/TestExtendedQueries.java b/jpa/eclipselink.jpa.wdf.test/src/it/java/org/eclipse/persistence/testing/tests/wdf/jpa1/query/TestExtendedQueries.java
index df19bfd..5512e0d 100644
--- a/jpa/eclipselink.jpa.wdf.test/src/it/java/org/eclipse/persistence/testing/tests/wdf/jpa1/query/TestExtendedQueries.java
+++ b/jpa/eclipselink.jpa.wdf.test/src/it/java/org/eclipse/persistence/testing/tests/wdf/jpa1/query/TestExtendedQueries.java
@@ -125,8 +125,6 @@
      * @param empID
      *            the ID of the employee
      * @return a hobby for the given employee ID
-     * @throws Exception
-     *             is thrown if there are no hobbies left which have not already been assigned to this employee
      */
     protected Hobby getRandomHobby(int empID) {
         boolean matched = false;
diff --git a/jpa/eclipselink.jpa.wdf.test/src/it/java/org/eclipse/persistence/testing/tests/wdf/jpa1/relation/TestRelationshipsWithCache.java b/jpa/eclipselink.jpa.wdf.test/src/it/java/org/eclipse/persistence/testing/tests/wdf/jpa1/relation/TestRelationshipsWithCache.java
index b358585..35602e0 100644
--- a/jpa/eclipselink.jpa.wdf.test/src/it/java/org/eclipse/persistence/testing/tests/wdf/jpa1/relation/TestRelationshipsWithCache.java
+++ b/jpa/eclipselink.jpa.wdf.test/src/it/java/org/eclipse/persistence/testing/tests/wdf/jpa1/relation/TestRelationshipsWithCache.java
@@ -42,7 +42,7 @@
 import org.junit.Test;
 
 /**
- * Testing relations in combination with object cache. Test cases generated by all-pairs testing tool: <li>ToManyFK, eager,
+ * Testing relations in combination with object cache. Test cases generated by all-pairs testing tool: <ul><li>ToManyFK, eager,
  * owning side right, cacheable both: testCostCenterEmployee</li> <li>ToOneFK, lazy, owning side left, cacheable right:
  * testMotorVehicleEmployee</li> <li>ToOneFK, eager, owning side right, cacheable both: testCubicleEmployee</li> <li>
  * ToManyJoinTable, eager, owning side left, cacheable right: testBicycleEmployee</li> <li>ToManyJoinTable, lazy, owning side
diff --git a/jpa/org.eclipse.persistence.jpa.jpql/pom.xml b/jpa/org.eclipse.persistence.jpa.jpql/pom.xml
index 48c3f76..6f1c684 100644
--- a/jpa/org.eclipse.persistence.jpa.jpql/pom.xml
+++ b/jpa/org.eclipse.persistence.jpa.jpql/pom.xml
@@ -30,10 +30,6 @@
         <relativePath>../../pom.xml</relativePath>
     </parent>
 
-    <properties>
-        <comp.xdoclint>-Xdoclint:all,-missing</comp.xdoclint>
-    </properties>
-
     <dependencies>
         <!--Test dependencies-->
         <dependency>
diff --git a/jpa/org.eclipse.persistence.jpa.modelgen/src/test/java/org/eclipse/persistence/jpa/test/modelgen/TestProcessor.java b/jpa/org.eclipse.persistence.jpa.modelgen/src/test/java/org/eclipse/persistence/jpa/test/modelgen/TestProcessor.java
index c027ee9..23eb83c 100644
--- a/jpa/org.eclipse.persistence.jpa.modelgen/src/test/java/org/eclipse/persistence/jpa/test/modelgen/TestProcessor.java
+++ b/jpa/org.eclipse.persistence.jpa.modelgen/src/test/java/org/eclipse/persistence/jpa/test/modelgen/TestProcessor.java
@@ -207,7 +207,7 @@
      * Verify logging output suppression
      * @param testName name of the test
      * @param pu persistence unit {@code String}
-     * @param whether there should be logging messages in the output or not
+     * @param haveMsgs there should be logging messages in the output or not
      * @param options compiler options
      * @throws Exception
      */
diff --git a/jpa/org.eclipse.persistence.jpa.test.framework/src/main/java/org/eclipse/persistence/testing/framework/junit/JUnitTestCase.java b/jpa/org.eclipse.persistence.jpa.test.framework/src/main/java/org/eclipse/persistence/testing/framework/junit/JUnitTestCase.java
index edc8774..4200c1b 100644
--- a/jpa/org.eclipse.persistence.jpa.test.framework/src/main/java/org/eclipse/persistence/testing/framework/junit/JUnitTestCase.java
+++ b/jpa/org.eclipse.persistence.jpa.test.framework/src/main/java/org/eclipse/persistence/testing/framework/junit/JUnitTestCase.java
@@ -363,7 +363,7 @@
                 serverPlatform = new JEEPlatform();
             } else {
                 try {
-                    serverPlatform = (ServerPlatform)Class.forName(platformClass).newInstance();
+                    serverPlatform = (ServerPlatform)Class.forName(platformClass).getConstructor().newInstance();
                 } catch (Exception notFound) {
                     throw new RuntimeException(notFound);
                 }
diff --git a/jpa/org.eclipse.persistence.jpa/src/main/java/org/eclipse/persistence/internal/jpa/deployment/BeanValidationInitializationHelper.java b/jpa/org.eclipse.persistence.jpa/src/main/java/org/eclipse/persistence/internal/jpa/deployment/BeanValidationInitializationHelper.java
index 069fca0..24c53d5 100644
--- a/jpa/org.eclipse.persistence.jpa/src/main/java/org/eclipse/persistence/internal/jpa/deployment/BeanValidationInitializationHelper.java
+++ b/jpa/org.eclipse.persistence.jpa/src/main/java/org/eclipse/persistence/internal/jpa/deployment/BeanValidationInitializationHelper.java
@@ -93,7 +93,7 @@
          * @param validationGroups Array of "," deliminated fully qualified class names
          * @param appClassLoader The classloader for application
          * @return Array of classes corresponding to classnames in given <code>validationGroups</code>.
-         *         <code>null<code> if given <code>validationGroups</code> is null or empty
+         *         <code>null</code> if given <code>validationGroups</code> is null or empty
          */
         private Class[] translateValidationGroups(String validationGroups, ClassLoader appClassLoader) {
             Class[] validationGroupsClasses = null;
diff --git a/jpa/org.eclipse.persistence.jpa/src/main/java/org/eclipse/persistence/internal/jpa/metadata/accessors/objects/MetadataAnnotatedElement.java b/jpa/org.eclipse.persistence.jpa/src/main/java/org/eclipse/persistence/internal/jpa/metadata/accessors/objects/MetadataAnnotatedElement.java
index cbd7486..834bf60 100644
--- a/jpa/org.eclipse.persistence.jpa/src/main/java/org/eclipse/persistence/internal/jpa/metadata/accessors/objects/MetadataAnnotatedElement.java
+++ b/jpa/org.eclipse.persistence.jpa/src/main/java/org/eclipse/persistence/internal/jpa/metadata/accessors/objects/MetadataAnnotatedElement.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -118,8 +118,8 @@
      * This is a list of class/type names from the class/field/method signature.
      * The size of the list varies depending on how many generics are present,
      * i.e.
-     * - Map<String, Long> -> ["java.util.Map", "java.lang.String", "java.lang.Long"]
-     * - Beverage<T> extends Object -> [T, :, java.lang.Object, java.lang.Object]
+     * - {@code Map<String, Long> -> ["java.util.Map", "java.lang.String", "java.lang.Long"]}
+     * - {@code Beverage<T> extends Object -> [T, :, java.lang.Object, java.lang.Object]}
      */
     private List<String> m_genericType;
 
diff --git a/jpa/org.eclipse.persistence.jpa/src/main/java/org/eclipse/persistence/internal/jpa/metadata/accessors/objects/MetadataAsmFactory.java b/jpa/org.eclipse.persistence.jpa/src/main/java/org/eclipse/persistence/internal/jpa/metadata/accessors/objects/MetadataAsmFactory.java
index 222aac7..164d872 100644
--- a/jpa/org.eclipse.persistence.jpa/src/main/java/org/eclipse/persistence/internal/jpa/metadata/accessors/objects/MetadataAsmFactory.java
+++ b/jpa/org.eclipse.persistence.jpa/src/main/java/org/eclipse/persistence/internal/jpa/metadata/accessors/objects/MetadataAsmFactory.java
@@ -575,7 +575,7 @@
     /**
      * Process the byte-code argument description and return the array of Java
      * class names. i.e.
-     * "(Lorg/foo/Bar;Z)Ljava/lang/Boolean;"=>[org.foo.Bar,boolean
+     * "(Lorg/foo/Bar;Z)Ljava/lang/Boolean;"={@literal >}[org.foo.Bar,boolean
      * ,java.lang.Boolean]
      */
     private static List<String> processDescription(String desc, boolean isGeneric) {
diff --git a/jpa/org.eclipse.persistence.jpa/src/main/java/org/eclipse/persistence/internal/jpa/metadata/xml/XMLEntityMappingsReader.java b/jpa/org.eclipse.persistence.jpa/src/main/java/org/eclipse/persistence/internal/jpa/metadata/xml/XMLEntityMappingsReader.java
index 88f83d1..5c51c95 100644
--- a/jpa/org.eclipse.persistence.jpa/src/main/java/org/eclipse/persistence/internal/jpa/metadata/xml/XMLEntityMappingsReader.java
+++ b/jpa/org.eclipse.persistence.jpa/src/main/java/org/eclipse/persistence/internal/jpa/metadata/xml/XMLEntityMappingsReader.java
@@ -431,10 +431,7 @@
      * hence works for the case where the schema is shipped as part of EclipseLink
      *
      * @param unmarshaller
-     * @param schemaName
-     * @param validateORMSchema
-     * @throws IOException
-     * @throws SAXException
+     * @param schema
      */
     private static void useLocalSchemaForUnmarshaller(XMLUnmarshaller unmarshaller, Schema schema) {
         try {
diff --git a/jpa/org.eclipse.persistence.jpa/src/main/java/org/eclipse/persistence/internal/jpa/metamodel/ManagedTypeImpl.java b/jpa/org.eclipse.persistence.jpa/src/main/java/org/eclipse/persistence/internal/jpa/metamodel/ManagedTypeImpl.java
index d179257..0c9a3b3 100644
--- a/jpa/org.eclipse.persistence.jpa/src/main/java/org/eclipse/persistence/internal/jpa/metamodel/ManagedTypeImpl.java
+++ b/jpa/org.eclipse.persistence.jpa/src/main/java/org/eclipse/persistence/internal/jpa/metamodel/ManagedTypeImpl.java
@@ -712,7 +712,6 @@
      * @param attributeElementType - the java element or basic element type
      * @param aReturnCollectionType - the plural return type
      * @throws IllegalArgumentException if either type is wrong
-     * @return void
      */
     private void verifyAttributeTypeAndReturnType(Attribute anAttribute, Class attributeElementType, CollectionType aReturnCollectionType) {
         // Check for plural or singular attribute
@@ -1115,7 +1114,7 @@
      * Handle the case where we were unable to determine the element type of the plural attribute.
      * Normally this function is never required and should have a code coverage of 0%.
      * @param managedType
-     * @param colMapping
+     * @param collectionMapping
      * @param validation
      */
     private AttributeImpl initializePluralAttributeTypeNotFound(ManagedTypeImpl managedType, CollectionMapping collectionMapping, boolean validation) {
diff --git a/jpa/org.eclipse.persistence.jpa/src/main/java/org/eclipse/persistence/internal/jpa/metamodel/MetamodelImpl.java b/jpa/org.eclipse.persistence.jpa/src/main/java/org/eclipse/persistence/internal/jpa/metamodel/MetamodelImpl.java
index 6f1755b..99ec4ee 100644
--- a/jpa/org.eclipse.persistence.jpa/src/main/java/org/eclipse/persistence/internal/jpa/metamodel/MetamodelImpl.java
+++ b/jpa/org.eclipse.persistence.jpa/src/main/java/org/eclipse/persistence/internal/jpa/metamodel/MetamodelImpl.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2011, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2011, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -159,7 +159,7 @@
      * Java SE (unmanaged) persistence unit.
      * This may occur on certain configurations of Spring or on Java EE 6 Web Profile implementations that are not in compliance
      * with the specification.
-     * See <link>http://bugs.eclipse.org/338837</link>
+     * See http://bugs.eclipse.org/338837
      * @param aType
      * @param clazz
      * @param metamodelType
diff --git a/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/server/latest/ServerCrudLatestTest.java b/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/server/latest/ServerCrudLatestTest.java
index b39502b..6838b67 100644
--- a/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/server/latest/ServerCrudLatestTest.java
+++ b/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/server/latest/ServerCrudLatestTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2014, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -21,7 +21,7 @@
 
 /**
  * ServerCrudTest modified for JPARS v2.0.
- * {@see ServerCrudTest}
+ * {@link org.eclipse.persistence.jpars.test.server.noversion.ServerCrudTest}
  *
  * @author Dmitry Kornilov
  * @since EclipseLink 2.6.0
diff --git a/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/server/latest/ServerEmployeeLatestTest.java b/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/server/latest/ServerEmployeeLatestTest.java
index 5613d40..6912a7b 100644
--- a/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/server/latest/ServerEmployeeLatestTest.java
+++ b/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/server/latest/ServerEmployeeLatestTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2014, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -19,7 +19,7 @@
 
 /**
  * ServerEmployeeTest from JPARS 2.0 adapted for 'latest' version.
- * {@see ServerEmployeeTest}
+ * {@link org.eclipse.persistence.jpars.test.server.noversion.ServerEmployeeTest}
  *
  * @author Dmitry Kornilov
  * @since EclipseLink 2.6.0
diff --git a/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/server/latest/ServerTravelerLatestTest.java b/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/server/latest/ServerTravelerLatestTest.java
index 88ba4f5..a91e306 100644
--- a/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/server/latest/ServerTravelerLatestTest.java
+++ b/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/server/latest/ServerTravelerLatestTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2014, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -18,8 +18,8 @@
 import org.junit.BeforeClass;
 
 /**
- * ServerTravelerNoVersionTest adapted for 'latest' version.
- * {@see ServerTravelerNoVersionTest}
+ * ServerTravelerTest adapted for 'latest' version.
+ * {@link org.eclipse.persistence.jpars.test.server.noversion.ServerTravelerTest}
  *
  * @author Dmitry Kornilov
  * @since EclipseLink 2.6.0
diff --git a/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/server/v1/ServerCrudV1Test.java b/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/server/v1/ServerCrudV1Test.java
index 421b0ab..7b77b2a 100644
--- a/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/server/v1/ServerCrudV1Test.java
+++ b/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/server/v1/ServerCrudV1Test.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2014, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -20,7 +20,7 @@
 
 /**
  * ServerCrudTest modified for JPARS v1.0.
- * {@see ServerCrudTest}
+ * {@link ServerCrudTest}
  *
  * @author Dmitry Kornilov
  * @since EclipseLink 2.6.0
diff --git a/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/server/v1/ServerEmployeeV1Test.java b/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/server/v1/ServerEmployeeV1Test.java
index a4299c0..640d482 100644
--- a/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/server/v1/ServerEmployeeV1Test.java
+++ b/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/server/v1/ServerEmployeeV1Test.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2014, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -19,7 +19,7 @@
 
 /**
  * ServerEmployeeTest adapted for JPARS 1.0.
- * {@see ServerEmployeeTest}
+ * {@link ServerEmployeeTest}
  *
  * @author Dmitry Kornilov
  * @since EclipseLink 2.6.0
diff --git a/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/server/v1/ServerTravelerV1Test.java b/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/server/v1/ServerTravelerV1Test.java
index a22534e..9c1d52b 100644
--- a/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/server/v1/ServerTravelerV1Test.java
+++ b/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/server/v1/ServerTravelerV1Test.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2014, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -19,7 +19,7 @@
 
 /**
  * ServerTravelerNoVersionTest adapted for JPARS 1.0.
- * {@see ServerTravelerNoVersionTest}
+ * {@link ServerTravelerTest}
  *
  * @author Dmitry Kornilov
  * @since EclipseLink 2.6.0
diff --git a/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/server/v2/ServerCrudV2Test.java b/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/server/v2/ServerCrudV2Test.java
index 5eccea7..1596e20 100644
--- a/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/server/v2/ServerCrudV2Test.java
+++ b/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/server/v2/ServerCrudV2Test.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2014, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -26,7 +26,7 @@
 
 /**
  * ServerCrudTest modified for JPARS v2.0.
- * {@see ServerCrudTest}
+ * {@link ServerCrudTest}
  *
  * @author Dmitry Kornilov
  * @since EclipseLink 2.6.0
diff --git a/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/server/v2/ServerEmployeeV2Test.java b/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/server/v2/ServerEmployeeV2Test.java
index dc53961..2484a29 100644
--- a/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/server/v2/ServerEmployeeV2Test.java
+++ b/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/server/v2/ServerEmployeeV2Test.java
@@ -40,7 +40,7 @@
 
 /**
  * ServerEmployeeTest from JPARS 1.0 adapted for version 2.0.
- * {@see ServerEmployeeTest}
+ * {@link ServerEmployeeTest}
  *
  * @author Dmitry Kornilov
  * @since EclipseLink 2.6.0
diff --git a/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/server/v2/ServerTravelerV2Test.java b/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/server/v2/ServerTravelerV2Test.java
index d0c5964..d8611a6 100644
--- a/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/server/v2/ServerTravelerV2Test.java
+++ b/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/server/v2/ServerTravelerV2Test.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2014, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -29,7 +29,7 @@
 
 /**
  * ServerTravelerNoVersionTest adapted for JPARS 2.0.
- * {@see ServerTravelerNoVersionTest}
+ * {@link org.eclipse.persistence.jpars.test.server.noversion.ServerTravelerTest}
  *
  * @author Dmitry Kornilov
  * @since EclipseLink 2.6.0
diff --git a/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/service/latest/EmployeeLatestTest.java b/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/service/latest/EmployeeLatestTest.java
index 4ad12d3..1fd9e1c 100644
--- a/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/service/latest/EmployeeLatestTest.java
+++ b/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/service/latest/EmployeeLatestTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2014, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -19,7 +19,7 @@
 
 /**
  * EmployeeTest adapted for JPARS 2.0.
- * {@see EmployeeTest}
+ * {@link org.eclipse.persistence.jpars.test.service.noversion.EmployeeTest}
  *
  * @author Dmitry Kornilov
  * @since EclipseLink 2.6.0
diff --git a/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/service/latest/MarshalUnmarshalLatestTest.java b/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/service/latest/MarshalUnmarshalLatestTest.java
index bca16dd..006681d 100644
--- a/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/service/latest/MarshalUnmarshalLatestTest.java
+++ b/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/service/latest/MarshalUnmarshalLatestTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2014, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -19,7 +19,7 @@
 
 /**
  * MarshalUnmarshalTest adapted for JPARS 2.0.
- * {@see MarshalUnmarshalTest}
+ * {@link org.eclipse.persistence.jpars.test.service.noversion.MarshalUnmarshalTest}
  *
  * @author Dmitry Kornilov
  * @since EclipseLink 2.6.0
diff --git a/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/service/v1/EmployeeV1Test.java b/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/service/v1/EmployeeV1Test.java
index 32503dd..ba225f5 100644
--- a/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/service/v1/EmployeeV1Test.java
+++ b/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/service/v1/EmployeeV1Test.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2014, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -19,7 +19,7 @@
 
 /**
  * EmployeeTest adapted for JPARS 1.0.
- * {@see EmployeeTest}
+ * {@link EmployeeTest}
  *
  * @author Dmitry Kornilov
  * @since EclipseLink 2.6.0
diff --git a/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/service/v1/MarshalUnmarshalV1Test.java b/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/service/v1/MarshalUnmarshalV1Test.java
index a9130d1..4b3a606 100644
--- a/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/service/v1/MarshalUnmarshalV1Test.java
+++ b/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/service/v1/MarshalUnmarshalV1Test.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2014, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -19,7 +19,7 @@
 
 /**
  * MarshalUnmarshalTest adapted for JPARS 1.0.
- * {@see MarshalUnmarshalTest}
+ * {@link MarshalUnmarshalTest}
  *
  * @author Dmitry Kornilov
  * @since EclipseLink 2.6.0.
diff --git a/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/service/v2/EmployeeV2Test.java b/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/service/v2/EmployeeV2Test.java
index 5a250e5..63e9115 100644
--- a/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/service/v2/EmployeeV2Test.java
+++ b/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/service/v2/EmployeeV2Test.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2014, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -19,7 +19,7 @@
 
 /**
  * EmployeeTest adapted for JPARS 2.0.
- * {@see EmployeeTest}
+ * {@link EmployeeTest}
  *
  * @author Dmitry Kornilov
  * @since EclipseLink 2.6.0
diff --git a/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/service/v2/MarshalUnmarshalV2Test.java b/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/service/v2/MarshalUnmarshalV2Test.java
index 5afe476..72fee5f 100644
--- a/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/service/v2/MarshalUnmarshalV2Test.java
+++ b/jpa/org.eclipse.persistence.jpars/src/it/java/org/eclipse/persistence/jpars/test/service/v2/MarshalUnmarshalV2Test.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2014, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -41,7 +41,7 @@
 
 /**
  * MarshalUnmarshalTest adapted for JPARS 2.0.
- * {@see MarshalUnmarshalTest}
+ * {@link org.eclipse.persistence.jpars.test.service.noversion.MarshalUnmarshalTest}
  *
  * @author Dmitry Kornilov
  * @since EclipseLink 2.6.0
diff --git a/moxy/org.eclipse.persistence.moxy/pom.xml b/moxy/org.eclipse.persistence.moxy/pom.xml
index 3ae45bc..8bf91e5 100644
--- a/moxy/org.eclipse.persistence.moxy/pom.xml
+++ b/moxy/org.eclipse.persistence.moxy/pom.xml
@@ -32,7 +32,6 @@
 
     <properties>
         <comp.xlint>-Xlint:all,-rawtypes,-unchecked,-serial,-exports</comp.xlint>
-        <comp.xdoclint>-Xdoclint:-missing</comp.xdoclint>
 
         <test-skip-moxy-jaxb-srg>${skipTests}</test-skip-moxy-jaxb-srg>
         <test-skip-moxy-jaxb>true</test-skip-moxy-jaxb>
diff --git a/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/JAXBEnumTypeConverter.java b/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/JAXBEnumTypeConverter.java
index cb20171..d9d7ad1 100644
--- a/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/JAXBEnumTypeConverter.java
+++ b/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/JAXBEnumTypeConverter.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -57,7 +57,6 @@
      * Convert all the class-name-based settings in this converter to actual
      * class-based settings. This method is used when converting a project
      * that has been built with class names to a project with classes.
-     * @param classLoader
      */
     @Override
     public void convertClassNamesToClasses(ClassLoader classLoader){
diff --git a/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/compiler/AnnotationsProcessor.java b/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/compiler/AnnotationsProcessor.java
index 974f6d7..70206cf 100644
--- a/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/compiler/AnnotationsProcessor.java
+++ b/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/compiler/AnnotationsProcessor.java
@@ -298,7 +298,6 @@
     /**
      * Generate TypeInfo instances for a given array of JavaClasses.
      *
-     * @param classes
      */
     void processClassesAndProperties(JavaClass[] classes, TypeMappingInfo[] typeMappingInfos) {
         init(classes, typeMappingInfos);
@@ -433,8 +432,6 @@
      * precedence over the annotation array; if there is an xml-element the
      * Array of Annotations will be ignored.
      *
-     * @param tmInfo
-     * @return
      */
     private java.lang.annotation.Annotation[] getAnnotations(TypeMappingInfo tmInfo) {
         if (tmInfo.getXmlElement() != null) {
@@ -544,8 +541,6 @@
      * this method have been modified (if necessary) postBuildTypeInfo and
      * processJavaClasses should be called to finish processing.
      *
-     * @param javaClasses
-     * @return
      */
     public Map<String, TypeInfo> preBuildTypeInfo(JavaClass[] javaClasses) {
         for (JavaClass javaClass : javaClasses) {
@@ -762,7 +757,6 @@
      * is typically called after init and preBuildTypeInfo have
      * been called.
      *
-     * @param javaClasses
      * @return updated array of JavaClasses, made up of the original classes
      * plus any additional ones
      */
@@ -795,8 +789,6 @@
      * instances. This method assumes that init, preBuildTypeInfo, and
      * postBuildTypeInfo have been called.
      *
-     * @param allClasses
-     * @return
      */
     private Map<String, TypeInfo> buildTypeInfo(JavaClass[] allClasses) {
         for (JavaClass javaClass : allClasses) {
@@ -1114,7 +1106,6 @@
     /**
      * Process a given TypeInfo instance's properties.
      *
-     * @param info
      */
     private void processTypeInfoProperties(JavaClass javaClass, TypeInfo info) {
         List<Property> properties = info.getPropertyList();
@@ -1176,8 +1167,6 @@
      * Process any additional classes, such as inner classes, @XmlRegistry or
      * from @XmlSeeAlso.
      *
-     * @param classes
-     * @return
      */
     private JavaClass[] processAdditionalClasses(JavaClass[] classes) {
         ArrayList<JavaClass> extraClasses = new ArrayList<JavaClass>();
@@ -1316,8 +1305,6 @@
      *
      * See @XmlRegistry or @XmlSeeAlso.
      *
-     * @param javaClass
-     * @param classesToProcess
      */
     private void processClass(JavaClass javaClass, ArrayList<JavaClass> classesToProcess) {
         if (shouldGenerateTypeInfo(javaClass)) {
@@ -1340,7 +1327,6 @@
      * Process an @XmlSeeAlso annotation. TypeInfo instances will be created for
      * each class listed.
      *
-     * @param javaClass
      */
     private void processXmlSeeAlso(JavaClass javaClass, TypeInfo info) {
         // reflectively load @XmlSeeAlso class to avoid dependency
@@ -1375,8 +1361,6 @@
     /**
      * Process any factory methods.
      *
-     * @param javaClass
-     * @param info
      */
     private void processFactoryMethods(JavaClass javaClass, TypeInfo info) {
         JavaMethod factoryMethod = this.factoryMethods.get(javaClass.getRawName());
@@ -1399,8 +1383,6 @@
     /**
      * Process any package-level @XmlJavaTypeAdapters.
      *
-     * @param javaClass
-     * @param info
      */
     private void processPackageLevelAdapters(JavaClass javaClass, TypeInfo info) {
         JavaPackage pack = javaClass.getPackage();
@@ -1431,8 +1413,6 @@
     /**
      * Process any class-level @XmlJavaTypeAdapters.
      *
-     * @param javaClass
-     * @param info
      */
     private void processClassLevelAdapters(JavaClass javaClass, TypeInfo info) {
         if (helper.isAnnotationPresent(javaClass, XmlJavaTypeAdapter.class)) {
@@ -1453,8 +1433,6 @@
     /**
      * Process any @XmlSchemaType(s).
      *
-     * @param javaClass
-     * @param info
      */
     private void processSchemaTypes(JavaClass javaClass, TypeInfo info) {
         JavaPackage pack = javaClass.getPackage();
@@ -1472,8 +1450,6 @@
     /**
      * Process @XmlRootElement annotation on a given JavaClass.
      *
-     * @param javaClass
-     * @param info
      */
     private void processXmlRootElement(JavaClass javaClass, TypeInfo info) {
         if (helper.isAnnotationPresent(javaClass, XmlRootElement.class)) {
@@ -1488,8 +1464,6 @@
     /**
      * Process @XmlExtensible annotation on a given JavaClass.
      *
-     * @param javaClass
-     * @param info
      */
     private void processXmlExtensible(JavaClass javaClass, TypeInfo info) {
         if (helper.isAnnotationPresent(javaClass, XmlVirtualAccessMethods.class)) {
@@ -1507,9 +1481,6 @@
      * for pre-processing. Note that if no @XmlType annotation is present we
      * still create a new XmlType an set it on the TypeInfo.
      *
-     * @param javaClass
-     * @param info
-     * @param packageNamespace
      */
     private void preProcessXmlType(JavaClass javaClass, TypeInfo info, NamespaceInfo packageNamespace) {
         org.eclipse.persistence.jaxb.xmlmodel.XmlType xmlType = new org.eclipse.persistence.jaxb.xmlmodel.XmlType(); // 14 xmlType=XmlType - default settings: name=null, namespace=null, factoryClass=null, factoryMethod=null, propOrder=null.
@@ -1549,9 +1520,6 @@
      * has an XmlType set - typically via preProcessXmlType or XmlProcessor
      * override.
      *
-     * @param javaClass
-     * @param info
-     * @param packageNamespace
      */
     private void postProcessXmlType(JavaClass javaClass, TypeInfo info, PackageInfo packageNamespace) {
         // assumes that the TypeInfo has an XmlType set from
@@ -1614,9 +1582,6 @@
      * Process @XmlAccessorType annotation on a given JavaClass and update the
      * TypeInfo for pre-processing.
      *
-     * @param javaClass
-     * @param info
-     * @param packageNamespace
      */
     private void preProcessXmlAccessorType(JavaClass javaClass, TypeInfo info, NamespaceInfo packageNamespace) {
         org.eclipse.persistence.jaxb.xmlmodel.XmlAccessType xmlAccessType;
@@ -1631,7 +1596,6 @@
      * Post process XmlAccessorType. In some cases, such as @XmlSeeAlso classes,
      * the access type may not have been set
      *
-     * @param info
      */
     private void postProcessXmlAccessorType(TypeInfo info, PackageInfo packageNamespace) {
         if (!info.isSetXmlAccessType()) {
@@ -1658,9 +1622,6 @@
      * Process package and class @XmlAccessorOrder. Class level annotation
      * overrides a package level annotation.
      *
-     * @param javaClass
-     * @param info
-     * @param packageNamespace
      */
     private void preProcessXmlAccessorOrder(JavaClass javaClass, TypeInfo info, NamespaceInfo packageNamespace) {
         XmlAccessorOrder order = null;
@@ -1676,8 +1637,6 @@
      * TypeInfo has already had its order set (via annotations in
      * preProcessXmlAccessorOrder or via xml metadata override in XMLProcessor).
      *
-     * @param info
-     * @param packageNamespace
      */
     private void postProcessXmlAccessorOrder(TypeInfo info, PackageInfo packageNamespace) {
         if (!info.isSetXmlAccessOrder()) {
@@ -1691,7 +1650,6 @@
     /**
      * Process @XmlElement annotation on a given property.
      *
-     * @param property
      */
     private void processXmlElement(Property property, TypeInfo info) {
 
@@ -1804,8 +1762,6 @@
     /**
      * Process @XmlID annotation on a given property
      *
-     * @param property
-     * @param info
      */
     private void processXmlID(Property property, JavaClass javaClass, TypeInfo info) {
         if (helper.isAnnotationPresent(property.getElement(), XmlID.class)) {
@@ -1817,7 +1773,6 @@
     /**
      * Process @XmlIDREF on a given property.
      *
-     * @param property
      */
     private void processXmlIDREF(Property property) {
         if (helper.isAnnotationPresent(property.getElement(), XmlIDREF.class)) {
@@ -1828,9 +1783,6 @@
     /**
      * Process @XmlJavaTypeAdapter on a given property.
      *
-     * @param property
-     * @param info
-     * @param javaClass
      */
     private void processXmlJavaTypeAdapter(Property property, TypeInfo info, JavaClass javaClass) {
         JavaClass adapterClass = null;
@@ -1883,8 +1835,6 @@
      * Store a QName (if necessary) based on a given TypeInfo's schema type
      * name.
      *
-     * @param javaClass
-     * @param info
      */
     private void processTypeQName(JavaClass javaClass, TypeInfo info, NamespaceInfo packageNamespace) {
         if(info.isTransient()) {
@@ -2253,8 +2203,6 @@
      * Validation and building of the XmlElement properties will be done during
      * finalizeProperties in the processChoiceProperty method.
      *
-     * @param javaHasAnnotations
-     * @return
      */
     private Property buildChoiceProperty(JavaHasAnnotations javaHasAnnotations) {
         Property choiceProperty = new Property(helper);
@@ -2355,10 +2303,6 @@
      * Each created Property is added to the owning Property's list of choice
      * properties.
      *
-     * @param choiceProperty
-     * @param info
-     * @param cls
-     * @param propertyType
      */
     private void processChoiceProperty(Property choiceProperty, TypeInfo info, JavaClass cls, JavaClass propertyType) {
         String propertyName = choiceProperty.getPropertyName();
@@ -2492,9 +2436,6 @@
      * inheritance (parent classes) and from parent class is reverse reference
      * via @XmlIDREF, @XmlPaths and @XmlElements to the some child classes.
      * In this phase type info is not complete (missing properties).
-     * @param javaClass
-     * @param typeInfo
-     * @return
      */
     private boolean preCheckXmlID(JavaClass javaClass, TypeInfo typeInfo) {
         ArrayList<Property> properties = getPropertiesForClass(javaClass, typeInfo);
@@ -2520,11 +2461,6 @@
      * performed during the finalize property phase via the
      * processReferenceProperty method.
      *
-     * @param info
-     * @param javaHasAnnotations
-     * @param propertyName
-     * @param ptype
-     * @return
      */
     private Property buildReferenceProperty(TypeInfo info, JavaHasAnnotations javaHasAnnotations, String propertyName, JavaClass ptype) {
         Property property = new Property(helper);
@@ -2566,10 +2502,6 @@
     /**
      * Build a reference property.
      *
-     * @param property
-     * @param info
-     * @param cls
-     * @return
      */
     private Property processReferenceProperty(Property property, TypeInfo info, JavaClass cls) {
 
@@ -2857,7 +2789,6 @@
      * for attribute transformers either a transformer class OR method name is
      * set (not both).
      *
-     * @param property
      */
     private void validateXmlTransformationProperty(Property property) {
         if (property.isSetXmlTransformation()) {
@@ -2909,9 +2840,6 @@
      * Compares a JavaModel JavaClass to a Class. Equality is based on the raw
      * name of the JavaClass compared to the canonical name of the Class.
      *
-     * @param src
-     * @param tgt
-     * @return
      */
     protected boolean areEquals(JavaClass src, Class tgt) {
         if (src == null || tgt == null) {
@@ -2983,9 +2911,6 @@
      * Compares a JavaModel JavaClass to a Class. Equality is based on the raw
      * name of the JavaClass compared to the canonical name of the Class.
      *
-     * @param src
-     * @param tgtCanonicalName
-     * @return
      */
     protected boolean areEquals(JavaClass src, String tgtCanonicalName) {
         if (src == null || tgtCanonicalName == null) {
@@ -3342,9 +3267,6 @@
      *
      * {@literal @XmlSchemaType(s)} annotation or xml-schema-type(s) metadata.
      *
-     * @param name
-     * @param namespace
-     * @param jClassQualifiedName
      */
     public void processSchemaType(String name, String namespace, String jClassQualifiedName) {
         this.userDefinedSchemaTypes.put(jClassQualifiedName, new QName(namespace, name));
@@ -3995,7 +3917,6 @@
     /**
      * Lazy load and return the map of global elements.
      *
-     * @return
      */
     public Map<QName, ElementDeclaration> getGlobalElements() {
         return this.elementDeclarations.get(XmlElementDecl.GLOBAL.class.getName());
@@ -4873,7 +4794,6 @@
      *
      * Map {@literal <String, Map<String, TypeInfo>>}
      *
-     * @param packageName
      * @return List of TypeInfo objects for a given package name
      */
     public Map<String, TypeInfo> getTypeInfosForPackage(String packageName) {
@@ -4892,7 +4812,6 @@
      * Set namespace override info from XML bindings file. This will typically
      * be called from the XMLProcessor.
      *
-     * @param packageToNamespaceMappings
      */
     public void setPackageToNamespaceMappings(HashMap<String, NamespaceInfo> packageToNamespaceMappings) {
         //this.packageToNamespaceMappings = packageToNamespaceMappings;
@@ -4958,7 +4877,6 @@
      * Convenience method which class pre and postBuildTypeInfo for a given set
      * of JavaClasses.
      *
-     * @param javaClasses
      */
     public void buildNewTypeInfo(JavaClass[] javaClasses) {
         preBuildTypeInfo(javaClasses);
@@ -4976,8 +4894,6 @@
      * place in MappingsGenerator's generateProject method, after the
      * descriptors and mappings have been generated.
      *
-     * @param jClass
-     * @param tInfo
      * @see XmlCustomizer
      * @see MappingsGenerator
      */
@@ -4991,7 +4907,6 @@
     /**
      * Lazy load the metadata logger.
      *
-     * @return
      */
     private JAXBMetadataLogger getLogger() {
         if (logger == null) {
@@ -5003,7 +4918,6 @@
     /**
      * Return the Helper object set on this processor.
      *
-     * @return
      */
     Helper getHelper() {
         return this.helper;
@@ -5041,7 +4955,6 @@
      * Convenience method for determining if a given JavaClass should be
      * processed as an ObjectFactory class.
      *
-     * @param javaClass
      * @return true if the JavaClass is annotated with @XmlRegistry or the map
      * of XmlRegistries contains a key equal to the JavaClass' qualified
      * name
@@ -5096,8 +5009,6 @@
      *
      * - DataHandler - byte[] - Byte[] - Image - Source - MimeMultipart
      *
-     * @param property
-     * @return
      */
     public boolean isMtomAttachment(Property property) {
         JavaClass ptype = property.getActualType();
diff --git a/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/compiler/Property.java b/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/compiler/Property.java
index bfcbf70..3fc9a11 100644
--- a/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/compiler/Property.java
+++ b/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/compiler/Property.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -181,7 +181,6 @@
      * original type will be set as required based on the XmlAdapter's
      * marshal method return type and input parameters.
      *
-     * @param adapterCls
      */
     public void setAdapterClass(JavaClass adapterCls) {
 
@@ -265,8 +264,6 @@
      * type. This method will typically be called when setting the type during
      * adapter processing.
      *
-     * @param newType
-     * @param parameterType
      */
     private void setTypeFromAdapterClass(JavaClass newType, JavaClass parameterType) {
         boolean isArray = this.getType().isArray() && !this.getType().getRawName().equals("byte[]");
@@ -612,7 +609,6 @@
     /**
      * Indicates if this property represents a choice property.
      *
-     * @return
      */
     public boolean isChoice() {
         return isChoice;
@@ -622,7 +618,6 @@
      * Set flag to indicate whether this property represents a choice
      * property.
      *
-     * @param choice
      */
     public void setChoice(boolean choice) {
         isChoice = choice;
@@ -631,7 +626,6 @@
     /**
      * Returns indicator for XmlAnyElement
      *
-     * @return
      */
     public boolean isAny() {
         return isAnyElement;
@@ -640,7 +634,6 @@
     /**
      * Set indicator for XmlAnyElement.
      *
-     * @param isAnyElement
      */
     public void setIsAny(boolean isAnyElement) {
         this.isAnyElement = isAnyElement;
@@ -649,7 +642,6 @@
     /**
      * Indicates if this Property is a reference property.
      *
-     * @return
      */
     public boolean isReference() {
         return isReference;
@@ -659,7 +651,6 @@
      * Set flag to indicate whether this property represents a reference
      * property.
      *
-     * @param isReference
      */
     public void setIsReference(boolean isReference) {
         this.isReference = isReference;
@@ -722,7 +713,6 @@
      * Return the generic type if it was set (collection or array item type) otherwise return the
      * type of this property
      *
-     * @return
      */
     public JavaClass getActualType() {
         if (genericType != null) {
@@ -736,7 +726,6 @@
      * the type has been changed via @XmlElement annotation and the
      * original type is desired.
      *
-     * @return
      */
     public JavaClass getOriginalType() {
         if (originalType == null) // in case of adapter which returns the same type - original type is the same as type
@@ -778,7 +767,6 @@
      * Set an XmlJavaTypeAdapter on this Property.  This call sets the adapterClass
      * property to the given adapter's value.
      *
-     * @param xmlJavaTypeAdapter
      * @see XmlJavaTypeAdapter
      */
     public void setXmlJavaTypeAdapter(XmlJavaTypeAdapter xmlJavaTypeAdapter) {
@@ -813,7 +801,6 @@
     /**
      * Set the XmlElementWrapper for this property.
      *
-     * @param xmlElementWrapper
      */
     public void setXmlElementWrapper(XmlElementWrapper xmlElementWrapper) {
         this.xmlElementWrapper = xmlElementWrapper;
@@ -822,7 +809,6 @@
     /**
      * Set the isXmlValue property.
      *
-     * @param isXmlValue
      */
     public void setIsXmlValue(boolean isXmlValue) {
         this.isXmlValue = isXmlValue;
@@ -831,7 +817,6 @@
     /**
      * Indicates if this property is an XmlValue.
      *
-     * @return
      */
     public boolean isXmlValue() {
         return this.isXmlValue;
@@ -840,7 +825,6 @@
     /**
      * Set the isXmlValueExtension property.
      *
-     * @param isXmlValueExtension
      */
     public void setIsXmlValueExtension(boolean isXmlValueExtension) {
         this.isXmlValueExtension = isXmlValueExtension;
@@ -849,7 +833,6 @@
     /**
      * Indicates if this property is an XmlValueExtension.
      *
-     * @return
      */
     public boolean isXmlValueExtension() {
         return this.isXmlValueExtension;
@@ -858,7 +841,6 @@
     /**
      * Set the isXmlList property.
      *
-     * @param isXmlList
      */
     public void setIsXmlList(boolean isXmlList) {
         this.isXmlList = isXmlList;
@@ -870,7 +852,6 @@
     /**
      * Indicates if this property is an XmlList.
      *
-     * @return
      */
     public boolean isXmlList() {
         return this.isXmlList;
@@ -911,7 +892,6 @@
     /**
      * Indicates if this property is an ID field.
      *
-     * @return
      */
     public boolean isXmlId() {
         return isXmlId;
@@ -920,7 +900,6 @@
     /**
      * Sets the indicator that identifies this property as an ID field.
      *
-     * @param isXmlId
      */
     public void setIsXmlId(boolean isXmlId) {
         this.isXmlId = isXmlId;
@@ -929,7 +908,6 @@
     /**
      * Indicates if this property is an ID extension field.
      *
-     * @return
      */
     public boolean isXmlIdExtension() {
         return isXmlIdExtension;
@@ -938,7 +916,6 @@
     /**
      * Sets the indicator that identifies this property as an ID extension field.
      *
-     * @param isXmlIdExtension
      */
     public void setIsXmlIdExtension(boolean isXmlIdExtension) {
         this.isXmlIdExtension = isXmlIdExtension;
@@ -947,7 +924,6 @@
     /**
      * Indicates if this property is a reference to an ID field.
      *
-     * @return
      */
     public boolean isXmlIdRef() {
         return isXmlIdRef;
@@ -957,7 +933,6 @@
      * Sets the indicator that identifies this property as a reference
      * to an ID field.
      *
-     * @param isXmlIdRef
      */
     public void setIsXmlIdRef(boolean isXmlIdRef) {
         this.isXmlIdRef = isXmlIdRef;
@@ -968,7 +943,6 @@
     /**
      * Used with XmlAnyElement.
      *
-     * @return
      */
     public boolean isLax() {
         return lax;
@@ -977,7 +951,6 @@
     /**
      * Used with XmlAnyElement.
      *
-     * @param b
      */
     public void setLax(boolean b) {
         lax = b;
@@ -987,7 +960,6 @@
      * Return the DomHandler class name.
      * Used with XmlAnyElement.
      *
-     * @return
      */
     public String getDomHandlerClassName() {
         return domHandlerClassName;
@@ -997,7 +969,6 @@
      * Set the DomHandler class name.
      * Used with XmlAnyElement.
      *
-     * @param domHandlerClassName
      */
     public void setDomHandlerClassName(String domHandlerClassName) {
         this.domHandlerClassName = domHandlerClassName;
@@ -1019,7 +990,6 @@
      * Return the generic type if it was set (collection or array item type) otherwise return the
      * type of this property
      *
-     * @return
      */
     public JavaClass getActualValueType() {
         if (valueGenericType != null) {
@@ -1065,7 +1035,6 @@
      * Return the XmlElements object set for this Property.  Typically
      * this will only be set if we are dealing with a 'choice'.
      *
-     * @return
      */
     public XmlElements getXmlElements() {
         return xmlElements;
@@ -1075,7 +1044,6 @@
      * Set the XmlElements object for this Property.  Typically
      * this will only be set if we are dealing with a 'choice'.
      *
-     * @param xmlElements
      */
     public void setXmlElements(XmlElements xmlElements) {
         this.xmlElements = xmlElements;
@@ -1085,7 +1053,6 @@
      * Return the choice properties set on this property.  Typically this
      * will only contain properties if we are dealing with a 'choice'.
      *
-     * @return
      */
     public Collection<Property> getChoiceProperties() {
         return this.choiceProperties;
@@ -1095,7 +1062,6 @@
      * Set the choice properties for this property.  Typically this
      * will only contain properties if we are dealing with a 'choice'.
      *
-     * @param properties
      */
     public void setChoiceProperties(Collection<Property> properties) {
         this.choiceProperties = properties;
@@ -1104,7 +1070,6 @@
     /**
      * Return the List of XmlElementRef(s) for this Property.
      *
-     * @return
      */
     public List<XmlElementRef> getXmlElementRefs() {
         return xmlElementRefs;
@@ -1113,7 +1078,6 @@
     /**
      * Set the List of XmlElementRef(s) for this Property.
      *
-     * @param xmlElementRefs
      */
     public void setXmlElementRefs(List<XmlElementRef> xmlElementRefs) {
         this.xmlElementRefs = xmlElementRefs;
@@ -1123,7 +1087,6 @@
      * Add an ElementDeclaration to the list of referenced elements. Typically this
      * will only contain ElementDeclarations if we are dealing with a 'reference'.
      *
-     * @param element
      */
     public void addReferencedElement(ElementDeclaration element) {
         if (referencedElements == null) {
@@ -1138,7 +1101,6 @@
      * Return the list of referenced elements.  Typically this will only
      * contain ElementDeclarations if we are dealing with a 'reference'.
      *
-     * @return
      */
     public List<ElementDeclaration> getReferencedElements() {
         return referencedElements;
@@ -1199,7 +1161,6 @@
     /**
      * Indicates if the isReadOnly flag was set via external metadata.
      *
-     * @return
      */
     public boolean isSetReadOnly() {
         return isReadOnly != null;
@@ -1227,7 +1188,6 @@
     /**
      * Indicates if the isWriteOnly flag was set via external metadata.
      *
-     * @return
      */
     public boolean isSetWriteOnly() {
         return isWriteOnly != null;
@@ -1255,7 +1215,6 @@
     /**
      * Indicates if the isCdata flag was set via external metadata.
      *
-     * @return
      */
     public boolean isSetCdata() {
         return isCdata != null;
@@ -1264,7 +1223,6 @@
     /**
      * Return the xpath for this property.
      *
-     * @return
      */
     public String getXmlPath() {
         return xmlPath;
@@ -1273,7 +1231,6 @@
     /**
      * Set the xpath for this property.
      *
-     * @param xmlPath
      */
     public void setXmlPath(String xmlPath) {
         this.xmlPath = xmlPath;
@@ -1282,7 +1239,6 @@
     /**
      * Indicates if an xpath is set for this property.
      *
-     * @return
      */
     public boolean isSetXmlPath() {
         return xmlPath != null;
@@ -1300,7 +1256,6 @@
     /**
      * Set the null policy for this property.
      *
-     * @param nullPolicy
      */
     public void setNullPolicy(XmlAbstractNullPolicy nullPolicy) {
         this.nullPolicy = nullPolicy;
@@ -1309,7 +1264,6 @@
     /**
      * Indicates if a null policy is set for this property.
      *
-     * @return
      */
     public boolean isSetNullPolicy() {
         return nullPolicy != null;
@@ -1324,7 +1278,6 @@
      * - isSetNullPolicy {@literal &&} xsi-nil-represents-null == 'true'
      * - isSetNullPolicy {@literal &&} null-representation-for-xml == 'XSI_NIL'
      *
-     * @return
      */
     public boolean shouldSetNillable() {
         if (isNillable()) {
@@ -1339,7 +1292,6 @@
     /**
      * Return the Map of user-defined properties.
      *
-     * @return
      */
     public Map<Object, Object> getUserProperties() {
         return userProperties;
@@ -1348,7 +1300,6 @@
     /**
      * Set the Map of user-defined properties.
      *
-     * @param userProperties
      */
     public void setUserProperties(Map<Object, Object> userProperties) {
         this.userProperties = userProperties;
@@ -1378,7 +1329,6 @@
      * the XmlTransformation will be used to construct an
      * XmlTransformationMapping.
      *
-     * @param xmlTransformation
      */
     public void setXmlTransformation(XmlTransformation xmlTransformation) {
         this.xmlTransformation = xmlTransformation;
@@ -1406,7 +1356,6 @@
     /**
      * Set flag that indicates if this property represents an XmlTransformation.
      *
-     * @param isXmlTransformation
      */
     public void setIsXmlTransformation(boolean isXmlTransformation) {
         this.isXmlTransformation = isXmlTransformation;
diff --git a/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/compiler/SchemaGenerator.java b/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/compiler/SchemaGenerator.java
index 251f6f9..dcea6d8 100644
--- a/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/compiler/SchemaGenerator.java
+++ b/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/compiler/SchemaGenerator.java
@@ -2439,7 +2439,7 @@
      * Replaces Java regexes with their respective XML Regex Shorthands, where applicable.
      * <p>
      * Recognized are Java regexes for the following XML Shorthands, and their negations:
-     * <blockquote><pre>
+     * <blockquote><pre>{@code
      * \i - Matches any character that may be the first character of an XML name.
      *      "[_:A-Za-z]"
      * \c - Matches any character that may occur after the first character in an XML name.
@@ -2473,13 +2473,13 @@
      *      }\\u0E30\\u0E32\\u0E33\\u0E45\\u0EB0\\u0EB2\\u0EB3]]*)|(?s:.))"
      * \R - Carriage return.
      *      "(?:(?>\\u000D\\u000A)|[\\u000A\\u000B\\u000C\\u000D\\u0085\\u2028\\u2029])"
-     * </pre></blockquote>
+     * }</pre></blockquote>
      *
      * CAUTION - ORDER SENSITIVE: Longer patterns should come first, because they may contain one of the shorter pattern.
      * <p>
      * Changes to this class should also be reflected in the opposite {@link org.eclipse.persistence.jaxb.plugins.BeanValidationPlugin.RegexMutator RegexMutator} class within XJC BeanValidation Plugin.
      *
-     * @see <a href="http://stackoverflow.com/questions/4304928/unicode-equivalents-for-w-and-b-in-java-regular-expressions"/>tchrist's work</a>
+     * @see <a href="http://stackoverflow.com/questions/4304928/unicode-equivalents-for-w-and-b-in-java-regular-expressions">tchrist's work</a>
      * @see <a href="http://www.regular-expressions.info/shorthand.html#xml">Special shorthands in XML Schema.</a>
      */
     private static final class RegexMutator {
diff --git a/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/compiler/TypeInfo.java b/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/compiler/TypeInfo.java
index ad7d515..b2d11a3 100644
--- a/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/compiler/TypeInfo.java
+++ b/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/compiler/TypeInfo.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -573,7 +573,7 @@
 
     /**
      * Convenience method that adds non-null, non-transient properties to a given
-     * List<Property>.  The propertyName parameter is used to lookup the Property.
+     * {@code List<Property>}.  The propertyName parameter is used to lookup the Property.
      * If propertyNamesCopy is non-null, the Property will be removed from that
      * List.  Any additional properties that exist for propertyName (as in the
      * case of multiple mappings to the same field) will be added as well.
diff --git a/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/javamodel/AnnotationProxy.java b/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/javamodel/AnnotationProxy.java
index 82d280c..9a05322 100644
--- a/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/javamodel/AnnotationProxy.java
+++ b/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/javamodel/AnnotationProxy.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -53,7 +53,7 @@
      * in the <code>Map</code> based on the return type of the associated
      * <code>Method</code> Note that the preferred method of obtaining an
      * instance of this proxy class is via
-     * <code>getProxy(Map, Class<A>, ClassLoader, ConversionManager)</code>
+     * {@code getProxy(Map, Class<A>, ClassLoader, ConversionManager)}
      *
      * @param components
      *            <code>Map</code> of method name to value pairs
diff --git a/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/plugins/BeanValidationPlugin.java b/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/plugins/BeanValidationPlugin.java
index d33efaa..3cd3d55 100644
--- a/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/plugins/BeanValidationPlugin.java
+++ b/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/plugins/BeanValidationPlugin.java
@@ -259,6 +259,7 @@
      * Processes an xsd value in form of xsd attribute from extended base.
      * <p>
      * Example:
+     * <pre>{@code
      * <xsd:complexType name="Employee">
      * <xsd:simpleContent>
      * <xsd:extension base="a:ShortId">  <- xsd extension base
@@ -272,7 +273,7 @@
      * <xsd:minLength value="1"/>        <- This is a special field that is added to the generated class, called "value" (corresponds to the valuePropertyName),
      * <xsd:maxLength value="5"/>           it gets processed by this method and the "value" field receives @Size(min = 1, max = 5).
      * </xsd:restriction>
-     * </xsd:simpleType>
+     * </xsd:simpleType>}</pre>
      */
     private void processValueFromExtendedBase(CValuePropertyInfo valueProperty, ClassOutline classOutline, List<FacetCustomization> customizations) {
         String valuePropertyName = valueProperty.getName(false);
@@ -287,13 +288,14 @@
      * Processes an xsd attribute.
      * <p>
      * Example:
+     * <pre>{@code
      * <xsd:complexType name="Employee">
      * <xsd:simpleContent>
      * <xsd:extension base="a:Person">
      * <xsd:attribute name="id" type="xsd:string" use="optional"/>   << "id" is the attributePropertyName
      * </xsd:extension>
      * </xsd:simpleContent>
-     * </xsd:complexType>
+     * </xsd:complexType>}</pre>
      */
     private void processAttribute(CAttributePropertyInfo attributeProperty, ClassOutline classOutline, List<FacetCustomization> customizations) {
         String attributePropertyName = attributeProperty.getName(false);
@@ -314,7 +316,7 @@
      * Processes an xsd element.
      * <p>
      * Example:
-     * <xsd:element name="someCollection" minOccurs="1" maxOccurs="unbounded"/>
+     * {@code <xsd:element name="someCollection" minOccurs="1" maxOccurs="unbounded"/>}
      */
     private void processElement(CElementPropertyInfo propertyInfo, ClassOutline co, List<FacetCustomization> customizations) {
         XSParticle particle = (XSParticle) propertyInfo.getSchemaComponent();
diff --git a/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/rs/MOXyJsonProvider.java b/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/rs/MOXyJsonProvider.java
index c46d646..97fa748 100644
--- a/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/rs/MOXyJsonProvider.java
+++ b/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/rs/MOXyJsonProvider.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -751,7 +751,6 @@
     /**
      * Get first non java class if exists.
      *
-     * @param domainClasses
      * @return first domain class or first generic class or just the first class from the list
      */
     public Class<?> getDomainClass(Set<Class<?>> domainClasses) {
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/beanvalidation/special/ExternallyConstrainedEmployee2.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/beanvalidation/special/ExternallyConstrainedEmployee2.java
index 8e8ef22..9610abc 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/beanvalidation/special/ExternallyConstrainedEmployee2.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/beanvalidation/special/ExternallyConstrainedEmployee2.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2015, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -23,7 +23,7 @@
  * "Warning
  * A given entity can only be configured once across all configuration files. The same applies for constraint
  * definitions for a given constraint annotation. It can only occur in one mapping file. If these rules are violated a
- * ValidationException is thrown." -> we need multiple classes if we wish to test multiple configuration files.
+ * ValidationException is thrown." -{@literal >} we need multiple classes if we wish to test multiple configuration files.
  */
 @XmlRootElement
 public class ExternallyConstrainedEmployee2 {
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/binder/adapter/MapEntryAdapter.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/binder/adapter/MapEntryAdapter.java
index 8085f39..832693d 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/binder/adapter/MapEntryAdapter.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/binder/adapter/MapEntryAdapter.java
@@ -20,7 +20,7 @@
 import jakarta.xml.bind.annotation.adapters.XmlAdapter;
 
 /**
- * Adapter that converts between Map<Integer, String> and MapEntry.
+ * Adapter that converts between {@code Map<Integer, String>} and {@code MapEntry}.
  *
  */
 public class MapEntryAdapter extends XmlAdapter<MapEntry, Map<Integer, String>> {
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/casesensitivity/Customer.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/casesensitivity/Customer.java
index 5c908e7..8217eb9 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/casesensitivity/Customer.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/casesensitivity/Customer.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2014, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -19,7 +19,7 @@
 /**
  * This class serves as a bridge between {@link org.eclipse.persistence.testing.jaxb.casesensitivity.correctCase.CustomerImpl}
  * and {@link org.eclipse.persistence.testing.jaxb.casesensitivity.otherCase.CustomerImpl}.
- * <p>Provides uniform bridged <i>equals()<i/> and <i>hashCode()<i/> methods.</p>
+ * <p>Provides uniform bridged <i>equals()</i> and <i>hashCode()</i> methods.</p>
  *
  * @author Marcel Valovy - marcel.valovy@oracle.com
  */
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/dynamic/DynamicJAXBCollectionTestCases.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/dynamic/DynamicJAXBCollectionTestCases.java
index 80b6eb5..7792801 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/dynamic/DynamicJAXBCollectionTestCases.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/dynamic/DynamicJAXBCollectionTestCases.java
@@ -70,7 +70,7 @@
         InputStream schemaStream = ClassLoader.getSystemResourceAsStream(XSD_MULTI);
         jaxbContext = DynamicJAXBContextFactory.createContextFromXSD(schemaStream, null, null, null);
 
-        InputStream xmlStream = Thread.currentThread().getContextClassLoader().getSystemResourceAsStream(XSD_MULTI_INSTANCE);
+        InputStream xmlStream = ClassLoader.getSystemResourceAsStream(XSD_MULTI_INSTANCE);
         JAXBElement<DynamicEntity> jaxbElement = (JAXBElement<DynamicEntity>) jaxbContext.createUnmarshaller().unmarshal(xmlStream);
 
         DynamicEntity customer = jaxbElement.getValue();
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/externalizedmetadata/ExternalizedMetadataTestCases.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/externalizedmetadata/ExternalizedMetadataTestCases.java
index e274c76..d2a6744 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/externalizedmetadata/ExternalizedMetadataTestCases.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/externalizedmetadata/ExternalizedMetadataTestCases.java
@@ -148,7 +148,7 @@
      *
      * @param contextPath
      * @param expectedSchemaCount
-     * @param resolver
+     * @param outputResolver
      */
     public void generateSchema(String contextPath, int expectedSchemaCount, MyStreamSchemaOutputResolver outputResolver) {
         try {
@@ -429,7 +429,7 @@
      * Validates a given instance doc against the generated schema.
      *
      * @param src
-     * @param schemaIndex index in output resolver's list of generated schemas
+     * @param namespace index in output resolver's list of generated schemas
      * @param outputResolver contains one or more schemas to validate against
      */
     protected String validateAgainstSchema(String src, String namespace, MySchemaOutputResolver outputResolver) {
@@ -454,7 +454,7 @@
      * Validates a given instance doc against the generated schema.
      *
      * @param src
-     * @param schemaIndex index in output resolver's list of generated schemas
+     * @param namespace index in output resolver's list of generated schemas
      * @param outputResolver contains one or more schemas to validate against
      */
     protected String validateAgainstSchema(InputStream src, String namespace, MySchemaOutputResolver outputResolver) {
@@ -503,7 +503,7 @@
      * Validates a given instance doc against the generated schema.
      *
      * @param src
-     * @param schemaIndex index in output resolver's list of generated schemas
+     * @param namespace index in output resolver's list of generated schemas
      * @param outputResolver contains one or more schemas to validate against
      */
     protected String validateAgainstSchema(String src, String namespace, MyStreamSchemaOutputResolver outputResolver) {
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/externalizedmetadata/exceptions/contextfactory/ExceptionHandlingTestCases.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/externalizedmetadata/exceptions/contextfactory/ExceptionHandlingTestCases.java
index bde387c..4149f08 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/externalizedmetadata/exceptions/contextfactory/ExceptionHandlingTestCases.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/externalizedmetadata/exceptions/contextfactory/ExceptionHandlingTestCases.java
@@ -88,8 +88,8 @@
     }
 
     /**
-     * Tests an invalid parameter type by setting Map<String, Class> instead
-     * of Map<String, Source>.
+     * Tests an invalid parameter type by setting {@code Map<String, Class>} instead
+     * of {@code Map<String, Source>}.
      *
      * Negative test.
      */
@@ -129,7 +129,7 @@
     }
 
     /**
-     * Tests associating something other than Map<String, Source> with the key
+     * Tests associating something other than {@code Map<String, Source>} with the key
      * 'eclipselink-oxm-xml' in the properties map.
      *
      * Negative test.
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/externalizedmetadata/xmldiscriminator/XmlDiscriminatorTestCases.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/externalizedmetadata/xmldiscriminator/XmlDiscriminatorTestCases.java
index 4e8af83..274afd8 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/externalizedmetadata/xmldiscriminator/XmlDiscriminatorTestCases.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/externalizedmetadata/xmldiscriminator/XmlDiscriminatorTestCases.java
@@ -30,7 +30,7 @@
 import org.eclipse.persistence.testing.jaxb.JAXBWithJSONTestCases;
 
 /**
- * Tests inheritance configuration via XmlDiscriminatorNode & XmlDiscriminatorValue.
+ * Tests inheritance configuration via XmlDiscriminatorNode &amp; XmlDiscriminatorValue.
  *
  */
 public class XmlDiscriminatorTestCases extends JAXBWithJSONTestCases {
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/externalizedmetadata/xmljoinnode/XmlJoinNodeTestCases.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/externalizedmetadata/xmljoinnode/XmlJoinNodeTestCases.java
index 7c7dc00..ff92631 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/externalizedmetadata/xmljoinnode/XmlJoinNodeTestCases.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/externalizedmetadata/xmljoinnode/XmlJoinNodeTestCases.java
@@ -37,7 +37,7 @@
 import org.eclipse.persistence.testing.jaxb.JAXBWithJSONTestCases;
 
 /**
- * Tests relationship mapping configuration via XmlJoinNode & XmlJoinNodes.
+ * Tests relationship mapping configuration via XmlJoinNode &amp; XmlJoinNodes.
  *
  */
 public class XmlJoinNodeTestCases extends JAXBWithJSONTestCases {
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/externalizedmetadata/xmltransient/XmlTransientTestCases.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/externalizedmetadata/xmltransient/XmlTransientTestCases.java
index 77a8e85..0132b12 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/externalizedmetadata/xmltransient/XmlTransientTestCases.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/externalizedmetadata/xmltransient/XmlTransientTestCases.java
@@ -120,7 +120,7 @@
 
 
     /**
-     * Test a reference to a transient class.  Here, ContactInfo has a List<Address> where
+     * Test a reference to a transient class.  Here, ContactInfo has a {@code List<Address>} where
      * Address is marked transient via XML metadata.  A JAXBException should be thrown.
      *
      * Negative test.
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/json/array/BooleanListTestCases.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/json/array/BooleanListTestCases.java
index 4867ad7..27bc7a7 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/json/array/BooleanListTestCases.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/json/array/BooleanListTestCases.java
@@ -23,7 +23,7 @@
 import java.util.List;
 
 /**
- * Tests marshall/unmarshal List of Booleans (List<Boolean>).
+ * Tests marshall/unmarshal List of Booleans ({@code List<Boolean>}).
  *
  * @author Radek Felcman
  *
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/json/array/IntegerListTestCases.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/json/array/IntegerListTestCases.java
index e7c36b4..bf6ff03 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/json/array/IntegerListTestCases.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/json/array/IntegerListTestCases.java
@@ -22,7 +22,7 @@
 import java.util.List;
 
 /**
- * Tests marshall/unmarshal List of Integer (List<Integer>).
+ * Tests marshall/unmarshal List of Integer ({@code List<Integer>}).
  *
  * @author Radek Felcman
  *
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/json/array/StringListTestCases.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/json/array/StringListTestCases.java
index 30f7389..d56cefa 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/json/array/StringListTestCases.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/json/array/StringListTestCases.java
@@ -23,7 +23,7 @@
 import java.util.List;
 
 /**
- * Tests marshall/unmarshal List of Strings (List<String>).
+ * Tests marshall/unmarshal List of Strings ({@code List<String>}).
  *
  * @author Radek Felcman
  *
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/schemagen/typearray/TypeArraySchemaGenTestCases.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/schemagen/typearray/TypeArraySchemaGenTestCases.java
index e1b6aee..64dc03b 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/schemagen/typearray/TypeArraySchemaGenTestCases.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/schemagen/typearray/TypeArraySchemaGenTestCases.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -148,7 +148,7 @@
     }
 
     /**
-     * Tests user-set additional global element generation (List<Employee>)
+     * Tests user-set additional global element generation ({@code List<Employee>})
      *
      * @throws Exception
      */
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/substitution/Person.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/substitution/Person.java
index 1c96a82..84e87f7 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/substitution/Person.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/substitution/Person.java
@@ -32,17 +32,17 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType name="person">
- *   &lt;complexContent>
- *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
- *       &lt;sequence>
- *         &lt;element ref="{myNamespace}name"/>
- *       &lt;/sequence>
- *     &lt;/restriction>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
+ * <pre>{@code
+ * <complexType name="person">
+ *   <complexContent>
+ *     <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
+ *       <sequence>
+ *         <element ref="{myNamespace}name"/>
+ *       </sequence>
+ *     </restriction>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  *
  *
  */
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmladapter/enumeration/AdapterEnumMoreGenericTestCases.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmladapter/enumeration/AdapterEnumMoreGenericTestCases.java
index 948ebed..693579d 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmladapter/enumeration/AdapterEnumMoreGenericTestCases.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmladapter/enumeration/AdapterEnumMoreGenericTestCases.java
@@ -20,7 +20,7 @@
 /**
  * This test represents scenario when more complicated generic XmlAdapter is used.
  * <p>
- * Example: GenericSuitsAdapterWithT&lt;T extends Enum> extends XmlAdapter&lt;String, T>
+ * Example: {@code GenericSuitsAdapterWithT<T extends Enum> extends XmlAdapter<String, T>}
  * </p>
  */
 public class AdapterEnumMoreGenericTestCases extends JAXBWithJSONTestCases{
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmladapter/enumeration/GenericSuitsAdapterWithT.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmladapter/enumeration/GenericSuitsAdapterWithT.java
index 32aa4d9..ecc2861 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmladapter/enumeration/GenericSuitsAdapterWithT.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmladapter/enumeration/GenericSuitsAdapterWithT.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2014, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -21,7 +21,7 @@
  * The correct values of BoundType and ValueType of Generic XmlAdapter are resolved by GenericsClassHelper.
  *
  * <p>
- * ReflectionHelper does not help when you define XmlAdapter as XmlAdapter&lt;Object, Object> or XmlAdapter&lt;Object, T>
+ * ReflectionHelper does not help when you define XmlAdapter as {@code XmlAdapter<Object, Object> or XmlAdapter<Object, T>}
  *
  * @see GenericsClassHelper
  *
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/All.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/All.java
index 05dbada..e542b65 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/All.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/All.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -27,31 +27,31 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType name="all">
- *   &lt;complexContent>
- *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}explicitGroup">
- *       &lt;group ref="{http://www.w3.org/2001/XMLSchema}allModel"/>
- *       &lt;attribute name="minOccurs" default="1">
- *         &lt;simpleType>
- *           &lt;restriction base="{http://www.w3.org/2001/XMLSchema}nonNegativeInteger">
- *             &lt;enumeration value="0"/>
- *             &lt;enumeration value="1"/>
- *           &lt;/restriction>
- *         &lt;/simpleType>
- *       &lt;/attribute>
- *       &lt;attribute name="maxOccurs" default="1">
- *         &lt;simpleType>
- *           &lt;restriction base="{http://www.w3.org/2001/XMLSchema}allNNI">
- *             &lt;enumeration value="1"/>
- *           &lt;/restriction>
- *         &lt;/simpleType>
- *       &lt;/attribute>
- *       &lt;anyAttribute processContents='lax' namespace='##other'/>
- *     &lt;/restriction>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
+ * <pre>{@code
+ * <complexType name="all">
+ *   <complexContent>
+ *     <restriction base="{http://www.w3.org/2001/XMLSchema}explicitGroup">
+ *       <group ref="{http://www.w3.org/2001/XMLSchema}allModel"/>
+ *       <attribute name="minOccurs" default="1">
+ *         <simpleType>
+ *           <restriction base="{http://www.w3.org/2001/XMLSchema}nonNegativeInteger">
+ *             <enumeration value="0"/>
+ *             <enumeration value="1"/>
+ *           </restriction>
+ *         </simpleType>
+ *       </attribute>
+ *       <attribute name="maxOccurs" default="1">
+ *         <simpleType>
+ *           <restriction base="{http://www.w3.org/2001/XMLSchema}allNNI">
+ *             <enumeration value="1"/>
+ *           </restriction>
+ *         </simpleType>
+ *       </attribute>
+ *       <anyAttribute processContents='lax' namespace='##other'/>
+ *     </restriction>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  *
  *
  */
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Annotated.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Annotated.java
index 9b2340d..ebf720b 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Annotated.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Annotated.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -28,26 +28,26 @@
 /**
  *
  *        This type is extended by all types which allow annotation
- *        other than <schema> itself
+ *        other than {@code <schema>} itself
  *
  *
  * <p>Java class for annotated complex type.
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType name="annotated">
- *   &lt;complexContent>
- *     &lt;extension base="{http://www.w3.org/2001/XMLSchema}openAttrs">
- *       &lt;sequence>
- *         &lt;element ref="{http://www.w3.org/2001/XMLSchema}annotation" minOccurs="0"/>
- *       &lt;/sequence>
- *       &lt;attribute name="id" type="{http://www.w3.org/2001/XMLSchema}ID" />
- *       &lt;anyAttribute processContents='lax' namespace='##other'/>
- *     &lt;/extension>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
+ * <pre>{@code
+ * <complexType name="annotated">
+ *   <complexContent>
+ *     <extension base="{http://www.w3.org/2001/XMLSchema}openAttrs">
+ *       <sequence>
+ *         <element ref="{http://www.w3.org/2001/XMLSchema}annotation" minOccurs="0"/>
+ *       </sequence>
+ *       <attribute name="id" type="{http://www.w3.org/2001/XMLSchema}ID" />
+ *       <anyAttribute processContents='lax' namespace='##other'/>
+ *     </extension>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  *
  *
  */
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Annotation.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Annotation.java
index b5d10f9..fd8cc0d 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Annotation.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Annotation.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -34,20 +34,20 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType>
- *   &lt;complexContent>
- *     &lt;extension base="{http://www.w3.org/2001/XMLSchema}openAttrs">
- *       &lt;choice maxOccurs="unbounded" minOccurs="0">
- *         &lt;element ref="{http://www.w3.org/2001/XMLSchema}appinfo"/>
- *         &lt;element ref="{http://www.w3.org/2001/XMLSchema}documentation"/>
- *       &lt;/choice>
- *       &lt;attribute name="id" type="{http://www.w3.org/2001/XMLSchema}ID" />
- *       &lt;anyAttribute processContents='lax' namespace='##other'/>
- *     &lt;/extension>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
+ * <pre>{@code
+ * <complexType>
+ *   <complexContent>
+ *     <extension base="{http://www.w3.org/2001/XMLSchema}openAttrs">
+ *       <choice maxOccurs="unbounded" minOccurs="0">
+ *         <element ref="{http://www.w3.org/2001/XMLSchema}appinfo"/>
+ *         <element ref="{http://www.w3.org/2001/XMLSchema}documentation"/>
+ *       </choice>
+ *       <attribute name="id" type="{http://www.w3.org/2001/XMLSchema}ID" />
+ *       <anyAttribute processContents='lax' namespace='##other'/>
+ *     </extension>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  *
  *
  */
@@ -84,7 +84,7 @@
      * For example, to add a new item, do as follows:
      * <pre>
      *    getAppinfoOrDocumentation().add(newItem);
-     * </pre>
+     * }</pre>
      *
      *
      * <p>
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Any.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Any.java
index 5e4923f..7d04bf6 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Any.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Any.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -28,16 +28,16 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType>
- *   &lt;complexContent>
- *     &lt;extension base="{http://www.w3.org/2001/XMLSchema}wildcard">
- *       &lt;attGroup ref="{http://www.w3.org/2001/XMLSchema}occurs"/>
- *       &lt;anyAttribute processContents='lax' namespace='##other'/>
- *     &lt;/extension>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
+ * <pre>{@code
+ * <complexType>
+ *   <complexContent>
+ *     <extension base="{http://www.w3.org/2001/XMLSchema}wildcard">
+ *       <attGroup ref="{http://www.w3.org/2001/XMLSchema}occurs"/>
+ *       <anyAttribute processContents='lax' namespace='##other'/>
+ *     </extension>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  *
  *
  */
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Appinfo.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Appinfo.java
index 08f8691..28c9be4 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Appinfo.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Appinfo.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -36,19 +36,19 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType>
- *   &lt;complexContent>
- *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
- *       &lt;sequence maxOccurs="unbounded" minOccurs="0">
- *         &lt;any processContents='lax'/>
- *       &lt;/sequence>
- *       &lt;attribute name="source" type="{http://www.w3.org/2001/XMLSchema}anyURI" />
- *       &lt;anyAttribute processContents='lax' namespace='##other'/>
- *     &lt;/restriction>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
+ * <pre>{@code
+ * <complexType>
+ *   <complexContent>
+ *     <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
+ *       <sequence maxOccurs="unbounded" minOccurs="0">
+ *         <any processContents='lax'/>
+ *       </sequence>
+ *       <attribute name="source" type="{http://www.w3.org/2001/XMLSchema}anyURI" />
+ *       <anyAttribute processContents='lax' namespace='##other'/>
+ *     </restriction>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  *
  *
  */
@@ -81,7 +81,7 @@
      * For example, to add a new item, do as follows:
      * <pre>
      *    getContent().add(newItem);
-     * </pre>
+     * }</pre>
      *
      *
      * <p>
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Attribute.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Attribute.java
index 37d97c0..0bf47ec 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Attribute.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Attribute.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -30,34 +30,32 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType name="attribute">
- *   &lt;complexContent>
- *     &lt;extension base="{http://www.w3.org/2001/XMLSchema}annotated">
- *       &lt;sequence>
- *         &lt;element name="simpleType" type="{http://www.w3.org/2001/XMLSchema}localSimpleType" minOccurs="0"/>
- *       &lt;/sequence>
- *       &lt;attGroup ref="{http://www.w3.org/2001/XMLSchema}defRef"/>
- *       &lt;attribute name="type" type="{http://www.w3.org/2001/XMLSchema}QName" />
- *       &lt;attribute name="use" default="optional">
- *         &lt;simpleType>
- *           &lt;restriction base="{http://www.w3.org/2001/XMLSchema}NMTOKEN">
- *             &lt;enumeration value="prohibited"/>
- *             &lt;enumeration value="optional"/>
- *             &lt;enumeration value="required"/>
- *           &lt;/restriction>
- *         &lt;/simpleType>
- *       &lt;/attribute>
- *       &lt;attribute name="default" type="{http://www.w3.org/2001/XMLSchema}string" />
- *       &lt;attribute name="fixed" type="{http://www.w3.org/2001/XMLSchema}string" />
- *       &lt;attribute name="form" type="{http://www.w3.org/2001/XMLSchema}formChoice" />
- *       &lt;anyAttribute processContents='lax' namespace='##other'/>
- *     &lt;/extension>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
- *
- *
+ * <pre>{@code
+ * <complexType name="attribute">
+ *   <complexContent>
+ *     <extension base="{http://www.w3.org/2001/XMLSchema}annotated">
+ *       <sequence>
+ *         <element name="simpleType" type="{http://www.w3.org/2001/XMLSchema}localSimpleType" minOccurs="0"/>
+ *       </sequence>
+ *       <attGroup ref="{http://www.w3.org/2001/XMLSchema}defRef"/>
+ *       <attribute name="type" type="{http://www.w3.org/2001/XMLSchema}QName" />
+ *       <attribute name="use" default="optional">
+ *         <simpleType>
+ *           <restriction base="{http://www.w3.org/2001/XMLSchema}NMTOKEN">
+ *             <enumeration value="prohibited"/>
+ *             <enumeration value="optional"/>
+ *             <enumeration value="required"/>
+ *           </restriction>
+ *         </simpleType>
+ *       </attribute>
+ *       <attribute name="default" type="{http://www.w3.org/2001/XMLSchema}string" />
+ *       <attribute name="fixed" type="{http://www.w3.org/2001/XMLSchema}string" />
+ *       <attribute name="form" type="{http://www.w3.org/2001/XMLSchema}formChoice" />
+ *       <anyAttribute processContents='lax' namespace='##other'/>
+ *     </extension>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  */
 @XmlAccessorType(XmlAccessType.FIELD)
 @XmlType(name = "attribute", propOrder = {
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/AttributeGroup.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/AttributeGroup.java
index 15ccdf3..cdc4690 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/AttributeGroup.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/AttributeGroup.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -34,17 +34,17 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType name="attributeGroup">
- *   &lt;complexContent>
- *     &lt;extension base="{http://www.w3.org/2001/XMLSchema}annotated">
- *       &lt;group ref="{http://www.w3.org/2001/XMLSchema}attrDecls"/>
- *       &lt;attGroup ref="{http://www.w3.org/2001/XMLSchema}defRef"/>
- *       &lt;anyAttribute processContents='lax' namespace='##other'/>
- *     &lt;/extension>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
+ * <pre>{@code
+ * <complexType name="attributeGroup">
+ *   <complexContent>
+ *     <extension base="{http://www.w3.org/2001/XMLSchema}annotated">
+ *       <group ref="{http://www.w3.org/2001/XMLSchema}attrDecls"/>
+ *       <attGroup ref="{http://www.w3.org/2001/XMLSchema}defRef"/>
+ *       <anyAttribute processContents='lax' namespace='##other'/>
+ *     </extension>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  *
  *
  */
@@ -87,7 +87,7 @@
      * For example, to add a new item, do as follows:
      * <pre>
      *    getAttributeOrAttributeGroup().add(newItem);
-     * </pre>
+     * }</pre>
      *
      *
      * <p>
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/AttributeGroupRef.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/AttributeGroupRef.java
index 5ce6bb3..730b6e4 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/AttributeGroupRef.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/AttributeGroupRef.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -24,19 +24,19 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType name="attributeGroupRef">
- *   &lt;complexContent>
- *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}attributeGroup">
- *       &lt;sequence>
- *         &lt;element ref="{http://www.w3.org/2001/XMLSchema}annotation" minOccurs="0"/>
- *       &lt;/sequence>
- *       &lt;attribute name="ref" use="required" type="{http://www.w3.org/2001/XMLSchema}QName" />
- *       &lt;anyAttribute processContents='lax' namespace='##other'/>
- *     &lt;/restriction>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
+ * <pre>{@code
+ * <complexType name="attributeGroupRef">
+ *   <complexContent>
+ *     <restriction base="{http://www.w3.org/2001/XMLSchema}attributeGroup">
+ *       <sequence>
+ *         <element ref="{http://www.w3.org/2001/XMLSchema}annotation" minOccurs="0"/>
+ *       </sequence>
+ *       <attribute name="ref" use="required" type="{http://www.w3.org/2001/XMLSchema}QName" />
+ *       <anyAttribute processContents='lax' namespace='##other'/>
+ *     </restriction>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  *
  *
  */
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/ComplexContent.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/ComplexContent.java
index b9f951c..f7ae210 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/ComplexContent.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/ComplexContent.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -26,20 +26,20 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType>
- *   &lt;complexContent>
- *     &lt;extension base="{http://www.w3.org/2001/XMLSchema}annotated">
- *       &lt;choice>
- *         &lt;element name="restriction" type="{http://www.w3.org/2001/XMLSchema}complexRestrictionType"/>
- *         &lt;element name="extension" type="{http://www.w3.org/2001/XMLSchema}extensionType"/>
- *       &lt;/choice>
- *       &lt;attribute name="mixed" type="{http://www.w3.org/2001/XMLSchema}boolean" />
- *       &lt;anyAttribute processContents='lax' namespace='##other'/>
- *     &lt;/extension>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
+ * <pre>{@code
+ * <complexType>
+ *   <complexContent>
+ *     <extension base="{http://www.w3.org/2001/XMLSchema}annotated">
+ *       <choice>
+ *         <element name="restriction" type="{http://www.w3.org/2001/XMLSchema}complexRestrictionType"/>
+ *         <element name="extension" type="{http://www.w3.org/2001/XMLSchema}extensionType"/>
+ *       </choice>
+ *       <attribute name="mixed" type="{http://www.w3.org/2001/XMLSchema}boolean" />
+ *       <anyAttribute processContents='lax' namespace='##other'/>
+ *     </extension>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  *
  *
  */
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/ComplexRestrictionType.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/ComplexRestrictionType.java
index a786932..801b92d 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/ComplexRestrictionType.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/ComplexRestrictionType.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -24,22 +24,22 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType name="complexRestrictionType">
- *   &lt;complexContent>
- *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}restrictionType">
- *       &lt;sequence>
- *         &lt;element ref="{http://www.w3.org/2001/XMLSchema}annotation" minOccurs="0"/>
- *         &lt;choice minOccurs="0">
- *           &lt;group ref="{http://www.w3.org/2001/XMLSchema}typeDefParticle"/>
- *         &lt;/choice>
- *         &lt;group ref="{http://www.w3.org/2001/XMLSchema}attrDecls"/>
- *       &lt;/sequence>
- *       &lt;anyAttribute processContents='lax' namespace='##other'/>
- *     &lt;/restriction>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
+ * <pre>{@code
+ * <complexType name="complexRestrictionType">
+ *   <complexContent>
+ *     <restriction base="{http://www.w3.org/2001/XMLSchema}restrictionType">
+ *       <sequence>
+ *         <element ref="{http://www.w3.org/2001/XMLSchema}annotation" minOccurs="0"/>
+ *         <choice minOccurs="0">
+ *           <group ref="{http://www.w3.org/2001/XMLSchema}typeDefParticle"/>
+ *         </choice>
+ *         <group ref="{http://www.w3.org/2001/XMLSchema}attrDecls"/>
+ *       </sequence>
+ *       <anyAttribute processContents='lax' namespace='##other'/>
+ *     </restriction>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  *
  *
  */
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/ComplexType.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/ComplexType.java
index ae45a4c..f87c868 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/ComplexType.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/ComplexType.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -33,21 +33,21 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType name="complexType">
- *   &lt;complexContent>
- *     &lt;extension base="{http://www.w3.org/2001/XMLSchema}annotated">
- *       &lt;group ref="{http://www.w3.org/2001/XMLSchema}complexTypeModel"/>
- *       &lt;attribute name="name" type="{http://www.w3.org/2001/XMLSchema}NCName" />
- *       &lt;attribute name="mixed" type="{http://www.w3.org/2001/XMLSchema}boolean" default="false" />
- *       &lt;attribute name="abstract" type="{http://www.w3.org/2001/XMLSchema}boolean" default="false" />
- *       &lt;attribute name="final" type="{http://www.w3.org/2001/XMLSchema}derivationSet" />
- *       &lt;attribute name="block" type="{http://www.w3.org/2001/XMLSchema}derivationSet" />
- *       &lt;anyAttribute processContents='lax' namespace='##other'/>
- *     &lt;/extension>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
+ * <pre>{@code
+ * <complexType name="complexType">
+ *   <complexContent>
+ *     <extension base="{http://www.w3.org/2001/XMLSchema}annotated">
+ *       <group ref="{http://www.w3.org/2001/XMLSchema}complexTypeModel"/>
+ *       <attribute name="name" type="{http://www.w3.org/2001/XMLSchema}NCName" />
+ *       <attribute name="mixed" type="{http://www.w3.org/2001/XMLSchema}boolean" default="false" />
+ *       <attribute name="abstract" type="{http://www.w3.org/2001/XMLSchema}boolean" default="false" />
+ *       <attribute name="final" type="{http://www.w3.org/2001/XMLSchema}derivationSet" />
+ *       <attribute name="block" type="{http://www.w3.org/2001/XMLSchema}derivationSet" />
+ *       <anyAttribute processContents='lax' namespace='##other'/>
+ *     </extension>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  *
  *
  */
@@ -254,7 +254,7 @@
      * For example, to add a new item, do as follows:
      * <pre>
      *    getAttributeOrAttributeGroup().add(newItem);
-     * </pre>
+     * }</pre>
      *
      *
      * <p>
@@ -388,7 +388,7 @@
      * For example, to add a new item, do as follows:
      * <pre>
      *    getFinal().add(newItem);
-     * </pre>
+     * }</pre>
      *
      *
      * <p>
@@ -417,7 +417,7 @@
      * For example, to add a new item, do as follows:
      * <pre>
      *    getBlock().add(newItem);
-     * </pre>
+     * }</pre>
      *
      *
      * <p>
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/DerivationControl.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/DerivationControl.java
index bf162c9..1b1c795 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/DerivationControl.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/DerivationControl.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -24,17 +24,17 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  * <p>
- * <pre>
- * &lt;simpleType name="derivationControl">
- *   &lt;restriction base="{http://www.w3.org/2001/XMLSchema}NMTOKEN">
- *     &lt;enumeration value="substitution"/>
- *     &lt;enumeration value="extension"/>
- *     &lt;enumeration value="restriction"/>
- *     &lt;enumeration value="list"/>
- *     &lt;enumeration value="union"/>
- *   &lt;/restriction>
- * &lt;/simpleType>
- * </pre>
+ * <pre>{@code
+ * <simpleType name="derivationControl">
+ *   <restriction base="{http://www.w3.org/2001/XMLSchema}NMTOKEN">
+ *     <enumeration value="substitution"/>
+ *     <enumeration value="extension"/>
+ *     <enumeration value="restriction"/>
+ *     <enumeration value="list"/>
+ *     <enumeration value="union"/>
+ *   </restriction>
+ * </simpleType>
+ * }</pre>
  *
  */
 @XmlType(name = "derivationControl")
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Documentation.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Documentation.java
index 9f4fa4e..4798488 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Documentation.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Documentation.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -36,19 +36,19 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType>
- *   &lt;complexContent>
- *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
- *       &lt;sequence maxOccurs="unbounded" minOccurs="0">
- *         &lt;any processContents='lax'/>
- *       &lt;/sequence>
- *       &lt;attribute name="source" type="{http://www.w3.org/2001/XMLSchema}anyURI" />
- *       &lt;anyAttribute processContents='lax' namespace='##other'/>
- *     &lt;/restriction>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
+ * <pre>{@code
+ * <complexType>
+ *   <complexContent>
+ *     <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
+ *       <sequence maxOccurs="unbounded" minOccurs="0">
+ *         <any processContents='lax'/>
+ *       </sequence>
+ *       <attribute name="source" type="{http://www.w3.org/2001/XMLSchema}anyURI" />
+ *       <anyAttribute processContents='lax' namespace='##other'/>
+ *     </restriction>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  *
  *
  */
@@ -81,7 +81,7 @@
      * For example, to add a new item, do as follows:
      * <pre>
      *    getContent().add(newItem);
-     * </pre>
+     * }</pre>
      *
      *
      * <p>
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Element.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Element.java
index 4be5c18..6e5045b 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Element.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Element.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -43,33 +43,33 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType name="element">
- *   &lt;complexContent>
- *     &lt;extension base="{http://www.w3.org/2001/XMLSchema}annotated">
- *       &lt;sequence>
- *         &lt;choice minOccurs="0">
- *           &lt;element name="simpleType" type="{http://www.w3.org/2001/XMLSchema}localSimpleType"/>
- *           &lt;element name="complexType" type="{http://www.w3.org/2001/XMLSchema}localComplexType"/>
- *         &lt;/choice>
- *         &lt;group ref="{http://www.w3.org/2001/XMLSchema}identityConstraint" maxOccurs="unbounded" minOccurs="0"/>
- *       &lt;/sequence>
- *       &lt;attGroup ref="{http://www.w3.org/2001/XMLSchema}occurs"/>
- *       &lt;attGroup ref="{http://www.w3.org/2001/XMLSchema}defRef"/>
- *       &lt;attribute name="type" type="{http://www.w3.org/2001/XMLSchema}QName" />
- *       &lt;attribute name="substitutionGroup" type="{http://www.w3.org/2001/XMLSchema}QName" />
- *       &lt;attribute name="default" type="{http://www.w3.org/2001/XMLSchema}string" />
- *       &lt;attribute name="fixed" type="{http://www.w3.org/2001/XMLSchema}string" />
- *       &lt;attribute name="nillable" type="{http://www.w3.org/2001/XMLSchema}boolean" default="false" />
- *       &lt;attribute name="abstract" type="{http://www.w3.org/2001/XMLSchema}boolean" default="false" />
- *       &lt;attribute name="final" type="{http://www.w3.org/2001/XMLSchema}derivationSet" />
- *       &lt;attribute name="block" type="{http://www.w3.org/2001/XMLSchema}blockSet" />
- *       &lt;attribute name="form" type="{http://www.w3.org/2001/XMLSchema}formChoice" />
- *       &lt;anyAttribute processContents='lax' namespace='##other'/>
- *     &lt;/extension>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
+ * <pre>{@code
+ * <complexType name="element">
+ *   <complexContent>
+ *     <extension base="{http://www.w3.org/2001/XMLSchema}annotated">
+ *       <sequence>
+ *         <choice minOccurs="0">
+ *           <element name="simpleType" type="{http://www.w3.org/2001/XMLSchema}localSimpleType"/>
+ *           <element name="complexType" type="{http://www.w3.org/2001/XMLSchema}localComplexType"/>
+ *         </choice>
+ *         <group ref="{http://www.w3.org/2001/XMLSchema}identityConstraint" maxOccurs="unbounded" minOccurs="0"/>
+ *       </sequence>
+ *       <attGroup ref="{http://www.w3.org/2001/XMLSchema}occurs"/>
+ *       <attGroup ref="{http://www.w3.org/2001/XMLSchema}defRef"/>
+ *       <attribute name="type" type="{http://www.w3.org/2001/XMLSchema}QName" />
+ *       <attribute name="substitutionGroup" type="{http://www.w3.org/2001/XMLSchema}QName" />
+ *       <attribute name="default" type="{http://www.w3.org/2001/XMLSchema}string" />
+ *       <attribute name="fixed" type="{http://www.w3.org/2001/XMLSchema}string" />
+ *       <attribute name="nillable" type="{http://www.w3.org/2001/XMLSchema}boolean" default="false" />
+ *       <attribute name="abstract" type="{http://www.w3.org/2001/XMLSchema}boolean" default="false" />
+ *       <attribute name="final" type="{http://www.w3.org/2001/XMLSchema}derivationSet" />
+ *       <attribute name="block" type="{http://www.w3.org/2001/XMLSchema}blockSet" />
+ *       <attribute name="form" type="{http://www.w3.org/2001/XMLSchema}formChoice" />
+ *       <anyAttribute processContents='lax' namespace='##other'/>
+ *     </extension>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  *
  *
  */
@@ -189,7 +189,7 @@
      * For example, to add a new item, do as follows:
      * <pre>
      *    getIdentityConstraint().add(newItem);
-     * </pre>
+     * }</pre>
      *
      *
      * <p>
@@ -372,7 +372,7 @@
      * For example, to add a new item, do as follows:
      * <pre>
      *    getFinal().add(newItem);
-     * </pre>
+     * }</pre>
      *
      *
      * <p>
@@ -401,7 +401,7 @@
      * For example, to add a new item, do as follows:
      * <pre>
      *    getBlock().add(newItem);
-     * </pre>
+     * }</pre>
      *
      *
      * <p>
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/ExplicitGroup.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/ExplicitGroup.java
index 10a0e46..dcb9502 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/ExplicitGroup.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/ExplicitGroup.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -28,19 +28,19 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType name="explicitGroup">
- *   &lt;complexContent>
- *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}group">
- *       &lt;sequence>
- *         &lt;element ref="{http://www.w3.org/2001/XMLSchema}annotation" minOccurs="0"/>
- *         &lt;group ref="{http://www.w3.org/2001/XMLSchema}nestedParticle" maxOccurs="unbounded" minOccurs="0"/>
- *       &lt;/sequence>
- *       &lt;anyAttribute processContents='lax' namespace='##other'/>
- *     &lt;/restriction>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
+ * <pre>{@code
+ * <complexType name="explicitGroup">
+ *   <complexContent>
+ *     <restriction base="{http://www.w3.org/2001/XMLSchema}group">
+ *       <sequence>
+ *         <element ref="{http://www.w3.org/2001/XMLSchema}annotation" minOccurs="0"/>
+ *         <group ref="{http://www.w3.org/2001/XMLSchema}nestedParticle" maxOccurs="unbounded" minOccurs="0"/>
+ *       </sequence>
+ *       <anyAttribute processContents='lax' namespace='##other'/>
+ *     </restriction>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  *
  *
  */
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/ExtensionType.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/ExtensionType.java
index 6a8eeca..f8b93c4 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/ExtensionType.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/ExtensionType.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -31,20 +31,20 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType name="extensionType">
- *   &lt;complexContent>
- *     &lt;extension base="{http://www.w3.org/2001/XMLSchema}annotated">
- *       &lt;sequence>
- *         &lt;group ref="{http://www.w3.org/2001/XMLSchema}typeDefParticle" minOccurs="0"/>
- *         &lt;group ref="{http://www.w3.org/2001/XMLSchema}attrDecls"/>
- *       &lt;/sequence>
- *       &lt;attribute name="base" use="required" type="{http://www.w3.org/2001/XMLSchema}QName" />
- *       &lt;anyAttribute processContents='lax' namespace='##other'/>
- *     &lt;/extension>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
+ * <pre>{@code
+ * <complexType name="extensionType">
+ *   <complexContent>
+ *     <extension base="{http://www.w3.org/2001/XMLSchema}annotated">
+ *       <sequence>
+ *         <group ref="{http://www.w3.org/2001/XMLSchema}typeDefParticle" minOccurs="0"/>
+ *         <group ref="{http://www.w3.org/2001/XMLSchema}attrDecls"/>
+ *       </sequence>
+ *       <attribute name="base" use="required" type="{http://www.w3.org/2001/XMLSchema}QName" />
+ *       <anyAttribute processContents='lax' namespace='##other'/>
+ *     </extension>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  *
  *
  */
@@ -186,7 +186,7 @@
      * For example, to add a new item, do as follows:
      * <pre>
      *    getAttributeOrAttributeGroup().add(newItem);
-     * </pre>
+     * }</pre>
      *
      *
      * <p>
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Facet.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Facet.java
index c113338..90d049b 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Facet.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Facet.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -27,17 +27,17 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType name="facet">
- *   &lt;complexContent>
- *     &lt;extension base="{http://www.w3.org/2001/XMLSchema}annotated">
- *       &lt;attribute name="value" use="required" type="{http://www.w3.org/2001/XMLSchema}anySimpleType" />
- *       &lt;attribute name="fixed" type="{http://www.w3.org/2001/XMLSchema}boolean" default="false" />
- *       &lt;anyAttribute processContents='lax' namespace='##other'/>
- *     &lt;/extension>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
+ * <pre>{@code
+ * <complexType name="facet">
+ *   <complexContent>
+ *     <extension base="{http://www.w3.org/2001/XMLSchema}annotated">
+ *       <attribute name="value" use="required" type="{http://www.w3.org/2001/XMLSchema}anySimpleType" />
+ *       <attribute name="fixed" type="{http://www.w3.org/2001/XMLSchema}boolean" default="false" />
+ *       <anyAttribute processContents='lax' namespace='##other'/>
+ *     </extension>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  *
  *
  */
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Field.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Field.java
index d7785a7..4271da9 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Field.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Field.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -28,22 +28,22 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType>
- *   &lt;complexContent>
- *     &lt;extension base="{http://www.w3.org/2001/XMLSchema}annotated">
- *       &lt;attribute name="xpath" use="required">
- *         &lt;simpleType>
- *           &lt;restriction base="{http://www.w3.org/2001/XMLSchema}token">
- *             &lt;pattern value="(\.//)?((((child::)?((\i\c*:)?(\i\c*|\*)))|\.)/)*((((child::)?((\i\c*:)?(\i\c*|\*)))|\.)|((attribute::|@)((\i\c*:)?(\i\c*|\*))))(\|(\.//)?((((child::)?((\i\c*:)?(\i\c*|\*)))|\.)/)*((((child::)?((\i\c*:)?(\i\c*|\*)))|\.)|((attribute::|@)((\i\c*:)?(\i\c*|\*)))))*"/>
- *           &lt;/restriction>
- *         &lt;/simpleType>
- *       &lt;/attribute>
- *       &lt;anyAttribute processContents='lax' namespace='##other'/>
- *     &lt;/extension>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
+ * <pre>{@code
+ * <complexType>
+ *   <complexContent>
+ *     <extension base="{http://www.w3.org/2001/XMLSchema}annotated">
+ *       <attribute name="xpath" use="required">
+ *         <simpleType>
+ *           <restriction base="{http://www.w3.org/2001/XMLSchema}token">
+ *             <pattern value="(\.//)?((((child::)?((\i\c*:)?(\i\c*|\*)))|\.)/)*((((child::)?((\i\c*:)?(\i\c*|\*)))|\.)|((attribute::|@)((\i\c*:)?(\i\c*|\*))))(\|(\.//)?((((child::)?((\i\c*:)?(\i\c*|\*)))|\.)/)*((((child::)?((\i\c*:)?(\i\c*|\*)))|\.)|((attribute::|@)((\i\c*:)?(\i\c*|\*)))))*"/>
+ *           </restriction>
+ *         </simpleType>
+ *       </attribute>
+ *       <anyAttribute processContents='lax' namespace='##other'/>
+ *     </extension>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  *
  *
  */
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/FormChoice.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/FormChoice.java
index 178c223..9a0943f 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/FormChoice.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/FormChoice.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -24,14 +24,14 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  * <p>
- * <pre>
- * &lt;simpleType name="formChoice">
- *   &lt;restriction base="{http://www.w3.org/2001/XMLSchema}NMTOKEN">
- *     &lt;enumeration value="qualified"/>
- *     &lt;enumeration value="unqualified"/>
- *   &lt;/restriction>
- * &lt;/simpleType>
- * </pre>
+ * <pre>{@code
+ * <simpleType name="formChoice">
+ *   <restriction base="{http://www.w3.org/2001/XMLSchema}NMTOKEN">
+ *     <enumeration value="qualified"/>
+ *     <enumeration value="unqualified"/>
+ *   </restriction>
+ * </simpleType>
+ * }</pre>
  *
  */
 @XmlType(name = "formChoice")
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Group.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Group.java
index 91dcad1..68e4784 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Group.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Group.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -40,18 +40,18 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType name="group">
- *   &lt;complexContent>
- *     &lt;extension base="{http://www.w3.org/2001/XMLSchema}annotated">
- *       &lt;group ref="{http://www.w3.org/2001/XMLSchema}particle" maxOccurs="unbounded" minOccurs="0"/>
- *       &lt;attGroup ref="{http://www.w3.org/2001/XMLSchema}defRef"/>
- *       &lt;attGroup ref="{http://www.w3.org/2001/XMLSchema}occurs"/>
- *       &lt;anyAttribute processContents='lax' namespace='##other'/>
- *     &lt;/extension>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
+ * <pre>{@code
+ * <complexType name="group">
+ *   <complexContent>
+ *     <extension base="{http://www.w3.org/2001/XMLSchema}annotated">
+ *       <group ref="{http://www.w3.org/2001/XMLSchema}particle" maxOccurs="unbounded" minOccurs="0"/>
+ *       <attGroup ref="{http://www.w3.org/2001/XMLSchema}defRef"/>
+ *       <attGroup ref="{http://www.w3.org/2001/XMLSchema}occurs"/>
+ *       <anyAttribute processContents='lax' namespace='##other'/>
+ *     </extension>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  *
  *
  */
@@ -102,7 +102,7 @@
      * For example, to add a new item, do as follows:
      * <pre>
      *    getParticle().add(newItem);
-     * </pre>
+     * }</pre>
      *
      *
      * <p>
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/GroupRef.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/GroupRef.java
index 9c3b327..5c569be 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/GroupRef.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/GroupRef.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -24,19 +24,19 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType name="groupRef">
- *   &lt;complexContent>
- *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}realGroup">
- *       &lt;sequence>
- *         &lt;element ref="{http://www.w3.org/2001/XMLSchema}annotation" minOccurs="0"/>
- *       &lt;/sequence>
- *       &lt;attribute name="ref" use="required" type="{http://www.w3.org/2001/XMLSchema}QName" />
- *       &lt;anyAttribute processContents='lax' namespace='##other'/>
- *     &lt;/restriction>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
+ * <pre>{@code
+ * <complexType name="groupRef">
+ *   <complexContent>
+ *     <restriction base="{http://www.w3.org/2001/XMLSchema}realGroup">
+ *       <sequence>
+ *         <element ref="{http://www.w3.org/2001/XMLSchema}annotation" minOccurs="0"/>
+ *       </sequence>
+ *       <attribute name="ref" use="required" type="{http://www.w3.org/2001/XMLSchema}QName" />
+ *       <anyAttribute processContents='lax' namespace='##other'/>
+ *     </restriction>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  *
  *
  */
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Import.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Import.java
index e29a96d..101dc27 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Import.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Import.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -27,17 +27,17 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType>
- *   &lt;complexContent>
- *     &lt;extension base="{http://www.w3.org/2001/XMLSchema}annotated">
- *       &lt;attribute name="namespace" type="{http://www.w3.org/2001/XMLSchema}anyURI" />
- *       &lt;attribute name="schemaLocation" type="{http://www.w3.org/2001/XMLSchema}anyURI" />
- *       &lt;anyAttribute processContents='lax' namespace='##other'/>
- *     &lt;/extension>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
+ * <pre>{@code
+ * <complexType>
+ *   <complexContent>
+ *     <extension base="{http://www.w3.org/2001/XMLSchema}annotated">
+ *       <attribute name="namespace" type="{http://www.w3.org/2001/XMLSchema}anyURI" />
+ *       <attribute name="schemaLocation" type="{http://www.w3.org/2001/XMLSchema}anyURI" />
+ *       <anyAttribute processContents='lax' namespace='##other'/>
+ *     </extension>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  *
  *
  */
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Include.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Include.java
index b73f188..59839fd 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Include.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Include.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -27,16 +27,16 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType>
- *   &lt;complexContent>
- *     &lt;extension base="{http://www.w3.org/2001/XMLSchema}annotated">
- *       &lt;attribute name="schemaLocation" use="required" type="{http://www.w3.org/2001/XMLSchema}anyURI" />
- *       &lt;anyAttribute processContents='lax' namespace='##other'/>
- *     &lt;/extension>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
+ * <pre>{@code
+ * <complexType>
+ *   <complexContent>
+ *     <extension base="{http://www.w3.org/2001/XMLSchema}annotated">
+ *       <attribute name="schemaLocation" use="required" type="{http://www.w3.org/2001/XMLSchema}anyURI" />
+ *       <anyAttribute processContents='lax' namespace='##other'/>
+ *     </extension>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  *
  *
  */
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Keybase.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Keybase.java
index 8d60806..1a9050d 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Keybase.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Keybase.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -32,20 +32,20 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType name="keybase">
- *   &lt;complexContent>
- *     &lt;extension base="{http://www.w3.org/2001/XMLSchema}annotated">
- *       &lt;sequence>
- *         &lt;element ref="{http://www.w3.org/2001/XMLSchema}selector"/>
- *         &lt;element ref="{http://www.w3.org/2001/XMLSchema}field" maxOccurs="unbounded"/>
- *       &lt;/sequence>
- *       &lt;attribute name="name" use="required" type="{http://www.w3.org/2001/XMLSchema}NCName" />
- *       &lt;anyAttribute processContents='lax' namespace='##other'/>
- *     &lt;/extension>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
+ * <pre>{@code
+ * <complexType name="keybase">
+ *   <complexContent>
+ *     <extension base="{http://www.w3.org/2001/XMLSchema}annotated">
+ *       <sequence>
+ *         <element ref="{http://www.w3.org/2001/XMLSchema}selector"/>
+ *         <element ref="{http://www.w3.org/2001/XMLSchema}field" maxOccurs="unbounded"/>
+ *       </sequence>
+ *       <attribute name="name" use="required" type="{http://www.w3.org/2001/XMLSchema}NCName" />
+ *       <anyAttribute processContents='lax' namespace='##other'/>
+ *     </extension>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  *
  *
  */
@@ -107,7 +107,7 @@
      * For example, to add a new item, do as follows:
      * <pre>
      *    getField().add(newItem);
-     * </pre>
+     * }</pre>
      *
      *
      * <p>
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Keyref.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Keyref.java
index e09f731..4bea968 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Keyref.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Keyref.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -27,16 +27,16 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType>
- *   &lt;complexContent>
- *     &lt;extension base="{http://www.w3.org/2001/XMLSchema}keybase">
- *       &lt;attribute name="refer" use="required" type="{http://www.w3.org/2001/XMLSchema}QName" />
- *       &lt;anyAttribute processContents='lax' namespace='##other'/>
- *     &lt;/extension>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
+ * <pre>{@code
+ * <complexType>
+ *   <complexContent>
+ *     <extension base="{http://www.w3.org/2001/XMLSchema}keybase">
+ *       <attribute name="refer" use="required" type="{http://www.w3.org/2001/XMLSchema}QName" />
+ *       <anyAttribute processContents='lax' namespace='##other'/>
+ *     </extension>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  *
  *
  */
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/List.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/List.java
index cbba7cb..c6445ec 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/List.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/List.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -32,19 +32,19 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType>
- *   &lt;complexContent>
- *     &lt;extension base="{http://www.w3.org/2001/XMLSchema}annotated">
- *       &lt;sequence>
- *         &lt;element name="simpleType" type="{http://www.w3.org/2001/XMLSchema}localSimpleType" minOccurs="0"/>
- *       &lt;/sequence>
- *       &lt;attribute name="itemType" type="{http://www.w3.org/2001/XMLSchema}QName" />
- *       &lt;anyAttribute processContents='lax' namespace='##other'/>
- *     &lt;/extension>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
+ * <pre>{@code
+ * <complexType>
+ *   <complexContent>
+ *     <extension base="{http://www.w3.org/2001/XMLSchema}annotated">
+ *       <sequence>
+ *         <element name="simpleType" type="{http://www.w3.org/2001/XMLSchema}localSimpleType" minOccurs="0"/>
+ *       </sequence>
+ *       <attribute name="itemType" type="{http://www.w3.org/2001/XMLSchema}QName" />
+ *       <anyAttribute processContents='lax' namespace='##other'/>
+ *     </extension>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  *
  *
  */
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/LocalComplexType.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/LocalComplexType.java
index 434ff88..8726712 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/LocalComplexType.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/LocalComplexType.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -24,19 +24,19 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType name="localComplexType">
- *   &lt;complexContent>
- *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}complexType">
- *       &lt;sequence>
- *         &lt;element ref="{http://www.w3.org/2001/XMLSchema}annotation" minOccurs="0"/>
- *         &lt;group ref="{http://www.w3.org/2001/XMLSchema}complexTypeModel"/>
- *       &lt;/sequence>
- *       &lt;anyAttribute processContents='lax' namespace='##other'/>
- *     &lt;/restriction>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
+ * <pre>{@code
+ * <complexType name="localComplexType">
+ *   <complexContent>
+ *     <restriction base="{http://www.w3.org/2001/XMLSchema}complexType">
+ *       <sequence>
+ *         <element ref="{http://www.w3.org/2001/XMLSchema}annotation" minOccurs="0"/>
+ *         <group ref="{http://www.w3.org/2001/XMLSchema}complexTypeModel"/>
+ *       </sequence>
+ *       <anyAttribute processContents='lax' namespace='##other'/>
+ *     </restriction>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  *
  *
  */
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/LocalElement.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/LocalElement.java
index e289b2b..33d8537 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/LocalElement.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/LocalElement.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -25,23 +25,23 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType name="localElement">
- *   &lt;complexContent>
- *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}element">
- *       &lt;sequence>
- *         &lt;element ref="{http://www.w3.org/2001/XMLSchema}annotation" minOccurs="0"/>
- *         &lt;choice minOccurs="0">
- *           &lt;element name="simpleType" type="{http://www.w3.org/2001/XMLSchema}localSimpleType"/>
- *           &lt;element name="complexType" type="{http://www.w3.org/2001/XMLSchema}localComplexType"/>
- *         &lt;/choice>
- *         &lt;group ref="{http://www.w3.org/2001/XMLSchema}identityConstraint" maxOccurs="unbounded" minOccurs="0"/>
- *       &lt;/sequence>
- *       &lt;anyAttribute processContents='lax' namespace='##other'/>
- *     &lt;/restriction>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
+ * <pre>{@code
+ * <complexType name="localElement">
+ *   <complexContent>
+ *     <restriction base="{http://www.w3.org/2001/XMLSchema}element">
+ *       <sequence>
+ *         <element ref="{http://www.w3.org/2001/XMLSchema}annotation" minOccurs="0"/>
+ *         <choice minOccurs="0">
+ *           <element name="simpleType" type="{http://www.w3.org/2001/XMLSchema}localSimpleType"/>
+ *           <element name="complexType" type="{http://www.w3.org/2001/XMLSchema}localComplexType"/>
+ *         </choice>
+ *         <group ref="{http://www.w3.org/2001/XMLSchema}identityConstraint" maxOccurs="unbounded" minOccurs="0"/>
+ *       </sequence>
+ *       <anyAttribute processContents='lax' namespace='##other'/>
+ *     </restriction>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  *
  *
  */
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/LocalSimpleType.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/LocalSimpleType.java
index 8ae8688..6885c50 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/LocalSimpleType.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/LocalSimpleType.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -24,19 +24,19 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType name="localSimpleType">
- *   &lt;complexContent>
- *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}simpleType">
- *       &lt;sequence>
- *         &lt;element ref="{http://www.w3.org/2001/XMLSchema}annotation" minOccurs="0"/>
- *         &lt;group ref="{http://www.w3.org/2001/XMLSchema}simpleDerivation"/>
- *       &lt;/sequence>
- *       &lt;anyAttribute processContents='lax' namespace='##other'/>
- *     &lt;/restriction>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
+ * <pre>{@code
+ * <complexType name="localSimpleType">
+ *   <complexContent>
+ *     <restriction base="{http://www.w3.org/2001/XMLSchema}simpleType">
+ *       <sequence>
+ *         <element ref="{http://www.w3.org/2001/XMLSchema}annotation" minOccurs="0"/>
+ *         <group ref="{http://www.w3.org/2001/XMLSchema}simpleDerivation"/>
+ *       </sequence>
+ *       <anyAttribute processContents='lax' namespace='##other'/>
+ *     </restriction>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  *
  *
  */
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/NamedAttributeGroup.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/NamedAttributeGroup.java
index 6abcf3e..6edbfe7 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/NamedAttributeGroup.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/NamedAttributeGroup.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -24,20 +24,20 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType name="namedAttributeGroup">
- *   &lt;complexContent>
- *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}attributeGroup">
- *       &lt;sequence>
- *         &lt;element ref="{http://www.w3.org/2001/XMLSchema}annotation" minOccurs="0"/>
- *         &lt;group ref="{http://www.w3.org/2001/XMLSchema}attrDecls"/>
- *       &lt;/sequence>
- *       &lt;attribute name="name" use="required" type="{http://www.w3.org/2001/XMLSchema}NCName" />
- *       &lt;anyAttribute processContents='lax' namespace='##other'/>
- *     &lt;/restriction>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
+ * <pre>{@code
+ * <complexType name="namedAttributeGroup">
+ *   <complexContent>
+ *     <restriction base="{http://www.w3.org/2001/XMLSchema}attributeGroup">
+ *       <sequence>
+ *         <element ref="{http://www.w3.org/2001/XMLSchema}annotation" minOccurs="0"/>
+ *         <group ref="{http://www.w3.org/2001/XMLSchema}attrDecls"/>
+ *       </sequence>
+ *       <attribute name="name" use="required" type="{http://www.w3.org/2001/XMLSchema}NCName" />
+ *       <anyAttribute processContents='lax' namespace='##other'/>
+ *     </restriction>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  *
  *
  */
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/NamedGroup.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/NamedGroup.java
index 18d1c65..3e6868e 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/NamedGroup.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/NamedGroup.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -24,33 +24,33 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType name="namedGroup">
- *   &lt;complexContent>
- *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}realGroup">
- *       &lt;sequence>
- *         &lt;element ref="{http://www.w3.org/2001/XMLSchema}annotation" minOccurs="0"/>
- *         &lt;choice>
- *           &lt;element name="all">
- *             &lt;complexType>
- *               &lt;complexContent>
- *                 &lt;restriction base="{http://www.w3.org/2001/XMLSchema}all">
- *                   &lt;group ref="{http://www.w3.org/2001/XMLSchema}allModel"/>
- *                   &lt;anyAttribute processContents='lax' namespace='##other'/>
- *                 &lt;/restriction>
- *               &lt;/complexContent>
- *             &lt;/complexType>
- *           &lt;/element>
- *           &lt;element name="choice" type="{http://www.w3.org/2001/XMLSchema}simpleExplicitGroup"/>
- *           &lt;element name="sequence" type="{http://www.w3.org/2001/XMLSchema}simpleExplicitGroup"/>
- *         &lt;/choice>
- *       &lt;/sequence>
- *       &lt;attribute name="name" use="required" type="{http://www.w3.org/2001/XMLSchema}NCName" />
- *       &lt;anyAttribute processContents='lax' namespace='##other'/>
- *     &lt;/restriction>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
+ * <pre>{@code
+ * <complexType name="namedGroup">
+ *   <complexContent>
+ *     <restriction base="{http://www.w3.org/2001/XMLSchema}realGroup">
+ *       <sequence>
+ *         <element ref="{http://www.w3.org/2001/XMLSchema}annotation" minOccurs="0"/>
+ *         <choice>
+ *           <element name="all">
+ *             <complexType>
+ *               <complexContent>
+ *                 <restriction base="{http://www.w3.org/2001/XMLSchema}all">
+ *                   <group ref="{http://www.w3.org/2001/XMLSchema}allModel"/>
+ *                   <anyAttribute processContents='lax' namespace='##other'/>
+ *                 </restriction>
+ *               </complexContent>
+ *             </complexType>
+ *           </element>
+ *           <element name="choice" type="{http://www.w3.org/2001/XMLSchema}simpleExplicitGroup"/>
+ *           <element name="sequence" type="{http://www.w3.org/2001/XMLSchema}simpleExplicitGroup"/>
+ *         </choice>
+ *       </sequence>
+ *       <attribute name="name" use="required" type="{http://www.w3.org/2001/XMLSchema}NCName" />
+ *       <anyAttribute processContents='lax' namespace='##other'/>
+ *     </restriction>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  *
  *
  */
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/NarrowMaxMin.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/NarrowMaxMin.java
index 313c968..0e76cb7 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/NarrowMaxMin.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/NarrowMaxMin.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -26,39 +26,39 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType name="narrowMaxMin">
- *   &lt;complexContent>
- *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}localElement">
- *       &lt;sequence>
- *         &lt;element ref="{http://www.w3.org/2001/XMLSchema}annotation" minOccurs="0"/>
- *         &lt;choice minOccurs="0">
- *           &lt;element name="simpleType" type="{http://www.w3.org/2001/XMLSchema}localSimpleType"/>
- *           &lt;element name="complexType" type="{http://www.w3.org/2001/XMLSchema}localComplexType"/>
- *         &lt;/choice>
- *         &lt;group ref="{http://www.w3.org/2001/XMLSchema}identityConstraint" maxOccurs="unbounded" minOccurs="0"/>
- *       &lt;/sequence>
- *       &lt;attribute name="minOccurs" default="1">
- *         &lt;simpleType>
- *           &lt;restriction base="{http://www.w3.org/2001/XMLSchema}nonNegativeInteger">
- *             &lt;enumeration value="0"/>
- *             &lt;enumeration value="1"/>
- *           &lt;/restriction>
- *         &lt;/simpleType>
- *       &lt;/attribute>
- *       &lt;attribute name="maxOccurs" default="1">
- *         &lt;simpleType>
- *           &lt;restriction base="{http://www.w3.org/2001/XMLSchema}allNNI">
- *             &lt;enumeration value="0"/>
- *             &lt;enumeration value="1"/>
- *           &lt;/restriction>
- *         &lt;/simpleType>
- *       &lt;/attribute>
- *       &lt;anyAttribute processContents='lax' namespace='##other'/>
- *     &lt;/restriction>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
+ * <pre>{@code
+ * <complexType name="narrowMaxMin">
+ *   <complexContent>
+ *     <restriction base="{http://www.w3.org/2001/XMLSchema}localElement">
+ *       <sequence>
+ *         <element ref="{http://www.w3.org/2001/XMLSchema}annotation" minOccurs="0"/>
+ *         <choice minOccurs="0">
+ *           <element name="simpleType" type="{http://www.w3.org/2001/XMLSchema}localSimpleType"/>
+ *           <element name="complexType" type="{http://www.w3.org/2001/XMLSchema}localComplexType"/>
+ *         </choice>
+ *         <group ref="{http://www.w3.org/2001/XMLSchema}identityConstraint" maxOccurs="unbounded" minOccurs="0"/>
+ *       </sequence>
+ *       <attribute name="minOccurs" default="1">
+ *         <simpleType>
+ *           <restriction base="{http://www.w3.org/2001/XMLSchema}nonNegativeInteger">
+ *             <enumeration value="0"/>
+ *             <enumeration value="1"/>
+ *           </restriction>
+ *         </simpleType>
+ *       </attribute>
+ *       <attribute name="maxOccurs" default="1">
+ *         <simpleType>
+ *           <restriction base="{http://www.w3.org/2001/XMLSchema}allNNI">
+ *             <enumeration value="0"/>
+ *             <enumeration value="1"/>
+ *           </restriction>
+ *         </simpleType>
+ *       </attribute>
+ *       <anyAttribute processContents='lax' namespace='##other'/>
+ *     </restriction>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  *
  *
  */
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/NoFixedFacet.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/NoFixedFacet.java
index bfa9174..9a83f00 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/NoFixedFacet.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/NoFixedFacet.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -25,18 +25,18 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType name="noFixedFacet">
- *   &lt;complexContent>
- *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}facet">
- *       &lt;sequence>
- *         &lt;element ref="{http://www.w3.org/2001/XMLSchema}annotation" minOccurs="0"/>
- *       &lt;/sequence>
- *       &lt;anyAttribute processContents='lax' namespace='##other'/>
- *     &lt;/restriction>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
+ * <pre>{@code
+ * <complexType name="noFixedFacet">
+ *   <complexContent>
+ *     <restriction base="{http://www.w3.org/2001/XMLSchema}facet">
+ *       <sequence>
+ *         <element ref="{http://www.w3.org/2001/XMLSchema}annotation" minOccurs="0"/>
+ *       </sequence>
+ *       <anyAttribute processContents='lax' namespace='##other'/>
+ *     </restriction>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  *
  *
  */
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Notation.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Notation.java
index c262b6a..ec979fe 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Notation.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Notation.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -29,18 +29,18 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType>
- *   &lt;complexContent>
- *     &lt;extension base="{http://www.w3.org/2001/XMLSchema}annotated">
- *       &lt;attribute name="name" use="required" type="{http://www.w3.org/2001/XMLSchema}NCName" />
- *       &lt;attribute name="public" type="{http://www.w3.org/2001/XMLSchema}public" />
- *       &lt;attribute name="system" type="{http://www.w3.org/2001/XMLSchema}anyURI" />
- *       &lt;anyAttribute processContents='lax' namespace='##other'/>
- *     &lt;/extension>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
+ * <pre>{@code
+ * <complexType>
+ *   <complexContent>
+ *     <extension base="{http://www.w3.org/2001/XMLSchema}annotated">
+ *       <attribute name="name" use="required" type="{http://www.w3.org/2001/XMLSchema}NCName" />
+ *       <attribute name="public" type="{http://www.w3.org/2001/XMLSchema}public" />
+ *       <attribute name="system" type="{http://www.w3.org/2001/XMLSchema}anyURI" />
+ *       <anyAttribute processContents='lax' namespace='##other'/>
+ *     </extension>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  *
  *
  */
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/NumFacet.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/NumFacet.java
index c946ee7..5eb193f 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/NumFacet.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/NumFacet.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -25,19 +25,19 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType name="numFacet">
- *   &lt;complexContent>
- *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}facet">
- *       &lt;sequence>
- *         &lt;element ref="{http://www.w3.org/2001/XMLSchema}annotation" minOccurs="0"/>
- *       &lt;/sequence>
- *       &lt;attribute name="value" use="required" type="{http://www.w3.org/2001/XMLSchema}nonNegativeInteger" />
- *       &lt;anyAttribute processContents='lax' namespace='##other'/>
- *     &lt;/restriction>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
+ * <pre>{@code
+ * <complexType name="numFacet">
+ *   <complexContent>
+ *     <restriction base="{http://www.w3.org/2001/XMLSchema}facet">
+ *       <sequence>
+ *         <element ref="{http://www.w3.org/2001/XMLSchema}annotation" minOccurs="0"/>
+ *       </sequence>
+ *       <attribute name="value" use="required" type="{http://www.w3.org/2001/XMLSchema}nonNegativeInteger" />
+ *       <anyAttribute processContents='lax' namespace='##other'/>
+ *     </restriction>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  *
  *
  */
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/OpenAttrs.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/OpenAttrs.java
index 93b0cc7..4d7c0f2 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/OpenAttrs.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/OpenAttrs.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -35,15 +35,15 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType name="openAttrs">
- *   &lt;complexContent>
- *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
- *       &lt;anyAttribute processContents='lax' namespace='##other'/>
- *     &lt;/restriction>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
+ * <pre>{@code
+ * <complexType name="openAttrs">
+ *   <complexContent>
+ *     <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
+ *       <anyAttribute processContents='lax' namespace='##other'/>
+ *     </restriction>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  *
  *
  */
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Pattern.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Pattern.java
index afca167..0eeb51b 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Pattern.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Pattern.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -25,19 +25,19 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType>
- *   &lt;complexContent>
- *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}noFixedFacet">
- *       &lt;sequence>
- *         &lt;element ref="{http://www.w3.org/2001/XMLSchema}annotation" minOccurs="0"/>
- *       &lt;/sequence>
- *       &lt;attribute name="value" use="required" type="{http://www.w3.org/2001/XMLSchema}string" />
- *       &lt;anyAttribute processContents='lax' namespace='##other'/>
- *     &lt;/restriction>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
+ * <pre>{@code
+ * <complexType>
+ *   <complexContent>
+ *     <restriction base="{http://www.w3.org/2001/XMLSchema}noFixedFacet">
+ *       <sequence>
+ *         <element ref="{http://www.w3.org/2001/XMLSchema}annotation" minOccurs="0"/>
+ *       </sequence>
+ *       <attribute name="value" use="required" type="{http://www.w3.org/2001/XMLSchema}string" />
+ *       <anyAttribute processContents='lax' namespace='##other'/>
+ *     </restriction>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  *
  *
  */
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/RealGroup.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/RealGroup.java
index 69031be..d6f02ee 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/RealGroup.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/RealGroup.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -25,23 +25,23 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType name="realGroup">
- *   &lt;complexContent>
- *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}group">
- *       &lt;sequence>
- *         &lt;element ref="{http://www.w3.org/2001/XMLSchema}annotation" minOccurs="0"/>
- *         &lt;choice minOccurs="0">
- *           &lt;element ref="{http://www.w3.org/2001/XMLSchema}all"/>
- *           &lt;element ref="{http://www.w3.org/2001/XMLSchema}choice"/>
- *           &lt;element ref="{http://www.w3.org/2001/XMLSchema}sequence"/>
- *         &lt;/choice>
- *       &lt;/sequence>
- *       &lt;anyAttribute processContents='lax' namespace='##other'/>
- *     &lt;/restriction>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
+ * <pre>{@code
+ * <complexType name="realGroup">
+ *   <complexContent>
+ *     <restriction base="{http://www.w3.org/2001/XMLSchema}group">
+ *       <sequence>
+ *         <element ref="{http://www.w3.org/2001/XMLSchema}annotation" minOccurs="0"/>
+ *         <choice minOccurs="0">
+ *           <element ref="{http://www.w3.org/2001/XMLSchema}all"/>
+ *           <element ref="{http://www.w3.org/2001/XMLSchema}choice"/>
+ *           <element ref="{http://www.w3.org/2001/XMLSchema}sequence"/>
+ *         </choice>
+ *       </sequence>
+ *       <anyAttribute processContents='lax' namespace='##other'/>
+ *     </restriction>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  *
  *
  */
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Redefine.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Redefine.java
index dcda908..a51f20b 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Redefine.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Redefine.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -34,21 +34,21 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType>
- *   &lt;complexContent>
- *     &lt;extension base="{http://www.w3.org/2001/XMLSchema}openAttrs">
- *       &lt;choice maxOccurs="unbounded" minOccurs="0">
- *         &lt;element ref="{http://www.w3.org/2001/XMLSchema}annotation"/>
- *         &lt;group ref="{http://www.w3.org/2001/XMLSchema}redefinable"/>
- *       &lt;/choice>
- *       &lt;attribute name="schemaLocation" use="required" type="{http://www.w3.org/2001/XMLSchema}anyURI" />
- *       &lt;attribute name="id" type="{http://www.w3.org/2001/XMLSchema}ID" />
- *       &lt;anyAttribute processContents='lax' namespace='##other'/>
- *     &lt;/extension>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
+ * <pre>{@code
+ * <complexType>
+ *   <complexContent>
+ *     <extension base="{http://www.w3.org/2001/XMLSchema}openAttrs">
+ *       <choice maxOccurs="unbounded" minOccurs="0">
+ *         <element ref="{http://www.w3.org/2001/XMLSchema}annotation"/>
+ *         <group ref="{http://www.w3.org/2001/XMLSchema}redefinable"/>
+ *       </choice>
+ *       <attribute name="schemaLocation" use="required" type="{http://www.w3.org/2001/XMLSchema}anyURI" />
+ *       <attribute name="id" type="{http://www.w3.org/2001/XMLSchema}ID" />
+ *       <anyAttribute processContents='lax' namespace='##other'/>
+ *     </extension>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  *
  *
  */
@@ -91,7 +91,7 @@
      * For example, to add a new item, do as follows:
      * <pre>
      *    getAnnotationOrSimpleTypeOrComplexType().add(newItem);
-     * </pre>
+     * }</pre>
      *
      *
      * <p>
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/ReducedDerivationControl.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/ReducedDerivationControl.java
index 5beb07e..9667459 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/ReducedDerivationControl.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/ReducedDerivationControl.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -24,14 +24,14 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  * <p>
- * <pre>
- * &lt;simpleType name="reducedDerivationControl">
- *   &lt;restriction base="{http://www.w3.org/2001/XMLSchema}derivationControl">
- *     &lt;enumeration value="extension"/>
- *     &lt;enumeration value="restriction"/>
- *   &lt;/restriction>
- * &lt;/simpleType>
- * </pre>
+ * <pre>{@code
+ * <simpleType name="reducedDerivationControl">
+ *   <restriction base="{http://www.w3.org/2001/XMLSchema}derivationControl">
+ *     <enumeration value="extension"/>
+ *     <enumeration value="restriction"/>
+ *   </restriction>
+ * </simpleType>
+ * }</pre>
  *
  */
 @XmlType(name = "reducedDerivationControl")
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Restriction.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Restriction.java
index 5b892cf..a7af6cf 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Restriction.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Restriction.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -37,17 +37,17 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType>
- *   &lt;complexContent>
- *     &lt;extension base="{http://www.w3.org/2001/XMLSchema}annotated">
- *       &lt;group ref="{http://www.w3.org/2001/XMLSchema}simpleRestrictionModel"/>
- *       &lt;attribute name="base" type="{http://www.w3.org/2001/XMLSchema}QName" />
- *       &lt;anyAttribute processContents='lax' namespace='##other'/>
- *     &lt;/extension>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
+ * <pre>{@code
+ * <complexType>
+ *   <complexContent>
+ *     <extension base="{http://www.w3.org/2001/XMLSchema}annotated">
+ *       <group ref="{http://www.w3.org/2001/XMLSchema}simpleRestrictionModel"/>
+ *       <attribute name="base" type="{http://www.w3.org/2001/XMLSchema}QName" />
+ *       <anyAttribute processContents='lax' namespace='##other'/>
+ *     </extension>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  *
  *
  */
@@ -117,7 +117,7 @@
      * For example, to add a new item, do as follows:
      * <pre>
      *    getFacets().add(newItem);
-     * </pre>
+     * }</pre>
      *
      *
      * <p>
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/RestrictionType.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/RestrictionType.java
index 5dc630c..1c48ae5 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/RestrictionType.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/RestrictionType.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -34,23 +34,23 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType name="restrictionType">
- *   &lt;complexContent>
- *     &lt;extension base="{http://www.w3.org/2001/XMLSchema}annotated">
- *       &lt;sequence>
- *         &lt;choice minOccurs="0">
- *           &lt;group ref="{http://www.w3.org/2001/XMLSchema}typeDefParticle"/>
- *           &lt;group ref="{http://www.w3.org/2001/XMLSchema}simpleRestrictionModel"/>
- *         &lt;/choice>
- *         &lt;group ref="{http://www.w3.org/2001/XMLSchema}attrDecls"/>
- *       &lt;/sequence>
- *       &lt;attribute name="base" use="required" type="{http://www.w3.org/2001/XMLSchema}QName" />
- *       &lt;anyAttribute processContents='lax' namespace='##other'/>
- *     &lt;/extension>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
+ * <pre>{@code
+ * <complexType name="restrictionType">
+ *   <complexContent>
+ *     <extension base="{http://www.w3.org/2001/XMLSchema}annotated">
+ *       <sequence>
+ *         <choice minOccurs="0">
+ *           <group ref="{http://www.w3.org/2001/XMLSchema}typeDefParticle"/>
+ *           <group ref="{http://www.w3.org/2001/XMLSchema}simpleRestrictionModel"/>
+ *         </choice>
+ *         <group ref="{http://www.w3.org/2001/XMLSchema}attrDecls"/>
+ *       </sequence>
+ *       <attribute name="base" use="required" type="{http://www.w3.org/2001/XMLSchema}QName" />
+ *       <anyAttribute processContents='lax' namespace='##other'/>
+ *     </extension>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  *
  *
  */
@@ -235,7 +235,7 @@
      * For example, to add a new item, do as follows:
      * <pre>
      *    getFacets().add(newItem);
-     * </pre>
+     * }</pre>
      *
      *
      * <p>
@@ -275,7 +275,7 @@
      * For example, to add a new item, do as follows:
      * <pre>
      *    getAttributeOrAttributeGroup().add(newItem);
-     * </pre>
+     * }</pre>
      *
      *
      * <p>
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Schema.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Schema.java
index 20c8b43..0488dff 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Schema.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Schema.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -34,34 +34,34 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType>
- *   &lt;complexContent>
- *     &lt;extension base="{http://www.w3.org/2001/XMLSchema}openAttrs">
- *       &lt;sequence>
- *         &lt;choice maxOccurs="unbounded" minOccurs="0">
- *           &lt;element ref="{http://www.w3.org/2001/XMLSchema}include"/>
- *           &lt;element ref="{http://www.w3.org/2001/XMLSchema}import"/>
- *           &lt;element ref="{http://www.w3.org/2001/XMLSchema}redefine"/>
- *           &lt;element ref="{http://www.w3.org/2001/XMLSchema}annotation"/>
- *         &lt;/choice>
- *         &lt;sequence maxOccurs="unbounded" minOccurs="0">
- *           &lt;group ref="{http://www.w3.org/2001/XMLSchema}schemaTop"/>
- *           &lt;element ref="{http://www.w3.org/2001/XMLSchema}annotation" maxOccurs="unbounded" minOccurs="0"/>
- *         &lt;/sequence>
- *       &lt;/sequence>
- *       &lt;attribute name="targetNamespace" type="{http://www.w3.org/2001/XMLSchema}anyURI" />
- *       &lt;attribute name="version" type="{http://www.w3.org/2001/XMLSchema}token" />
- *       &lt;attribute name="finalDefault" type="{http://www.w3.org/2001/XMLSchema}fullDerivationSet" default="" />
- *       &lt;attribute name="blockDefault" type="{http://www.w3.org/2001/XMLSchema}blockSet" default="" />
- *       &lt;attribute name="attributeFormDefault" type="{http://www.w3.org/2001/XMLSchema}formChoice" default="unqualified" />
- *       &lt;attribute name="elementFormDefault" type="{http://www.w3.org/2001/XMLSchema}formChoice" default="unqualified" />
- *       &lt;attribute name="id" type="{http://www.w3.org/2001/XMLSchema}ID" />
- *       &lt;anyAttribute processContents='lax' namespace='##other'/>
- *     &lt;/extension>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
+ * <pre>{@code
+ * <complexType>
+ *   <complexContent>
+ *     <extension base="{http://www.w3.org/2001/XMLSchema}openAttrs">
+ *       <sequence>
+ *         <choice maxOccurs="unbounded" minOccurs="0">
+ *           <element ref="{http://www.w3.org/2001/XMLSchema}include"/>
+ *           <element ref="{http://www.w3.org/2001/XMLSchema}import"/>
+ *           <element ref="{http://www.w3.org/2001/XMLSchema}redefine"/>
+ *           <element ref="{http://www.w3.org/2001/XMLSchema}annotation"/>
+ *         </choice>
+ *         <sequence maxOccurs="unbounded" minOccurs="0">
+ *           <group ref="{http://www.w3.org/2001/XMLSchema}schemaTop"/>
+ *           <element ref="{http://www.w3.org/2001/XMLSchema}annotation" maxOccurs="unbounded" minOccurs="0"/>
+ *         </sequence>
+ *       </sequence>
+ *       <attribute name="targetNamespace" type="{http://www.w3.org/2001/XMLSchema}anyURI" />
+ *       <attribute name="version" type="{http://www.w3.org/2001/XMLSchema}token" />
+ *       <attribute name="finalDefault" type="{http://www.w3.org/2001/XMLSchema}fullDerivationSet" default="" />
+ *       <attribute name="blockDefault" type="{http://www.w3.org/2001/XMLSchema}blockSet" default="" />
+ *       <attribute name="attributeFormDefault" type="{http://www.w3.org/2001/XMLSchema}formChoice" default="unqualified" />
+ *       <attribute name="elementFormDefault" type="{http://www.w3.org/2001/XMLSchema}formChoice" default="unqualified" />
+ *       <attribute name="id" type="{http://www.w3.org/2001/XMLSchema}ID" />
+ *       <anyAttribute processContents='lax' namespace='##other'/>
+ *     </extension>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  *
  *
  */
@@ -129,7 +129,7 @@
      * For example, to add a new item, do as follows:
      * <pre>
      *    getIncludeOrImportOrRedefine().add(newItem);
-     * </pre>
+     * }</pre>
      *
      *
      * <p>
@@ -161,7 +161,7 @@
      * For example, to add a new item, do as follows:
      * <pre>
      *    getSimpleTypeOrComplexTypeOrGroup().add(newItem);
-     * </pre>
+     * }</pre>
      *
      *
      * <p>
@@ -245,7 +245,7 @@
      * For example, to add a new item, do as follows:
      * <pre>
      *    getFinalDefault().add(newItem);
-     * </pre>
+     * }</pre>
      *
      *
      * <p>
@@ -274,7 +274,7 @@
      * For example, to add a new item, do as follows:
      * <pre>
      *    getBlockDefault().add(newItem);
-     * </pre>
+     * }</pre>
      *
      *
      * <p>
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Selector.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Selector.java
index 730a1d1..1ca6c11 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Selector.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Selector.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -28,22 +28,22 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType>
- *   &lt;complexContent>
- *     &lt;extension base="{http://www.w3.org/2001/XMLSchema}annotated">
- *       &lt;attribute name="xpath" use="required">
- *         &lt;simpleType>
- *           &lt;restriction base="{http://www.w3.org/2001/XMLSchema}token">
- *             &lt;pattern value="(\.//)?(((child::)?((\i\c*:)?(\i\c*|\*)))|\.)(/(((child::)?((\i\c*:)?(\i\c*|\*)))|\.))*(\|(\.//)?(((child::)?((\i\c*:)?(\i\c*|\*)))|\.)(/(((child::)?((\i\c*:)?(\i\c*|\*)))|\.))*)*"/>
- *           &lt;/restriction>
- *         &lt;/simpleType>
- *       &lt;/attribute>
- *       &lt;anyAttribute processContents='lax' namespace='##other'/>
- *     &lt;/extension>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
+ * <pre>{@code
+ * <complexType>
+ *   <complexContent>
+ *     <extension base="{http://www.w3.org/2001/XMLSchema}annotated">
+ *       <attribute name="xpath" use="required">
+ *         <simpleType>
+ *           <restriction base="{http://www.w3.org/2001/XMLSchema}token">
+ *             <pattern value="(\.//)?(((child::)?((\i\c*:)?(\i\c*|\*)))|\.)(/(((child::)?((\i\c*:)?(\i\c*|\*)))|\.))*(\|(\.//)?(((child::)?((\i\c*:)?(\i\c*|\*)))|\.)(/(((child::)?((\i\c*:)?(\i\c*|\*)))|\.))*)*"/>
+ *           </restriction>
+ *         </simpleType>
+ *       </attribute>
+ *       <anyAttribute processContents='lax' namespace='##other'/>
+ *     </extension>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  *
  *
  */
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/SimpleContent.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/SimpleContent.java
index 6e17fa8..7da34e9 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/SimpleContent.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/SimpleContent.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -25,19 +25,19 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType>
- *   &lt;complexContent>
- *     &lt;extension base="{http://www.w3.org/2001/XMLSchema}annotated">
- *       &lt;choice>
- *         &lt;element name="restriction" type="{http://www.w3.org/2001/XMLSchema}simpleRestrictionType"/>
- *         &lt;element name="extension" type="{http://www.w3.org/2001/XMLSchema}simpleExtensionType"/>
- *       &lt;/choice>
- *       &lt;anyAttribute processContents='lax' namespace='##other'/>
- *     &lt;/extension>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
+ * <pre>{@code
+ * <complexType>
+ *   <complexContent>
+ *     <extension base="{http://www.w3.org/2001/XMLSchema}annotated">
+ *       <choice>
+ *         <element name="restriction" type="{http://www.w3.org/2001/XMLSchema}simpleRestrictionType"/>
+ *         <element name="extension" type="{http://www.w3.org/2001/XMLSchema}simpleExtensionType"/>
+ *       </choice>
+ *       <anyAttribute processContents='lax' namespace='##other'/>
+ *     </extension>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  *
  *
  */
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/SimpleExplicitGroup.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/SimpleExplicitGroup.java
index a154987..93198dd 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/SimpleExplicitGroup.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/SimpleExplicitGroup.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -24,19 +24,19 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType name="simpleExplicitGroup">
- *   &lt;complexContent>
- *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}explicitGroup">
- *       &lt;sequence>
- *         &lt;element ref="{http://www.w3.org/2001/XMLSchema}annotation" minOccurs="0"/>
- *         &lt;group ref="{http://www.w3.org/2001/XMLSchema}nestedParticle" maxOccurs="unbounded" minOccurs="0"/>
- *       &lt;/sequence>
- *       &lt;anyAttribute processContents='lax' namespace='##other'/>
- *     &lt;/restriction>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
+ * <pre>{@code
+ * <complexType name="simpleExplicitGroup">
+ *   <complexContent>
+ *     <restriction base="{http://www.w3.org/2001/XMLSchema}explicitGroup">
+ *       <sequence>
+ *         <element ref="{http://www.w3.org/2001/XMLSchema}annotation" minOccurs="0"/>
+ *         <group ref="{http://www.w3.org/2001/XMLSchema}nestedParticle" maxOccurs="unbounded" minOccurs="0"/>
+ *       </sequence>
+ *       <anyAttribute processContents='lax' namespace='##other'/>
+ *     </restriction>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  *
  *
  */
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/SimpleExtensionType.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/SimpleExtensionType.java
index 35bede0..3bde0f2 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/SimpleExtensionType.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/SimpleExtensionType.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -24,19 +24,19 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType name="simpleExtensionType">
- *   &lt;complexContent>
- *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}extensionType">
- *       &lt;sequence>
- *         &lt;element ref="{http://www.w3.org/2001/XMLSchema}annotation" minOccurs="0"/>
- *         &lt;group ref="{http://www.w3.org/2001/XMLSchema}attrDecls"/>
- *       &lt;/sequence>
- *       &lt;anyAttribute processContents='lax' namespace='##other'/>
- *     &lt;/restriction>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
+ * <pre>{@code
+ * <complexType name="simpleExtensionType">
+ *   <complexContent>
+ *     <restriction base="{http://www.w3.org/2001/XMLSchema}extensionType">
+ *       <sequence>
+ *         <element ref="{http://www.w3.org/2001/XMLSchema}annotation" minOccurs="0"/>
+ *         <group ref="{http://www.w3.org/2001/XMLSchema}attrDecls"/>
+ *       </sequence>
+ *       <anyAttribute processContents='lax' namespace='##other'/>
+ *     </restriction>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  *
  *
  */
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/SimpleRestrictionType.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/SimpleRestrictionType.java
index 360323a..0da4617 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/SimpleRestrictionType.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/SimpleRestrictionType.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -24,22 +24,22 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType name="simpleRestrictionType">
- *   &lt;complexContent>
- *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}restrictionType">
- *       &lt;sequence>
- *         &lt;element ref="{http://www.w3.org/2001/XMLSchema}annotation" minOccurs="0"/>
- *         &lt;choice minOccurs="0">
- *           &lt;group ref="{http://www.w3.org/2001/XMLSchema}simpleRestrictionModel"/>
- *         &lt;/choice>
- *         &lt;group ref="{http://www.w3.org/2001/XMLSchema}attrDecls"/>
- *       &lt;/sequence>
- *       &lt;anyAttribute processContents='lax' namespace='##other'/>
- *     &lt;/restriction>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
+ * <pre>{@code
+ * <complexType name="simpleRestrictionType">
+ *   <complexContent>
+ *     <restriction base="{http://www.w3.org/2001/XMLSchema}restrictionType">
+ *       <sequence>
+ *         <element ref="{http://www.w3.org/2001/XMLSchema}annotation" minOccurs="0"/>
+ *         <choice minOccurs="0">
+ *           <group ref="{http://www.w3.org/2001/XMLSchema}simpleRestrictionModel"/>
+ *         </choice>
+ *         <group ref="{http://www.w3.org/2001/XMLSchema}attrDecls"/>
+ *       </sequence>
+ *       <anyAttribute processContents='lax' namespace='##other'/>
+ *     </restriction>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  *
  *
  */
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/SimpleType.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/SimpleType.java
index 5cde256..d5afa8c 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/SimpleType.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/SimpleType.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -30,18 +30,18 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType name="simpleType">
- *   &lt;complexContent>
- *     &lt;extension base="{http://www.w3.org/2001/XMLSchema}annotated">
- *       &lt;group ref="{http://www.w3.org/2001/XMLSchema}simpleDerivation"/>
- *       &lt;attribute name="final" type="{http://www.w3.org/2001/XMLSchema}simpleDerivationSet" />
- *       &lt;attribute name="name" type="{http://www.w3.org/2001/XMLSchema}NCName" />
- *       &lt;anyAttribute processContents='lax' namespace='##other'/>
- *     &lt;/extension>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
+ * <pre>{@code
+ * <complexType name="simpleType">
+ *   <complexContent>
+ *     <extension base="{http://www.w3.org/2001/XMLSchema}annotated">
+ *       <group ref="{http://www.w3.org/2001/XMLSchema}simpleDerivation"/>
+ *       <attribute name="final" type="{http://www.w3.org/2001/XMLSchema}simpleDerivationSet" />
+ *       <attribute name="name" type="{http://www.w3.org/2001/XMLSchema}NCName" />
+ *       <anyAttribute processContents='lax' namespace='##other'/>
+ *     </extension>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  *
  *
  */
@@ -99,7 +99,7 @@
      *
      * @return
      *     possible object is
-     *     {@link org.w3._2001.xmlschema.List }
+     *     {@link List }
      *
      */
     public org.eclipse.persistence.testing.jaxb.xmlschema.model.List getList() {
@@ -111,7 +111,7 @@
      *
      * @param value
      *     allowed object is
-     *     {@link org.w3._2001.xmlschema.List }
+     *     {@link List }
      *
      */
     public void setList(org.eclipse.persistence.testing.jaxb.xmlschema.model.List value) {
@@ -155,7 +155,7 @@
      * For example, to add a new item, do as follows:
      * <pre>
      *    getFinal().add(newItem);
-     * </pre>
+     * }</pre>
      *
      *
      * <p>
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/TopLevelAttribute.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/TopLevelAttribute.java
index 62b343f..3d07852 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/TopLevelAttribute.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/TopLevelAttribute.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -24,20 +24,20 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType name="topLevelAttribute">
- *   &lt;complexContent>
- *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}attribute">
- *       &lt;sequence>
- *         &lt;element ref="{http://www.w3.org/2001/XMLSchema}annotation" minOccurs="0"/>
- *         &lt;element name="simpleType" type="{http://www.w3.org/2001/XMLSchema}localSimpleType" minOccurs="0"/>
- *       &lt;/sequence>
- *       &lt;attribute name="name" use="required" type="{http://www.w3.org/2001/XMLSchema}NCName" />
- *       &lt;anyAttribute processContents='lax' namespace='##other'/>
- *     &lt;/restriction>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
+ * <pre>{@code
+ * <complexType name="topLevelAttribute">
+ *   <complexContent>
+ *     <restriction base="{http://www.w3.org/2001/XMLSchema}attribute">
+ *       <sequence>
+ *         <element ref="{http://www.w3.org/2001/XMLSchema}annotation" minOccurs="0"/>
+ *         <element name="simpleType" type="{http://www.w3.org/2001/XMLSchema}localSimpleType" minOccurs="0"/>
+ *       </sequence>
+ *       <attribute name="name" use="required" type="{http://www.w3.org/2001/XMLSchema}NCName" />
+ *       <anyAttribute processContents='lax' namespace='##other'/>
+ *     </restriction>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  *
  *
  */
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/TopLevelComplexType.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/TopLevelComplexType.java
index 7afc491..5da1041 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/TopLevelComplexType.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/TopLevelComplexType.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -24,20 +24,20 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType name="topLevelComplexType">
- *   &lt;complexContent>
- *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}complexType">
- *       &lt;sequence>
- *         &lt;element ref="{http://www.w3.org/2001/XMLSchema}annotation" minOccurs="0"/>
- *         &lt;group ref="{http://www.w3.org/2001/XMLSchema}complexTypeModel"/>
- *       &lt;/sequence>
- *       &lt;attribute name="name" use="required" type="{http://www.w3.org/2001/XMLSchema}NCName" />
- *       &lt;anyAttribute processContents='lax' namespace='##other'/>
- *     &lt;/restriction>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
+ * <pre>{@code
+ * <complexType name="topLevelComplexType">
+ *   <complexContent>
+ *     <restriction base="{http://www.w3.org/2001/XMLSchema}complexType">
+ *       <sequence>
+ *         <element ref="{http://www.w3.org/2001/XMLSchema}annotation" minOccurs="0"/>
+ *         <group ref="{http://www.w3.org/2001/XMLSchema}complexTypeModel"/>
+ *       </sequence>
+ *       <attribute name="name" use="required" type="{http://www.w3.org/2001/XMLSchema}NCName" />
+ *       <anyAttribute processContents='lax' namespace='##other'/>
+ *     </restriction>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  *
  *
  */
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/TopLevelElement.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/TopLevelElement.java
index cc36484..b1b08fa 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/TopLevelElement.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/TopLevelElement.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -24,24 +24,24 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType name="topLevelElement">
- *   &lt;complexContent>
- *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}element">
- *       &lt;sequence>
- *         &lt;element ref="{http://www.w3.org/2001/XMLSchema}annotation" minOccurs="0"/>
- *         &lt;choice minOccurs="0">
- *           &lt;element name="simpleType" type="{http://www.w3.org/2001/XMLSchema}localSimpleType"/>
- *           &lt;element name="complexType" type="{http://www.w3.org/2001/XMLSchema}localComplexType"/>
- *         &lt;/choice>
- *         &lt;group ref="{http://www.w3.org/2001/XMLSchema}identityConstraint" maxOccurs="unbounded" minOccurs="0"/>
- *       &lt;/sequence>
- *       &lt;attribute name="name" use="required" type="{http://www.w3.org/2001/XMLSchema}NCName" />
- *       &lt;anyAttribute processContents='lax' namespace='##other'/>
- *     &lt;/restriction>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
+ * <pre>{@code
+ * <complexType name="topLevelElement">
+ *   <complexContent>
+ *     <restriction base="{http://www.w3.org/2001/XMLSchema}element">
+ *       <sequence>
+ *         <element ref="{http://www.w3.org/2001/XMLSchema}annotation" minOccurs="0"/>
+ *         <choice minOccurs="0">
+ *           <element name="simpleType" type="{http://www.w3.org/2001/XMLSchema}localSimpleType"/>
+ *           <element name="complexType" type="{http://www.w3.org/2001/XMLSchema}localComplexType"/>
+ *         </choice>
+ *         <group ref="{http://www.w3.org/2001/XMLSchema}identityConstraint" maxOccurs="unbounded" minOccurs="0"/>
+ *       </sequence>
+ *       <attribute name="name" use="required" type="{http://www.w3.org/2001/XMLSchema}NCName" />
+ *       <anyAttribute processContents='lax' namespace='##other'/>
+ *     </restriction>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  *
  *
  */
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/TopLevelSimpleType.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/TopLevelSimpleType.java
index 88b2263..aebe5ac 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/TopLevelSimpleType.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/TopLevelSimpleType.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -24,20 +24,20 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType name="topLevelSimpleType">
- *   &lt;complexContent>
- *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}simpleType">
- *       &lt;sequence>
- *         &lt;element ref="{http://www.w3.org/2001/XMLSchema}annotation" minOccurs="0"/>
- *         &lt;group ref="{http://www.w3.org/2001/XMLSchema}simpleDerivation"/>
- *       &lt;/sequence>
- *       &lt;attribute name="name" use="required" type="{http://www.w3.org/2001/XMLSchema}NCName" />
- *       &lt;anyAttribute processContents='lax' namespace='##other'/>
- *     &lt;/restriction>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
+ * <pre>{@code
+ * <complexType name="topLevelSimpleType">
+ *   <complexContent>
+ *     <restriction base="{http://www.w3.org/2001/XMLSchema}simpleType">
+ *       <sequence>
+ *         <element ref="{http://www.w3.org/2001/XMLSchema}annotation" minOccurs="0"/>
+ *         <group ref="{http://www.w3.org/2001/XMLSchema}simpleDerivation"/>
+ *       </sequence>
+ *       <attribute name="name" use="required" type="{http://www.w3.org/2001/XMLSchema}NCName" />
+ *       <anyAttribute processContents='lax' namespace='##other'/>
+ *     </restriction>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  *
  *
  */
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/TotalDigits.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/TotalDigits.java
index 874bc0a..bd7593f 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/TotalDigits.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/TotalDigits.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -25,19 +25,19 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType>
- *   &lt;complexContent>
- *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}numFacet">
- *       &lt;sequence>
- *         &lt;element ref="{http://www.w3.org/2001/XMLSchema}annotation" minOccurs="0"/>
- *       &lt;/sequence>
- *       &lt;attribute name="value" use="required" type="{http://www.w3.org/2001/XMLSchema}positiveInteger" />
- *       &lt;anyAttribute processContents='lax' namespace='##other'/>
- *     &lt;/restriction>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
+ * <pre>{@code
+ * <complexType>
+ *   <complexContent>
+ *     <restriction base="{http://www.w3.org/2001/XMLSchema}numFacet">
+ *       <sequence>
+ *         <element ref="{http://www.w3.org/2001/XMLSchema}annotation" minOccurs="0"/>
+ *       </sequence>
+ *       <attribute name="value" use="required" type="{http://www.w3.org/2001/XMLSchema}positiveInteger" />
+ *       <anyAttribute processContents='lax' namespace='##other'/>
+ *     </restriction>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  *
  *
  */
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/TypeDerivationControl.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/TypeDerivationControl.java
index 44f2224..88f80d6 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/TypeDerivationControl.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/TypeDerivationControl.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -24,16 +24,16 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  * <p>
- * <pre>
- * &lt;simpleType name="typeDerivationControl">
- *   &lt;restriction base="{http://www.w3.org/2001/XMLSchema}derivationControl">
- *     &lt;enumeration value="extension"/>
- *     &lt;enumeration value="restriction"/>
- *     &lt;enumeration value="list"/>
- *     &lt;enumeration value="union"/>
- *   &lt;/restriction>
- * &lt;/simpleType>
- * </pre>
+ * <pre>{@code
+ * <simpleType name="typeDerivationControl">
+ *   <restriction base="{http://www.w3.org/2001/XMLSchema}derivationControl">
+ *     <enumeration value="extension"/>
+ *     <enumeration value="restriction"/>
+ *     <enumeration value="list"/>
+ *     <enumeration value="union"/>
+ *   </restriction>
+ * </simpleType>
+ * }</pre>
  *
  */
 @XmlType(name = "typeDerivationControl")
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Union.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Union.java
index c6f1571..3ef644b 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Union.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Union.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -34,23 +34,23 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType>
- *   &lt;complexContent>
- *     &lt;extension base="{http://www.w3.org/2001/XMLSchema}annotated">
- *       &lt;sequence>
- *         &lt;element name="simpleType" type="{http://www.w3.org/2001/XMLSchema}localSimpleType" maxOccurs="unbounded" minOccurs="0"/>
- *       &lt;/sequence>
- *       &lt;attribute name="memberTypes">
- *         &lt;simpleType>
- *           &lt;list itemType="{http://www.w3.org/2001/XMLSchema}QName" />
- *         &lt;/simpleType>
- *       &lt;/attribute>
- *       &lt;anyAttribute processContents='lax' namespace='##other'/>
- *     &lt;/extension>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
+ * <pre>{@code
+ * <complexType>
+ *   <complexContent>
+ *     <extension base="{http://www.w3.org/2001/XMLSchema}annotated">
+ *       <sequence>
+ *         <element name="simpleType" type="{http://www.w3.org/2001/XMLSchema}localSimpleType" maxOccurs="unbounded" minOccurs="0"/>
+ *       </sequence>
+ *       <attribute name="memberTypes">
+ *         <simpleType>
+ *           <list itemType="{http://www.w3.org/2001/XMLSchema}QName" />
+ *         </simpleType>
+ *       </attribute>
+ *       <anyAttribute processContents='lax' namespace='##other'/>
+ *     </extension>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  *
  *
  */
@@ -80,7 +80,7 @@
      * For example, to add a new item, do as follows:
      * <pre>
      *    getSimpleType().add(newItem);
-     * </pre>
+     * }</pre>
      *
      *
      * <p>
@@ -109,7 +109,7 @@
      * For example, to add a new item, do as follows:
      * <pre>
      *    getMemberTypes().add(newItem);
-     * </pre>
+     * }</pre>
      *
      *
      * <p>
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/WhiteSpace.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/WhiteSpace.java
index ad36810..54041af 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/WhiteSpace.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/WhiteSpace.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -25,27 +25,27 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType>
- *   &lt;complexContent>
- *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}facet">
- *       &lt;sequence>
- *         &lt;element ref="{http://www.w3.org/2001/XMLSchema}annotation" minOccurs="0"/>
- *       &lt;/sequence>
- *       &lt;attribute name="value" use="required">
- *         &lt;simpleType>
- *           &lt;restriction base="{http://www.w3.org/2001/XMLSchema}NMTOKEN">
- *             &lt;enumeration value="preserve"/>
- *             &lt;enumeration value="replace"/>
- *             &lt;enumeration value="collapse"/>
- *           &lt;/restriction>
- *         &lt;/simpleType>
- *       &lt;/attribute>
- *       &lt;anyAttribute processContents='lax' namespace='##other'/>
- *     &lt;/restriction>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
+ * <pre>{@code
+ * <complexType>
+ *   <complexContent>
+ *     <restriction base="{http://www.w3.org/2001/XMLSchema}facet">
+ *       <sequence>
+ *         <element ref="{http://www.w3.org/2001/XMLSchema}annotation" minOccurs="0"/>
+ *       </sequence>
+ *       <attribute name="value" use="required">
+ *         <simpleType>
+ *           <restriction base="{http://www.w3.org/2001/XMLSchema}NMTOKEN">
+ *             <enumeration value="preserve"/>
+ *             <enumeration value="replace"/>
+ *             <enumeration value="collapse"/>
+ *           </restriction>
+ *         </simpleType>
+ *       </attribute>
+ *       <anyAttribute processContents='lax' namespace='##other'/>
+ *     </restriction>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  *
  *
  */
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Wildcard.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Wildcard.java
index 213ec9b..0fcd3da 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Wildcard.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/jaxb/xmlschema/model/Wildcard.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -31,25 +31,25 @@
  *
  * <p>The following schema fragment specifies the expected content contained within this class.
  *
- * <pre>
- * &lt;complexType name="wildcard">
- *   &lt;complexContent>
- *     &lt;extension base="{http://www.w3.org/2001/XMLSchema}annotated">
- *       &lt;attribute name="namespace" type="{http://www.w3.org/2001/XMLSchema}namespaceList" default="##any" />
- *       &lt;attribute name="processContents" default="strict">
- *         &lt;simpleType>
- *           &lt;restriction base="{http://www.w3.org/2001/XMLSchema}NMTOKEN">
- *             &lt;enumeration value="skip"/>
- *             &lt;enumeration value="lax"/>
- *             &lt;enumeration value="strict"/>
- *           &lt;/restriction>
- *         &lt;/simpleType>
- *       &lt;/attribute>
- *       &lt;anyAttribute processContents='lax' namespace='##other'/>
- *     &lt;/extension>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
+ * <pre>{@code
+ * <complexType name="wildcard">
+ *   <complexContent>
+ *     <extension base="{http://www.w3.org/2001/XMLSchema}annotated">
+ *       <attribute name="namespace" type="{http://www.w3.org/2001/XMLSchema}namespaceList" default="##any" />
+ *       <attribute name="processContents" default="strict">
+ *         <simpleType>
+ *           <restriction base="{http://www.w3.org/2001/XMLSchema}NMTOKEN">
+ *             <enumeration value="skip"/>
+ *             <enumeration value="lax"/>
+ *             <enumeration value="strict"/>
+ *           </restriction>
+ *         </simpleType>
+ *       </attribute>
+ *       <anyAttribute processContents='lax' namespace='##other'/>
+ *     </extension>
+ *   </complexContent>
+ * </complexType>
+ * }</pre>
  *
  *
  */
@@ -82,7 +82,7 @@
      * For example, to add a new item, do as follows:
      * <pre>
      *    getNamespace().add(newItem);
-     * </pre>
+     * }</pre>
      *
      *
      * <p>
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/mappings/XMLMappingTestCases.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/mappings/XMLMappingTestCases.java
index 3097a7b..2b1a1c6 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/mappings/XMLMappingTestCases.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/mappings/XMLMappingTestCases.java
@@ -212,7 +212,7 @@
 
     public void testXMLToObjectFromInputStream() throws Exception {
         if(isUnmarshalTest()) {
-            InputStream instream = Thread.currentThread().getContextClassLoader().getSystemResourceAsStream(resourceName);
+            InputStream instream = ClassLoader.getSystemResourceAsStream(resourceName);
             Object testObject = xmlUnmarshaller.unmarshal(instream);
             instream.close();
             xmlToObjectTest(testObject);
@@ -221,7 +221,7 @@
 
     public void testXMLToObjectFromNode() throws Exception {
         if(isUnmarshalTest()) {
-            InputStream instream = Thread.currentThread().getContextClassLoader().getSystemResourceAsStream(resourceName);
+            InputStream instream = ClassLoader.getSystemResourceAsStream(resourceName);
             Node node  = parser.parse(instream);
             Object testObject = xmlUnmarshaller.unmarshal(node);
             instream.close();
@@ -231,7 +231,7 @@
 
     public void testXMLToObjectFromXMLStreamReader() throws Exception {
         if(isUnmarshalTest()  && null != XML_INPUT_FACTORY) {
-            InputStream instream = Thread.currentThread().getContextClassLoader().getSystemResourceAsStream(resourceName);
+            InputStream instream = ClassLoader.getSystemResourceAsStream(resourceName);
             XMLStreamReader xmlStreamReader = XML_INPUT_FACTORY.createXMLStreamReader(instream);
             XMLStreamReaderReader staxReader = new XMLStreamReaderReader();
             staxReader.setErrorHandler(xmlUnmarshaller.getErrorHandler());
@@ -245,7 +245,7 @@
 
     public void testXMLToObjectFromXMLEventReader() throws Exception {
         if(isUnmarshalTest()  && null != XML_INPUT_FACTORY) {
-            InputStream instream = Thread.currentThread().getContextClassLoader().getSystemResourceAsStream(resourceName);
+            InputStream instream = ClassLoader.getSystemResourceAsStream(resourceName);
             XMLEventReader xmlEventReader = XML_INPUT_FACTORY.createXMLEventReader(instream);
             XMLEventReaderReader staxReader = new XMLEventReaderReader();
             staxReader.setErrorHandler(xmlUnmarshaller.getErrorHandler());
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/mappings/anyattribute/withoutgroupingelement/AnyAttributeNSonRootTestCases.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/mappings/anyattribute/withoutgroupingelement/AnyAttributeNSonRootTestCases.java
index 5f7b282..acaef67 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/mappings/anyattribute/withoutgroupingelement/AnyAttributeNSonRootTestCases.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/mappings/anyattribute/withoutgroupingelement/AnyAttributeNSonRootTestCases.java
@@ -23,9 +23,10 @@
  * The Descriptor for Wrapper has a Namepace Resolver with "myns" in it and for ns0
  * The document has some attributes in the anyattribute mapping with a  prefix/uriof ns0 that is on the root
  * ie: (in this case ns0, "www.example.com/test.xsd" is on the root)
+ * <pre>{@code
 *  <myns:wrapper xmlns:myns="www.example.com/some-dir/some.xsd" xmlns:ns0="www.example.com/test.xsd">
  *   <myns:root ns0:first-name="Matt" ns0:last-name="MacIvor"/>
- * </myns:wrapper>
+ * </myns:wrapper>}</pre>
  */
 public class AnyAttributeNSonRootTestCases extends XMLMappingTestCases {
     public AnyAttributeNSonRootTestCases(String name) throws Exception {
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/mappings/anyattribute/withoutgroupingelement/AnyAttributeNotInNRTestCases.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/mappings/anyattribute/withoutgroupingelement/AnyAttributeNotInNRTestCases.java
index a3963da..4b5b3ed 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/mappings/anyattribute/withoutgroupingelement/AnyAttributeNotInNRTestCases.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/mappings/anyattribute/withoutgroupingelement/AnyAttributeNotInNRTestCases.java
@@ -22,9 +22,9 @@
  * The Descriptor for Root has a Namepace Resolver with "myns" in it
  * The document has some attributes in the anyattribute mapping with a new prefix/uri
  * ie: (in this case ns0, "www.example.com/test.xsd" are not in any NR)
- * <myns:root ns0:first-name="Matt" ns0:last-name="MacIvor"
+ * <pre>{@code<myns:root ns0:first-name="Matt" ns0:last-name="MacIvor"
  *        xmlns:myns="www.example.com/some-dir/some.xsd"
- *        xmlns:ns0="www.example.com/test.xsd"/>
+ *        xmlns:ns0="www.example.com/test.xsd"/>}</pre>
  */
 public class AnyAttributeNotInNRTestCases extends XMLMappingTestCases {
     public AnyAttributeNotInNRTestCases(String name) throws Exception {
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/mappings/compositecollection/nillable/CompositeCollectionNodeNullPolicyProject.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/mappings/compositecollection/nillable/CompositeCollectionNodeNullPolicyProject.java
index 41a1f34..b9c1549 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/mappings/compositecollection/nillable/CompositeCollectionNodeNullPolicyProject.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/mappings/compositecollection/nillable/CompositeCollectionNodeNullPolicyProject.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -23,7 +23,6 @@
 
     /**
      * Construct a project with a descriptor setup for all fields that do not use a default NodeNullPolicy
-     * @param aMapping
      * @param fieldsAsElements
      */
     public CompositeCollectionNodeNullPolicyProject(boolean fieldsAsElements) {
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/mappings/compositeobject/nillable/CompositeObjectNodeNullPolicyProject.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/mappings/compositeobject/nillable/CompositeObjectNodeNullPolicyProject.java
index a70de3e..4c5a1a2 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/mappings/compositeobject/nillable/CompositeObjectNodeNullPolicyProject.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/mappings/compositeobject/nillable/CompositeObjectNodeNullPolicyProject.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -23,7 +23,6 @@
 
     /**
      * Construct a project with a descriptor setup for all fields that do not use a default NodeNullPolicy
-     * @param aMapping
      * @param fieldsAsElements
      */
     public CompositeObjectNodeNullPolicyProject(boolean fieldsAsElements) {
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/mappings/compositeobject/nillable/CompositeObjectNodeNullPolicyTextNodeProject.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/mappings/compositeobject/nillable/CompositeObjectNodeNullPolicyTextNodeProject.java
index bdf1678..26fc4fd 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/mappings/compositeobject/nillable/CompositeObjectNodeNullPolicyTextNodeProject.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/mappings/compositeobject/nillable/CompositeObjectNodeNullPolicyTextNodeProject.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -24,7 +24,6 @@
     /**
      * Construct a project with a descriptor setup for all fields that do not use a default NodeNullPolicy
      * The firstname field of the composite object "manager" is a text() field
-     * @param aMapping
      * @param fieldsAsElements
      */
     public CompositeObjectNodeNullPolicyTextNodeProject(boolean fieldsAsElements) {
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/mappings/directcollection/nillable/DirectCollectionNodeNullPolicyProject.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/mappings/directcollection/nillable/DirectCollectionNodeNullPolicyProject.java
index bde0ea6..ad37d50 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/mappings/directcollection/nillable/DirectCollectionNodeNullPolicyProject.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/mappings/directcollection/nillable/DirectCollectionNodeNullPolicyProject.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -25,7 +25,6 @@
 
     /**
      * Construct a project with a descriptor setup for all fields that do not use a default NodeNullPolicy
-     * @param aMapping
      * @param fieldsAsElements
      */
     public DirectCollectionNodeNullPolicyProject(boolean fieldsAsElements) {
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/mappings/directtofield/defaultnullvalue/xmlelement/EmptyElementTestCases.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/mappings/directtofield/defaultnullvalue/xmlelement/EmptyElementTestCases.java
index fac72f7..4ec003a 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/mappings/directtofield/defaultnullvalue/xmlelement/EmptyElementTestCases.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/mappings/directtofield/defaultnullvalue/xmlelement/EmptyElementTestCases.java
@@ -31,7 +31,7 @@
     private final static String XML_RESOURCE = "org/eclipse/persistence/testing/oxm/mappings/directtofield/defaultnullvalue/xmlelement/EmptyElement.xml";
     private final static String XML_WRITE_RESOURCE = "org/eclipse/persistence/testing/oxm/mappings/directtofield/defaultnullvalue/xmlelement/EmptyElementWrite.xml";
 
-    /**
+    /*
      * Empty Element single tag With nullValue=EMPTY_STRING "<employee/>", "<employee/>",
      * true, false); // Expected result "<employee><first-name/></employee>", true, false); // Input document
      */
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/mappings/directtofield/nillable/DirectIsSetNodeNullPolicyProject.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/mappings/directtofield/nillable/DirectIsSetNodeNullPolicyProject.java
index 9765621..993385f 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/mappings/directtofield/nillable/DirectIsSetNodeNullPolicyProject.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/mappings/directtofield/nillable/DirectIsSetNodeNullPolicyProject.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -22,7 +22,6 @@
 
     /**
      * Construct a project with a descriptor setup for all fields that do not use a default NullPolicy
-     * @param aMapping
      * @param fieldsAsElements
      */
     public DirectIsSetNodeNullPolicyProject(boolean fieldsAsElements) {
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/mappings/directtofield/nillable/DirectNodeNullPolicyProject.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/mappings/directtofield/nillable/DirectNodeNullPolicyProject.java
index 9bb1e0a..f0bb100 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/mappings/directtofield/nillable/DirectNodeNullPolicyProject.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/mappings/directtofield/nillable/DirectNodeNullPolicyProject.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -22,7 +22,6 @@
 
     /**
      * Construct a project with a descriptor setup for all fields that do not use a default NodeNullPolicy
-     * @param aMapping
      * @param fieldsAsElements
      */
     public DirectNodeNullPolicyProject(boolean fieldsAsElements) {
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/schemamodelgenerator/GenerateSchemaTestCases.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/schemamodelgenerator/GenerateSchemaTestCases.java
index 29a00f3..fa51ef3 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/schemamodelgenerator/GenerateSchemaTestCases.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/schemamodelgenerator/GenerateSchemaTestCases.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -133,7 +133,7 @@
      * of an XML schema.
      *
      * @param generatedSchema
-     * @param controlSchemaName
+     * @param controlSchema
      */
     protected boolean compareSchemaStrings(Schema generatedSchema, String controlSchema){
         Project p = new SchemaModelProject();
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/xmlroot/complex/inheritance/NonNullDefaultRootMatchingPersonXMLRootTestCases.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/xmlroot/complex/inheritance/NonNullDefaultRootMatchingPersonXMLRootTestCases.java
index 8b0a615..d5c3f8f 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/xmlroot/complex/inheritance/NonNullDefaultRootMatchingPersonXMLRootTestCases.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/xmlroot/complex/inheritance/NonNullDefaultRootMatchingPersonXMLRootTestCases.java
@@ -28,7 +28,7 @@
 
 public class NonNullDefaultRootMatchingPersonXMLRootTestCases extends XMLMappingTestCases {
     private final static String XML_RESOURCE = "org/eclipse/persistence/testing/oxm/xmlroot/complex/inheritance/personNonNullRootMatchingXMLRoot.xml";
-    /**
+    /*
       <?xml version="1.0" encoding="UTF-8"?>
       <oxm:pRoot xsi:type="oxm:person" xmlns:oxm="test" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
         <name>Joe Smith</name>
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/xmlroot/complex/inheritance/NonNullDefaultRootPersonTestCases.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/xmlroot/complex/inheritance/NonNullDefaultRootPersonTestCases.java
index e23eb89..6990203 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/xmlroot/complex/inheritance/NonNullDefaultRootPersonTestCases.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/xmlroot/complex/inheritance/NonNullDefaultRootPersonTestCases.java
@@ -28,7 +28,7 @@
 
 public class NonNullDefaultRootPersonTestCases extends XMLMappingTestCases {
     private final static String XML_RESOURCE = "org/eclipse/persistence/testing/oxm/xmlroot/complex/inheritance/personNonNullRoot.xml";
-    /**
+    /*
       <?xml version="1.0" encoding="UTF-8"?>
       <oxm:pRoot xsi:type="oxm:person" xmlns:oxm="test" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
         <name>Joe Smith</name>
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/xmlroot/complex/inheritance/NonNullDefaultRootPersonXMLRootTestCases.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/xmlroot/complex/inheritance/NonNullDefaultRootPersonXMLRootTestCases.java
index bdc8d3f..69de77a 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/xmlroot/complex/inheritance/NonNullDefaultRootPersonXMLRootTestCases.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/xmlroot/complex/inheritance/NonNullDefaultRootPersonXMLRootTestCases.java
@@ -28,7 +28,7 @@
 
 public class NonNullDefaultRootPersonXMLRootTestCases extends XMLMappingTestCases {
     private final static String XML_RESOURCE = "org/eclipse/persistence/testing/oxm/xmlroot/complex/inheritance/personNonNullRootXMLRoot.xml";
-    /**
+    /*
       <?xml version="1.0" encoding="UTF-8"?>
       <oxm:blah xsi:type="oxm:person" xmlns:oxm="test" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
         <name>Joe Smith</name>
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/xmlroot/complex/inheritance/NullDefaultRootXMLRootTestCases.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/xmlroot/complex/inheritance/NullDefaultRootXMLRootTestCases.java
index d017678..3cb7376 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/xmlroot/complex/inheritance/NullDefaultRootXMLRootTestCases.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/xmlroot/complex/inheritance/NullDefaultRootXMLRootTestCases.java
@@ -22,7 +22,7 @@
 public class NullDefaultRootXMLRootTestCases extends XMLMappingTestCases {
     private final static String XML_RESOURCE = "org/eclipse/persistence/testing/oxm/xmlroot/complex/inheritance/employeeNullRoot.xml";
 
-    /**
+    /*
       <?xml version="1.0" encoding="UTF-8"?>
       <oxm:blah xsi:type="oxm:emp" xmlns:oxm="test" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
         <name>Joe Smith</name>
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/xpathengine/XPathEngineFindTestCases.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/xpathengine/XPathEngineFindTestCases.java
index f194828..40766fe 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/xpathengine/XPathEngineFindTestCases.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/xpathengine/XPathEngineFindTestCases.java
@@ -55,7 +55,7 @@
 
     /**
      * Execute the 'self' xpath on the control document - should return the
-     * root element <addressbook>, a.k.a. serachNode
+     * root element {@code <addressbook>}, a.k.a. searchNode
      */
     public void testFindSelf() throws Exception {
         XMLField field = new XMLField(".");
@@ -68,7 +68,7 @@
 
     /**
      * Execute the 'self' xpath on the control document - should return a
-     * collection containing the root element <addressbook>, a.k.a. serachNode
+     * collection containing the root element {@code <addressbook>}, a.k.a. searchNode
      */
     public void testFindSelfCollection() throws Exception {
         XMLField field = new XMLField(".");
diff --git a/pom.xml b/pom.xml
index 77b7b1f..c3d3841 100644
--- a/pom.xml
+++ b/pom.xml
@@ -101,7 +101,7 @@
         <!-- exclude big groups from the Xlint -->
         <comp.xlint>-Xlint:all,-rawtypes,-unchecked,-serial</comp.xlint>
         <!-- -Xdoclint:-missing does not seem to work properly on the infra -->
-        <comp.xdoclint>-Xdoclint:none</comp.xdoclint>
+        <comp.xdoclint>-Xdoclint:all,-missing</comp.xdoclint>
         <warn.limit>150</warn.limit>
 
         <spotbugs.common>${project.build.directory}/spotbugs-exclude-common.xml</spotbugs.common>
diff --git a/sdo/org.eclipse.persistence.sdo/pom.xml b/sdo/org.eclipse.persistence.sdo/pom.xml
index ccd7f02..aabcade 100644
--- a/sdo/org.eclipse.persistence.sdo/pom.xml
+++ b/sdo/org.eclipse.persistence.sdo/pom.xml
@@ -35,6 +35,7 @@
         <jdoc.doclint>-missing</jdoc.doclint>
         <!-- XXX deprecated comes from commonj.sdo which we don't want to touch -->
         <comp.xlint>-Xlint:all,-rawtypes,-unchecked,-serial,-deprecation,-dep-ann</comp.xlint>
+        <comp.xdoclint>-Xdoclint:none</comp.xdoclint>
 
         <test-skip-sdo-srg>${skipTests}</test-skip-sdo-srg>
         <test-skip-sdo>true</test-skip-sdo>
diff --git a/sdo/org.eclipse.persistence.sdo/src/main/java/org/eclipse/persistence/sdo/SDOChangeSummary.java b/sdo/org.eclipse.persistence.sdo/src/main/java/org/eclipse/persistence/sdo/SDOChangeSummary.java
index cad0f19..b697dc9 100644
--- a/sdo/org.eclipse.persistence.sdo/src/main/java/org/eclipse/persistence/sdo/SDOChangeSummary.java
+++ b/sdo/org.eclipse.persistence.sdo/src/main/java/org/eclipse/persistence/sdo/SDOChangeSummary.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -72,10 +72,10 @@
     private Map oldContainer;// Key is DataObject, value is DataObject
     private Map oldContainmentProperty;// Key is DataObject, value is Property
 
-    /** Cache map of originalSequences Map<DataObject, Sequence> */
+    /** Cache map of originalSequences {@code Map<DataObject, Sequence>} */
     private Map oldSequences;// Key is DataObject, value is Sequence
 
-    /** Map of originalSequence Map<DataObject, Sequence> */
+    /** Map of originalSequence {@code Map<DataObject, Sequence>} */
     private Map originalSequences;// Key is DataObject, value is Sequence
     private Map unsetOCPropsMap;
 
diff --git a/sdo/org.eclipse.persistence.sdo/src/main/java/org/eclipse/persistence/sdo/SDOSequence.java b/sdo/org.eclipse.persistence.sdo/src/main/java/org/eclipse/persistence/sdo/SDOSequence.java
index fecf34b..4c83097 100644
--- a/sdo/org.eclipse.persistence.sdo/src/main/java/org/eclipse/persistence/sdo/SDOSequence.java
+++ b/sdo/org.eclipse.persistence.sdo/src/main/java/org/eclipse/persistence/sdo/SDOSequence.java
@@ -635,7 +635,6 @@
      * return 2. Although B is at index 4 of the Settings list, it is at index 2
      * of the list of "letters" - [A, C, B, D].
      *
-     * @param property
      * @return index of the value's Setting in the list relative to a given
      *         property or -1 if not found.
      */
diff --git a/sdo/org.eclipse.persistence.sdo/src/main/java/org/eclipse/persistence/sdo/helper/SDOClassGenerator.java b/sdo/org.eclipse.persistence.sdo/src/main/java/org/eclipse/persistence/sdo/helper/SDOClassGenerator.java
index 54941d7..466311d 100644
--- a/sdo/org.eclipse.persistence.sdo/src/main/java/org/eclipse/persistence/sdo/helper/SDOClassGenerator.java
+++ b/sdo/org.eclipse.persistence.sdo/src/main/java/org/eclipse/persistence/sdo/helper/SDOClassGenerator.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -464,12 +464,6 @@
 
     /**
      * INTERNAL:
-     * @param uri
-     * @param ownerName
-     * @param name
-     * @param javaType (always represents the processed javaClass name)
-     * @param many
-     * @param annotation
      */
     private void buildGetterAndSetter(ClassBuffer classBuffer, SDOProperty property) {
         pushIndent();
@@ -485,10 +479,6 @@
     /**
      * INTERNAL:
      * @param classBuffer
-     * @param name
-     * @param javaType (always represents the processed javaClass name)
-     * @param annotation
-     * @param className
      */
     private void buildGetMethodBuffer(ClassBuffer classBuffer, SDOProperty property, java.util.List documentation) {
         String returnType = SDOUtil.getJavaTypeForProperty(property);
@@ -539,10 +529,6 @@
     /**
      * INTERNAL:
      * @param classBuffer
-     * @param name
-     * @param javaType (always represents the processed javaClass name)
-     * @param annotation
-     * @param className
      */
     private void buildSetMethodBuffer(ClassBuffer classBuffer, SDOProperty property, java.util.List documentation) {
         if (property.getType().isChangeSummaryType()) {
diff --git a/sdo/org.eclipse.persistence.sdo/src/main/java/org/eclipse/persistence/sdo/helper/SDOCopyHelper.java b/sdo/org.eclipse.persistence.sdo/src/main/java/org/eclipse/persistence/sdo/helper/SDOCopyHelper.java
index a18fd68..b671745 100644
--- a/sdo/org.eclipse.persistence.sdo/src/main/java/org/eclipse/persistence/sdo/helper/SDOCopyHelper.java
+++ b/sdo/org.eclipse.persistence.sdo/src/main/java/org/eclipse/persistence/sdo/helper/SDOCopyHelper.java
@@ -502,7 +502,7 @@
      *
      * @param anOriginalCS
      * @param aCopyCS
-     * @param doMap (map of original do's (CS1) to their copy do's in (CS2))
+     * @param origDOCS1toCopyDOCS2Map (map of original do's (CS1) to their copy do's in (CS2))
      */
     private void copyChangeSummary(ChangeSummary anOriginalCS, ChangeSummary aCopyCS,//
                                    Map origDOCS1toCopyDOCS2Map) {
@@ -824,7 +824,7 @@
      * Recurse the tree in preorder traversal (root, child1-n)
      * Scope: We do not have to check the copyTree scope when iterating opposites since
      * we will not enter any opposite property dataTree that is outside of the copyTree scope
-     * @param doMap (cache original -> copy DataObject instances to set non-containment properties after tree construction)
+     * @param doMap (cache original -{@literal >} copy DataObject instances to set non-containment properties after tree construction)
      * @param ncPropMap (cache original DO:non-containment property values to be set after tree construction)
      */
     private SDODataObject copyPrivate(SDODataObject dataObject, HashMap doMap,//
@@ -909,8 +909,8 @@
      * @param copy
      * @param property
      * @param value
-     * @param doMap (cache original -> copy DataObject instances to set non-containment properties after tree construction)
-     * @param propMap (cache original DO:non-containment property values to be set after tree construction)
+     * @param doMap (cache original -{@literal >} copy DataObject instances to set non-containment properties after tree construction)
+     * @param ncPropMap (cache original DO:non-containment property values to be set after tree construction)
      */
     private void copyContainmentPropertyValue(SDODataObject copy, SDOProperty property, Object value,//
                                               HashMap doMap, HashMap ncPropMap, SDOChangeSummary cs) {
diff --git a/sdo/org.eclipse.persistence.sdo/src/main/java/org/eclipse/persistence/sdo/helper/SDOMarshalListener.java b/sdo/org.eclipse.persistence.sdo/src/main/java/org/eclipse/persistence/sdo/helper/SDOMarshalListener.java
index c241427..b90f019 100644
--- a/sdo/org.eclipse.persistence.sdo/src/main/java/org/eclipse/persistence/sdo/helper/SDOMarshalListener.java
+++ b/sdo/org.eclipse.persistence.sdo/src/main/java/org/eclipse/persistence/sdo/helper/SDOMarshalListener.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -445,7 +445,7 @@
     * Performance: This function is O(log n) where n=# of children in the tree
     *
     * @param currentPath
-    * @param targetObject
+    * @param targetDO
     * @param currentObject
     * @param aSeparator (XPath separator is written only between elements - not for the first call)
     * @return String (representing the XPath)
diff --git a/sdo/org.eclipse.persistence.sdo/src/main/java/org/eclipse/persistence/sdo/helper/SDOTypesGenerator.java b/sdo/org.eclipse.persistence.sdo/src/main/java/org/eclipse/persistence/sdo/helper/SDOTypesGenerator.java
index 92d5780..a249baa 100644
--- a/sdo/org.eclipse.persistence.sdo/src/main/java/org/eclipse/persistence/sdo/helper/SDOTypesGenerator.java
+++ b/sdo/org.eclipse.persistence.sdo/src/main/java/org/eclipse/persistence/sdo/helper/SDOTypesGenerator.java
@@ -285,7 +285,7 @@
     /**
      * INTERNAL:
      * This function is referenced by processImport or processInclude possibly recursively
-     * @param Include theImportOrInclude
+     * @param theImportOrInclude theImportOrInclude
      * @throws Exception
      */
     private void processImportIncludeInternal(Include theImportOrInclude) throws Exception {
diff --git a/sdo/org.eclipse.persistence.sdo/src/main/java/org/eclipse/persistence/sdo/helper/delegates/SDOTypeHelperDelegate.java b/sdo/org.eclipse.persistence.sdo/src/main/java/org/eclipse/persistence/sdo/helper/delegates/SDOTypeHelperDelegate.java
index 4f01f53..d372725 100644
--- a/sdo/org.eclipse.persistence.sdo/src/main/java/org/eclipse/persistence/sdo/helper/delegates/SDOTypeHelperDelegate.java
+++ b/sdo/org.eclipse.persistence.sdo/src/main/java/org/eclipse/persistence/sdo/helper/delegates/SDOTypeHelperDelegate.java
@@ -67,10 +67,10 @@
     /** Map containing wrapper types */
     private Map<QName, SDOType> wrappersHashMap;
 
-    /** Map of interfaces -> SDOType */
+    /** Map of interfaces -{@literal >} SDOType */
     private Map<Class, SDOType> interfacesToSDOTypeHashMap;
 
-    /** Map of impl classes -> SDOType */
+    /** Map of impl classes -{@literal >} SDOType */
     private Map<Class, SDOType> implClassesToSDOType = new HashMap<Class, SDOType>();
 
     /** Map containing built-in types for primitive and SDO types */
@@ -1222,7 +1222,7 @@
 
     /**
      * INTERNAL:
-     * @param propertyQName
+     * @param propertyUri
      * @param property
      */
     private void defineOpenContentProperty(String propertyUri, String propertyName, Property property) {
diff --git a/sdo/org.eclipse.persistence.sdo/src/main/java/org/eclipse/persistence/sdo/helper/delegates/SDOXMLHelperDelegate.java b/sdo/org.eclipse.persistence.sdo/src/main/java/org/eclipse/persistence/sdo/helper/delegates/SDOXMLHelperDelegate.java
index 7ae3908..72fda04 100644
--- a/sdo/org.eclipse.persistence.sdo/src/main/java/org/eclipse/persistence/sdo/helper/delegates/SDOXMLHelperDelegate.java
+++ b/sdo/org.eclipse.persistence.sdo/src/main/java/org/eclipse/persistence/sdo/helper/delegates/SDOXMLHelperDelegate.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -586,11 +586,10 @@
          *   save(createDocument(dataObject, rootElementURI, rootElementName),
          *     writer, null);
          *
-         * @param dataObject specifies DataObject to be saved
+         * @param rootObject specifies DataObject to be saved
          * @param rootElementURI the Target Namespace URI of the root XML element
          * @param rootElementName the Name of the root XML element
          * @param writer specifies the Writer to write to.
-         * @throws IOException for stream exceptions.
          * @throws IllegalArgumentException if the dataObject tree
          *    is not closed or has no container.
          */
diff --git a/sdo/org.eclipse.persistence.sdo/src/main/java/org/eclipse/persistence/sdo/helper/extension/OPStack.java b/sdo/org.eclipse.persistence.sdo/src/main/java/org/eclipse/persistence/sdo/helper/extension/OPStack.java
index 198beda..4798649 100644
--- a/sdo/org.eclipse.persistence.sdo/src/main/java/org/eclipse/persistence/sdo/helper/extension/OPStack.java
+++ b/sdo/org.eclipse.persistence.sdo/src/main/java/org/eclipse/persistence/sdo/helper/extension/OPStack.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -89,7 +89,7 @@
      * List that will be returned), then push the new token onto the
      * stack.
      *
-     * @param out
+     * @param outList
      * @param t
      */
     private void pushSpew(List outList, Token t) {
diff --git a/sdo/org.eclipse.persistence.sdo/src/test/java/org/eclipse/persistence/testing/sdo/helper/classgen/dynamicimpl/ChangeSummaryTestCases.java b/sdo/org.eclipse.persistence.sdo/src/test/java/org/eclipse/persistence/testing/sdo/helper/classgen/dynamicimpl/ChangeSummaryTestCases.java
index 083b638..351963a 100644
--- a/sdo/org.eclipse.persistence.sdo/src/test/java/org/eclipse/persistence/testing/sdo/helper/classgen/dynamicimpl/ChangeSummaryTestCases.java
+++ b/sdo/org.eclipse.persistence.sdo/src/test/java/org/eclipse/persistence/testing/sdo/helper/classgen/dynamicimpl/ChangeSummaryTestCases.java
@@ -32,7 +32,7 @@
     @Override
     public void setUp() {
         super.setUp();
-        InputStream xsdInputStream = Thread.currentThread().getContextClassLoader().getSystemResourceAsStream(XSD);
+        InputStream xsdInputStream = ClassLoader.getSystemResourceAsStream(XSD);
         this.aHelperContext.getXSDHelper().define(xsdInputStream, null);
     }
 
diff --git a/sdo/org.eclipse.persistence.sdo/src/test/java/org/eclipse/persistence/testing/sdo/helper/classgen/dynamicimpl/DataTypeManyTestCases.java b/sdo/org.eclipse.persistence.sdo/src/test/java/org/eclipse/persistence/testing/sdo/helper/classgen/dynamicimpl/DataTypeManyTestCases.java
index a355007..685eeae 100644
--- a/sdo/org.eclipse.persistence.sdo/src/test/java/org/eclipse/persistence/testing/sdo/helper/classgen/dynamicimpl/DataTypeManyTestCases.java
+++ b/sdo/org.eclipse.persistence.sdo/src/test/java/org/eclipse/persistence/testing/sdo/helper/classgen/dynamicimpl/DataTypeManyTestCases.java
@@ -35,7 +35,7 @@
     @Override
     public void setUp() {
         super.setUp();
-        InputStream xsdInputStream = Thread.currentThread().getContextClassLoader().getSystemResourceAsStream(XSD);
+        InputStream xsdInputStream = ClassLoader.getSystemResourceAsStream(XSD);
         this.aHelperContext.getXSDHelper().define(xsdInputStream, null);
     }
 
diff --git a/sdo/org.eclipse.persistence.sdo/src/test/java/org/eclipse/persistence/testing/sdo/helper/classgen/dynamicimpl/DataTypesTestCases.java b/sdo/org.eclipse.persistence.sdo/src/test/java/org/eclipse/persistence/testing/sdo/helper/classgen/dynamicimpl/DataTypesTestCases.java
index d7386a5..c9c3bfb 100644
--- a/sdo/org.eclipse.persistence.sdo/src/test/java/org/eclipse/persistence/testing/sdo/helper/classgen/dynamicimpl/DataTypesTestCases.java
+++ b/sdo/org.eclipse.persistence.sdo/src/test/java/org/eclipse/persistence/testing/sdo/helper/classgen/dynamicimpl/DataTypesTestCases.java
@@ -52,7 +52,7 @@
     @Override
     public void setUp() {
         super.setUp();
-        InputStream xsdInputStream = Thread.currentThread().getContextClassLoader().getSystemResourceAsStream(XSD);
+        InputStream xsdInputStream = ClassLoader.getSystemResourceAsStream(XSD);
         this.aHelperContext.getXSDHelper().define(xsdInputStream, null);
     }
 
diff --git a/sdo/org.eclipse.persistence.sdo/src/test/java/org/eclipse/persistence/testing/sdo/helper/classgen/dynamicimpl/InheritanceTestCases.java b/sdo/org.eclipse.persistence.sdo/src/test/java/org/eclipse/persistence/testing/sdo/helper/classgen/dynamicimpl/InheritanceTestCases.java
index 28c8a17..f80bde3 100644
--- a/sdo/org.eclipse.persistence.sdo/src/test/java/org/eclipse/persistence/testing/sdo/helper/classgen/dynamicimpl/InheritanceTestCases.java
+++ b/sdo/org.eclipse.persistence.sdo/src/test/java/org/eclipse/persistence/testing/sdo/helper/classgen/dynamicimpl/InheritanceTestCases.java
@@ -33,7 +33,7 @@
     @Override
     public void setUp() {
         super.setUp();
-        InputStream xsdInputStream = Thread.currentThread().getContextClassLoader().getSystemResourceAsStream(XSD);
+        InputStream xsdInputStream = ClassLoader.getSystemResourceAsStream(XSD);
         this.aHelperContext.getXSDHelper().define(xsdInputStream, null);
     }
 
diff --git a/sdo/org.eclipse.persistence.sdo/src/test/java/org/eclipse/persistence/testing/sdo/helper/classgen/dynamicimpl/NonDataTypeManyTestCases.java b/sdo/org.eclipse.persistence.sdo/src/test/java/org/eclipse/persistence/testing/sdo/helper/classgen/dynamicimpl/NonDataTypeManyTestCases.java
index d9c1423..55a16b6 100644
--- a/sdo/org.eclipse.persistence.sdo/src/test/java/org/eclipse/persistence/testing/sdo/helper/classgen/dynamicimpl/NonDataTypeManyTestCases.java
+++ b/sdo/org.eclipse.persistence.sdo/src/test/java/org/eclipse/persistence/testing/sdo/helper/classgen/dynamicimpl/NonDataTypeManyTestCases.java
@@ -33,7 +33,7 @@
     @Override
     public void setUp() {
         super.setUp();
-        InputStream xsdInputStream = Thread.currentThread().getContextClassLoader().getSystemResourceAsStream(XSD);
+        InputStream xsdInputStream = ClassLoader.getSystemResourceAsStream(XSD);
         this.aHelperContext.getXSDHelper().define(xsdInputStream, null);
     }
 
diff --git a/sdo/org.eclipse.persistence.sdo/src/test/java/org/eclipse/persistence/testing/sdo/helper/classgen/dynamicimpl/NonDataTypeTestCases.java b/sdo/org.eclipse.persistence.sdo/src/test/java/org/eclipse/persistence/testing/sdo/helper/classgen/dynamicimpl/NonDataTypeTestCases.java
index 55d2dbe..95c0400 100644
--- a/sdo/org.eclipse.persistence.sdo/src/test/java/org/eclipse/persistence/testing/sdo/helper/classgen/dynamicimpl/NonDataTypeTestCases.java
+++ b/sdo/org.eclipse.persistence.sdo/src/test/java/org/eclipse/persistence/testing/sdo/helper/classgen/dynamicimpl/NonDataTypeTestCases.java
@@ -33,7 +33,7 @@
     @Override
     public void setUp() {
         super.setUp();
-        InputStream xsdInputStream = Thread.currentThread().getContextClassLoader().getSystemResourceAsStream(XSD);
+        InputStream xsdInputStream = ClassLoader.getSystemResourceAsStream(XSD);
         this.aHelperContext.getXSDHelper().define(xsdInputStream, null);
     }
 
diff --git a/sdo/org.eclipse.persistence.sdo/src/test/java/org/eclipse/persistence/testing/sdo/helper/classgen/dynamicimpl/OneElementTestCases.java b/sdo/org.eclipse.persistence.sdo/src/test/java/org/eclipse/persistence/testing/sdo/helper/classgen/dynamicimpl/OneElementTestCases.java
index ed6d62b..e66a3ee 100644
--- a/sdo/org.eclipse.persistence.sdo/src/test/java/org/eclipse/persistence/testing/sdo/helper/classgen/dynamicimpl/OneElementTestCases.java
+++ b/sdo/org.eclipse.persistence.sdo/src/test/java/org/eclipse/persistence/testing/sdo/helper/classgen/dynamicimpl/OneElementTestCases.java
@@ -33,7 +33,7 @@
     @Override
     public void setUp() {
         super.setUp();
-        InputStream xsdInputStream = Thread.currentThread().getContextClassLoader().getSystemResourceAsStream(XSD);
+        InputStream xsdInputStream = ClassLoader.getSystemResourceAsStream(XSD);
         this.aHelperContext.getXSDHelper().define(xsdInputStream, null);
     }
 
diff --git a/sdo/org.eclipse.persistence.sdo/src/test/java/org/eclipse/persistence/testing/sdo/helper/xsdhelper/define/RedefineTestCases.java b/sdo/org.eclipse.persistence.sdo/src/test/java/org/eclipse/persistence/testing/sdo/helper/xsdhelper/define/RedefineTestCases.java
index 4d34204..e3aa630 100644
--- a/sdo/org.eclipse.persistence.sdo/src/test/java/org/eclipse/persistence/testing/sdo/helper/xsdhelper/define/RedefineTestCases.java
+++ b/sdo/org.eclipse.persistence.sdo/src/test/java/org/eclipse/persistence/testing/sdo/helper/xsdhelper/define/RedefineTestCases.java
@@ -60,7 +60,7 @@
     }
 
     private InputStream getSchema(String resource) {
-        return Thread.currentThread().getContextClassLoader().getSystemResourceAsStream(resource);
+        return ClassLoader.getSystemResourceAsStream(resource);
     }
 
 }
diff --git a/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/optionalarguments/OptionalArgumentTestSuite.java b/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/optionalarguments/OptionalArgumentTestSuite.java
index 754e204..0e8278e 100644
--- a/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/optionalarguments/OptionalArgumentTestSuite.java
+++ b/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/optionalarguments/OptionalArgumentTestSuite.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2011, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2011, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -260,7 +260,7 @@
 
     /**
      * Tests handing in no optional args.
-     * Expects -1 for 'X' & 'Z'.
+     * Expects -1 for 'X' &amp; 'Z'.
      */
     @Test
     public void optionalArgTest3() {
diff --git a/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/rowtype/RowTypeTestSuite.java b/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/rowtype/RowTypeTestSuite.java
index 7bd47b8..e46c07e 100644
--- a/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/rowtype/RowTypeTestSuite.java
+++ b/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/rowtype/RowTypeTestSuite.java
@@ -40,7 +40,7 @@
 
 /**
  * Tests %ROWTYPE support. If, in a PL/SQL package, you want a record
- * with fields (names & types, but not constraints) that mirror a
+ * with fields (names &amp; types, but not constraints) that mirror a
  * JDBC table, without defining the record in the package, %ROWTYPE
  * can be used, i.e. "PARAM1 OUT MYTABLE%ROWTYPE".
  *
diff --git a/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/shadowddlgeneration/oldjpub/DMLMethod.java b/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/shadowddlgeneration/oldjpub/DMLMethod.java
index c6de66f..093992c 100644
--- a/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/shadowddlgeneration/oldjpub/DMLMethod.java
+++ b/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/shadowddlgeneration/oldjpub/DMLMethod.java
@@ -23,8 +23,8 @@
 
     /**
      * Construct a Method that is a DML (which returns an int)
-     * <p/>
-     * m_isBatched <= isBatched
+     * <br>
+     * m_isBatched {@literal<}= isBatched
      */
     public DMLMethod(String name, int modifiers, String sqlStmt, boolean isBatched,
         SqlReflector reflector) throws SQLException,
diff --git a/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/shadowddlgeneration/oldjpub/JavaName.java b/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/shadowddlgeneration/oldjpub/JavaName.java
index ab9a641..642b3d9 100644
--- a/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/shadowddlgeneration/oldjpub/JavaName.java
+++ b/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/shadowddlgeneration/oldjpub/JavaName.java
@@ -34,7 +34,7 @@
      * case), the decl name will be the same as the use name. The decl name is the name of the class
      * that JPub generates. It is different from the use name, the name of the class that represents
      * the SQL type, if the class is user-written. The user tells JPub that this is the case by
-     * putting the clause "GENERATE <decl class name> AS <use class name> in the input file.
+     * putting the clause "{@code GENERATE <decl class name> AS <use class name>}" in the input file.
      *
      * * @param package the package in which the class is declared
      *
diff --git a/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/shadowddlgeneration/oldjpub/PlsqlTableType.java b/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/shadowddlgeneration/oldjpub/PlsqlTableType.java
index b7f0828..491fcd1 100644
--- a/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/shadowddlgeneration/oldjpub/PlsqlTableType.java
+++ b/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/shadowddlgeneration/oldjpub/PlsqlTableType.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -172,7 +172,6 @@
      * @param generateMe
      * @param parentType
      * @param isGrandparent
-     * @param options
      * @param reflector
      * @return either a newly defined PL/SQL Table type or a predefined scalar PL/SQL index-by table
      *         type
diff --git a/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/shadowddlgeneration/oldjpub/SerializableType.java b/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/shadowddlgeneration/oldjpub/SerializableType.java
index 4d50e2e..301cb75 100644
--- a/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/shadowddlgeneration/oldjpub/SerializableType.java
+++ b/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/shadowddlgeneration/oldjpub/SerializableType.java
@@ -15,7 +15,7 @@
 package dbws.testing.shadowddlgeneration.oldjpub;
 
 /**
- * Instances of the class </code>SerializableType</code> represent Java serializable types.
+ * Instances of the class <code>SerializableType</code> represent Java serializable types.
  */
 public class SerializableType extends SqlType {
     /**
diff --git a/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/shadowddlgeneration/oldjpub/SqlArrayType.java b/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/shadowddlgeneration/oldjpub/SqlArrayType.java
index 379f4fb..b9baebc 100644
--- a/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/shadowddlgeneration/oldjpub/SqlArrayType.java
+++ b/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/shadowddlgeneration/oldjpub/SqlArrayType.java
@@ -25,7 +25,6 @@
 
     /**
      * Determines if this Type represents an Array type.
-     * <p/>
      */
     @Override
     public boolean isArray() {
diff --git a/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/shadowddlgeneration/oldjpub/SqlName.java b/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/shadowddlgeneration/oldjpub/SqlName.java
index 8ebcfae..f44b0a6 100644
--- a/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/shadowddlgeneration/oldjpub/SqlName.java
+++ b/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/shadowddlgeneration/oldjpub/SqlName.java
@@ -181,7 +181,7 @@
 
     /**
      * Determine the SQL type name for a PL/SQL type. Generate a name in the form of
-     * <prefix>_<name>. The <prefix> term is determined as follows in precedency - java user
+     * {@code <prefix>_<name>}. The {@code <prefix>} term is determined as follows in precedency - java user
      * interface name of the associated PL/SQL package - java base interface name of the associated
      * PL/SQL package - the associated PL/SQL package name Generated names are subject to length and
      * conflict check. If length excceeds PL/SQL identifier limit, the name will be chopped. If
@@ -398,7 +398,7 @@
      * the class that JPub generates. It is different from the use class name, the name of the class
      * name generated when the class is used, rather than declared, if the use class is
      * user-written. The user tells JPub that this is the case by putting the clause
-     * "GENERATE <decl name> AS <use name>" in the input file.
+     * "{@code GENERATE <decl name> AS <use name>}" in the input file.
      *
      * * @return the decl class name of a type.
      */
@@ -411,8 +411,8 @@
      * Returns the declaration package name of an SqlName. The declaration package name is the name
      * of the package that JPub generates. It is different from the use package name, the name of
      * the package name generated when the package is used, rather than declared, if the use package
-     * is user-written. The user tells JPub that this is the case by putting the clause "GENERATE
-     * <decl name> AS <use name> in the input file.
+     * is user-written. The user tells JPub that this is the case by putting the clause "{@code GENERATE
+     * <decl name> AS <use name>}" in the input file.
      *
      * * @return the decl package name of a type.
      */
@@ -753,7 +753,7 @@
 
     /**
      * Returns the PL/SQL function to be used for converting this PL/SQL into a SQL type.
-     * <p/>
+     * <br>
      * Returns null if this is not a PL/SQL type or if it does not have user-defined conversions.
      */
     public String getOutOfConversion() {
@@ -775,7 +775,7 @@
 
     /**
      * Returns the PL/SQL function to be used for converting a SQL type into this PL/SQL type.
-     * <p/>
+     * <br>
      * Returns null if this is not a PL/SQL type or if it does not have user-defined conversions.
      */
     public String getIntoConversion() {
diff --git a/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/shadowddlgeneration/oldjpub/SqlObjectType.java b/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/shadowddlgeneration/oldjpub/SqlObjectType.java
index cec57e4..9c3d8c9 100644
--- a/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/shadowddlgeneration/oldjpub/SqlObjectType.java
+++ b/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/shadowddlgeneration/oldjpub/SqlObjectType.java
@@ -67,7 +67,6 @@
 
     /**
      * Determines if this Type represents an object type.
-     * <p/>
      */
     @Override
     public boolean isObject() {
diff --git a/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/shadowddlgeneration/oldjpub/SqlOpaqueType.java b/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/shadowddlgeneration/oldjpub/SqlOpaqueType.java
index e313301..28a2196 100644
--- a/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/shadowddlgeneration/oldjpub/SqlOpaqueType.java
+++ b/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/shadowddlgeneration/oldjpub/SqlOpaqueType.java
@@ -23,7 +23,6 @@
 
     /**
      * Determines if this Type represents an Opaque type.
-     * <p/>
      */
     @Override
     public boolean isOpaque() {
diff --git a/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/shadowddlgeneration/oldjpub/SqlRefType.java b/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/shadowddlgeneration/oldjpub/SqlRefType.java
index b1a03df..ed5cd7f 100644
--- a/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/shadowddlgeneration/oldjpub/SqlRefType.java
+++ b/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/shadowddlgeneration/oldjpub/SqlRefType.java
@@ -15,7 +15,7 @@
 package dbws.testing.shadowddlgeneration.oldjpub;
 
 /**
- * Instances of the class </code>SqlRefType</code> represent SQL REF types.
+ * Instances of the class <code>SqlRefType</code> represent SQL REF types.
  */
 public class SqlRefType extends SqlType {
 
diff --git a/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/shadowddlgeneration/oldjpub/SqlTableType.java b/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/shadowddlgeneration/oldjpub/SqlTableType.java
index 069120a..960699a 100644
--- a/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/shadowddlgeneration/oldjpub/SqlTableType.java
+++ b/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/shadowddlgeneration/oldjpub/SqlTableType.java
@@ -23,7 +23,6 @@
 
     /**
      * Determines if this Type represents a table type.
-     * <p/>
      */
     @Override
     public boolean isTable() {
diff --git a/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/shadowddlgeneration/oldjpub/SqlType.java b/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/shadowddlgeneration/oldjpub/SqlType.java
index c3b50f8..7b87497 100644
--- a/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/shadowddlgeneration/oldjpub/SqlType.java
+++ b/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/shadowddlgeneration/oldjpub/SqlType.java
@@ -270,7 +270,7 @@
 
     /**
      * Returns the PL/SQL function to be used for converting this PL/SQL into a SQL type.
-     * <p/>
+     * <br>
      * Returns null if this is not a PL/SQL type or if it does not have user-defined conversions.
      */
     //static Hashtable m_convFuns = new Hashtable();
@@ -286,7 +286,7 @@
 
     /**
      * Returns the PL/SQL function to be used for converting a SQL type into this PL/SQL type.
-     * <p/>
+     * <br>
      * Returns null if this is not a PL/SQL type or if it does not have user-defined conversions.
      */
     @Override
diff --git a/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/shadowddlgeneration/oldjpub/TypeClass.java b/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/shadowddlgeneration/oldjpub/TypeClass.java
index d5ea8bc..16110a3 100644
--- a/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/shadowddlgeneration/oldjpub/TypeClass.java
+++ b/utils/eclipselink.dbws.builder.test.oracle/src/it/java/dbws/testing/shadowddlgeneration/oldjpub/TypeClass.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -23,11 +23,11 @@
 import dbws.testing.shadowddlgeneration.oldjpub.PublisherException;
 
 /**
- * Instances of the class </code>Type</code> represent user-declared or predefined types in SQL or
- * PL/SQL that may have fields and methods. Currently, subclasses of </code>Type</code> represent
+ * Instances of the class <code>Type</code> represent user-declared or predefined types in SQL or
+ * PL/SQL that may have fields and methods. Currently, subclasses of <code>Type</code> represent
  * PL/SQL packages, the top-level PL/SQL scope, Oracle 8 user-defined types (objects, varrays and
  * nested tables) and the primitive database types.
- * <p/>
+ * <br>
  * This class is analogous to java.lang.Class.
  */
 public abstract class TypeClass {
@@ -105,7 +105,7 @@
 
     /**
      * Determines if this Type represents an array type.
-     * <p/>
+     * <br>
      */
     public boolean isArray() {
         return false;
@@ -113,7 +113,7 @@
 
     /**
      * Determines if this Type represents an object type.
-     * <p/>
+     * <br>
      */
     public boolean isObject() {
         return false;
@@ -266,7 +266,7 @@
 
     /**
      * Returns the PL/SQL function to be used for converting this PL/SQL into a SQL type.
-     * <p/>
+     * <br>
      * Returns null if this is not a PL/SQL type or if it does not have user-defined conversions.
      */
     public String getOutOfConversion() {
@@ -276,7 +276,7 @@
     /**
      * Returns the PL/SQL function to be used for converting this PL/SQL into a SQL type, qualified
      * with package name.
-     * <p/>
+     * <br>
      * Returns null if this is not a PL/SQL type or if it does not have user-defined conversions.
      */
     public String getOutOfConversionQualified() {
@@ -286,7 +286,7 @@
     /**
      * Returns the PL/SQL function to be used for converting a SQL type into this PL/SQL type,
      * qualified with package name.
-     * <p/>
+     * <br>
      * Returns null if this is not a PL/SQL type or if it does not have user-defined conversions.
      */
     public String getIntoConversion() {
@@ -296,7 +296,7 @@
     /**
      * Returns the PL/SQL function to be used for converting a SQL type into this PL/SQL type,
      * qualified with package name.
-     * <p/>
+     * <br>
      * Returns null if this is not a PL/SQL type or if it does not have user-defined conversions.
      */
     public String getIntoConversionQualified() {
diff --git a/utils/eclipselink.utils.rename/pom.xml b/utils/eclipselink.utils.rename/pom.xml
index d0642a3..a2021bf 100644
--- a/utils/eclipselink.utils.rename/pom.xml
+++ b/utils/eclipselink.utils.rename/pom.xml
@@ -30,7 +30,4 @@
         <relativePath>../../pom.xml</relativePath>
     </parent>
 
-    <properties>
-        <comp.xdoclint>-Xdoclint:-missing</comp.xdoclint>
-    </properties>
 </project>
diff --git a/utils/eclipselink.utils.sigcompare/pom.xml b/utils/eclipselink.utils.sigcompare/pom.xml
index babe776..2f12c6c 100644
--- a/utils/eclipselink.utils.sigcompare/pom.xml
+++ b/utils/eclipselink.utils.sigcompare/pom.xml
@@ -30,10 +30,6 @@
         <relativePath>../../pom.xml</relativePath>
     </parent>
 
-    <properties>
-        <comp.xdoclint>-Xdoclint:-missing</comp.xdoclint>
-    </properties>
-
     <dependencies>
         <!--Other modules-->
         <dependency>
