diff --git a/tck/pom.xml b/tck/pom.xml
index 9be8e19..fc3e7bb 100644
--- a/tck/pom.xml
+++ b/tck/pom.xml
@@ -187,6 +187,23 @@
                 <artifactId>maven-javadoc-plugin</artifactId>
                 <configuration>
                     <doclint>none</doclint>
+                    <tags>
+                        <tag>
+                            <name>testName</name>
+                            <placement>m</placement>
+                            <head>Test Name:</head>
+                        </tag>
+                        <tag>
+                            <name>assertion_ids</name>
+                            <placement>m</placement>
+                            <head>Assertion IDs:</head>
+                        </tag>
+                        <tag>
+                            <name>test_Strategy</name>
+                            <placement>m</placement>
+                            <head>Test Strategy:</head>
+                        </tag>
+                    </tags>
                 </configuration>
                 <executions>
                     <execution>
diff --git a/tck/src/main/java/ee/jakarta/tck/el/api/arrayelresolver/ELClientIT.java b/tck/src/main/java/ee/jakarta/tck/el/api/arrayelresolver/ELClientIT.java
index 97cb574..bb861d4 100644
--- a/tck/src/main/java/ee/jakarta/tck/el/api/arrayelresolver/ELClientIT.java
+++ b/tck/src/main/java/ee/jakarta/tck/el/api/arrayelresolver/ELClientIT.java
@@ -60,12 +60,12 @@
   }
 
   /**
-   * @testName: arrayELResolverTest
+   * @testName  arrayELResolverTest
    *
-   * @assertion_ids: EL:JAVADOC:1; EL:JAVADOC:3; EL:JAVADOC:4; EL:JAVADOC:5;
+   * @assertion_ids  EL:JAVADOC:1; EL:JAVADOC:3; EL:JAVADOC:4; EL:JAVADOC:5;
    *                 EL:JAVADOC:6; EL:JAVADOC:7; EL:JAVADOC:8
    *
-   * @test_Strategy: Verify that API calls work as expected: arrayELResolver()
+   * @test_Strategy  Verify that API calls work as expected: arrayELResolver()
    *                 getValue() getType() setValue() isReadOnly()
    *                 getCommonPropertyType()
    */
@@ -94,13 +94,13 @@
   }
 
   /**
-   * @testName: arrayELResolverNPETest
+   * @testName  arrayELResolverNPETest
    *
-   * @assertion_ids: EL:JAVADOC:1; EL:JAVADOC:5; EL:JAVADOC:6; EL:JAVADOC:7;
+   * @assertion_ids  EL:JAVADOC:1; EL:JAVADOC:5; EL:JAVADOC:6; EL:JAVADOC:7;
    *                 EL:JAVADOC:8; EL:JAVADOC:122; EL:JAVADOC:125;
    *                 EL:JAVADOC:128; EL:JAVADOC:131
    *
-   * @test_Strategy: Verify that the following methods throw a
+   * @test_Strategy  Verify that the following methods throw a
    *                 NullPointerException, if context is null:
    *
    *                 getValue() getType() setValue() isReadOnly()
@@ -127,12 +127,12 @@
   }
 
   /**
-   * @testName: arrayELResolverPNFETest
+   * @testName  arrayELResolverPNFETest
    *
-   * @assertion_ids: EL:JAVADOC:1; EL:JAVADOC:5; EL:JAVADOC:7; EL:JAVADOC:8;
+   * @assertion_ids  EL:JAVADOC:1; EL:JAVADOC:5; EL:JAVADOC:7; EL:JAVADOC:8;
    *                 EL:JAVADOC:121; EL:JAVADOC:127; EL:JAVADOC:134
    *
-   * @test_Strategy: Verify that the following methods throw a
+   * @test_Strategy  Verify that the following methods throw a
    *                 PropertyNotFoundException, if the given index is out of
    *                 bounds for this array :
    *
@@ -163,12 +163,12 @@
   }
 
   /**
-   * @testName: arrayELResolverIAETest
+   * @testName  arrayELResolverIAETest
    *
-   * @assertion_ids: EL:JAVADOC:1; EL:JAVADOC:6; EL:JAVADOC:8; EL:JAVADOC:124;
+   * @assertion_ids  EL:JAVADOC:1; EL:JAVADOC:6; EL:JAVADOC:8; EL:JAVADOC:124;
    *                 EL:JAVADOC:132
    *
-   * @test_Strategy: Verify that the following methods throw an
+   * @test_Strategy  Verify that the following methods throw an
    *                 IllegalArgumentException, if the property could not be
    *                 coerced into an integer:
    *
@@ -198,11 +198,11 @@
   }
 
   /**
-   * @testName: arrayELResolverPNWETest
+   * @testName  arrayELResolverPNWETest
    *
-   * @assertion_ids: EL:JAVADOC:2; EL:JAVADOC:8; EL:JAVADOC:127; EL:JAVADOC:133
+   * @assertion_ids  EL:JAVADOC:2; EL:JAVADOC:8; EL:JAVADOC:127; EL:JAVADOC:133
    *
-   * @test_Strategy: Verify that the single-parameter constructor for
+   * @test_Strategy  Verify that the single-parameter constructor for
    *                 arrayELResolver can be used to construct a read-only
    *                 resolver, and that the setValue() method throws a
    *                 PropertyNotWritableException, if the resolver was
@@ -235,11 +235,11 @@
   }
 
   /*
-   * @testName: arrayELResolverOBETest
+   * @testName  arrayELResolverOBETest
    *
-   * @assertion_ids: EL:JAVADOC:1; EL:JAVADOC:6
+   * @assertion_ids  EL:JAVADOC:1; EL:JAVADOC:6
    *
-   * @test_Strategy: Verify that if the index is out of bounds, null is
+   * @test_Strategy  Verify that if the index is out of bounds, null is
    * returned.
    *
    * getValue()
@@ -274,11 +274,11 @@
   }
 
   /*
-   * @testName: arrayELResolverCCETest
+   * @testName  arrayELResolverCCETest
    *
-   * @assertion_ids: EL:JAVADOC:1; EL:JAVADOC:8; EL:JAVADOC:130
+   * @assertion_ids  EL:JAVADOC:1; EL:JAVADOC:8; EL:JAVADOC:130
    *
-   * @test_Strategy: Verify that if the class of a specified object prevents it
+   * @test_Strategy  Verify that if the class of a specified object prevents it
    * from being added to the array, a ClassCastException is thrown.
    *
    * setValue()
@@ -311,9 +311,9 @@
 
 
   /*
-   * @testName: arrayELResolverLengthTest
+   * @testName  arrayELResolverLengthTest
    *
-   * @test_Strategy: Verify that the length of an array is available as a read-only property.
+   * @test_Strategy  Verify that the length of an array is available as a read-only property.
    */
   @Test
   public void arrayELResolverLengthTest() throws Exception {
diff --git a/tck/src/main/java/ee/jakarta/tck/el/api/beanelresolver/ELClientIT.java b/tck/src/main/java/ee/jakarta/tck/el/api/beanelresolver/ELClientIT.java
index 68d3ece..3606848 100644
--- a/tck/src/main/java/ee/jakarta/tck/el/api/beanelresolver/ELClientIT.java
+++ b/tck/src/main/java/ee/jakarta/tck/el/api/beanelresolver/ELClientIT.java
@@ -60,12 +60,12 @@
   }
 
   /**
-   * @testName: beanELResolverTest
+   * @testName  beanELResolverTest
    *
-   * @assertion_ids: EL:JAVADOC:9; EL:JAVADOC:11; EL:JAVADOC:12; EL:JAVADOC:13;
+   * @assertion_ids  EL:JAVADOC:9; EL:JAVADOC:11; EL:JAVADOC:12; EL:JAVADOC:13;
    *                 EL:JAVADOC:14; EL:JAVADOC:15; EL:JAVADOC:16
    *
-   * @test_Strategy: Verify that API calls work as expected: beanELResolver()
+   * @test_Strategy  Verify that API calls work as expected: beanELResolver()
    *                 getValue() getType() setValue() isReadOnly()
    *                 getCommonPropertyType()
    */
@@ -94,12 +94,12 @@
   }
 
   /**
-   * @testName: beanELResolverDefaultMethodReadOnlyTest
+   * @testName  beanELResolverDefaultMethodReadOnlyTest
    *
-   * @assertion_ids: EL:JAVADOC:9; EL:JAVADOC:11; EL:JAVADOC:12; EL:JAVADOC:13;
+   * @assertion_ids  EL:JAVADOC:9; EL:JAVADOC:11; EL:JAVADOC:12; EL:JAVADOC:13;
    *                 EL:JAVADOC:14; EL:JAVADOC:15; EL:JAVADOC:16
    *
-   * @test_Strategy: Verify that API calls work as expected when accessing
+   * @test_Strategy  Verify that API calls work as expected when accessing
    *                 read-only properties defined via a default interface method
    */
   @Test
@@ -132,12 +132,12 @@
 
 
   /**
-   * @testName: beanELResolverDefaultMethodReadWriteTest
+   * @testName  beanELResolverDefaultMethodReadWriteTest
    *
-   * @assertion_ids: EL:JAVADOC:9; EL:JAVADOC:11; EL:JAVADOC:12; EL:JAVADOC:13;
+   * @assertion_ids  EL:JAVADOC:9; EL:JAVADOC:11; EL:JAVADOC:12; EL:JAVADOC:13;
    *                 EL:JAVADOC:14; EL:JAVADOC:15; EL:JAVADOC:16
    *
-   * @test_Strategy: Verify that API calls work as expected when accessing
+   * @test_Strategy  Verify that API calls work as expected when accessing
    *                 writable properties defined via a default interface method
    */
   @Test
@@ -169,10 +169,10 @@
   }
 
   /**
-   * @testName: beanELResolverInvokeTest
-   * @assertion_ids: EL:JAVADOC:9; EL:JAVADOC:11; EL:JAVADOC:12; EL:JAVADOC:13;
+   * @testName  beanELResolverInvokeTest
+   * @assertion_ids  EL:JAVADOC:9; EL:JAVADOC:11; EL:JAVADOC:12; EL:JAVADOC:13;
    *                 EL:JAVADOC:14; EL:JAVADOC:15; EL:JAVADOC:16; EL:JAVADOC:142
-   * @test_Strategy: Verify that API calls work as expected for
+   * @test_Strategy  Verify that API calls work as expected for
    *                 BeanELResolver.invoke().
    */
   @Test
@@ -202,10 +202,10 @@
   }// End beanELResolverInvokeTest
 
   /**
-   * @testName: beanELResolverInvokeVoidTest
-   * @assertion_ids: EL:JAVADOC:9; EL:JAVADOC:11; EL:JAVADOC:12; EL:JAVADOC:13;
+   * @testName  beanELResolverInvokeVoidTest
+   * @assertion_ids  EL:JAVADOC:9; EL:JAVADOC:11; EL:JAVADOC:12; EL:JAVADOC:13;
    *                 EL:JAVADOC:14; EL:JAVADOC:15; EL:JAVADOC:16
-   * @test_Strategy: Verify that the ELResolver.invoke() API calls work as
+   * @test_Strategy  Verify that the ELResolver.invoke() API calls work as
    *                 expected when calling a method that returns void.
    */
   @Test
@@ -248,10 +248,10 @@
   }// End beanELResolverInvokeVoidTest
 
   /**
-   * @testName: beanELResolverInvokeMNFETest
-   * @assertion_ids: EL:JAVADOC:9; EL:JAVADOC:11; EL:JAVADOC:12; EL:JAVADOC:13;
+   * @testName  beanELResolverInvokeMNFETest
+   * @assertion_ids  EL:JAVADOC:9; EL:JAVADOC:11; EL:JAVADOC:12; EL:JAVADOC:13;
    *                 EL:JAVADOC:14; EL:JAVADOC:15; EL:JAVADOC:16; EL:JAVADOC:143
-   * @test_Strategy: Verify that the invoke() method throws
+   * @test_Strategy  Verify that the invoke() method throws
    *                 MethodNotFoundException if no suitable method can be found.
    */
   @Test
@@ -283,13 +283,13 @@
   }// End beanELResolverInvokeMNFETest
 
   /**
-   * @testName: beanELResolverNPETest
+   * @testName  beanELResolverNPETest
    *
-   * @assertion_ids: EL:JAVADOC:9; EL:JAVADOC:13; EL:JAVADOC:14; EL:JAVADOC:15;
+   * @assertion_ids  EL:JAVADOC:9; EL:JAVADOC:13; EL:JAVADOC:14; EL:JAVADOC:15;
    *                 EL:JAVADOC:16; EL:JAVADOC:136; EL:JAVADOC:139;
    *                 EL:JAVADOC:145; EL:JAVADOC:148
    *
-   * @test_Strategy: Verify that the following methods throw a
+   * @test_Strategy  Verify that the following methods throw a
    *                 NullPointerException, if context is null:
    *
    *                 getType() getValue() isReadOnly() setValue()
@@ -317,13 +317,13 @@
   }
 
   /**
-   * @testName: beanELResolverPNFETest
+   * @testName  beanELResolverPNFETest
    *
-   * @assertion_ids: EL:JAVADOC:9; EL:JAVADOC:13; EL:JAVADOC:14; EL:JAVADOC:15;
+   * @assertion_ids  EL:JAVADOC:9; EL:JAVADOC:13; EL:JAVADOC:14; EL:JAVADOC:15;
    *                 EL:JAVADOC:16; EL:JAVADOC:137; EL:JAVADOC:140;
    *                 EL:JAVADOC:146; EL:JAVADOC:149
    *
-   * @test_Strategy: Verify that the following methods throw a
+   * @test_Strategy  Verify that the following methods throw a
    *                 PropertyNotFoundException, if the base is not null and the
    *                 specified property does not exist.
    *
@@ -355,11 +355,11 @@
   }
 
   /**
-   * @testName: beanELResolverPNWETest
+   * @testName  beanELResolverPNWETest
    *
-   * @assertion_ids: EL:JAVADOC:10; EL:JAVADOC:16; EL:JAVADOC:150
+   * @assertion_ids  EL:JAVADOC:10; EL:JAVADOC:16; EL:JAVADOC:150
    *
-   * @test_Strategy: Verify that the single-parameter constructor for
+   * @test_Strategy  Verify that the single-parameter constructor for
    *                 beanELResolver can be used to construct a read-only
    *                 resolver, and that the setValue() method throws a
    *                 PropertyNotWritableException, if the resolver was
@@ -391,9 +391,9 @@
   }
 
   /**
-   * @testName: beanELResolverMethodVisibilityTest
+   * @testName  beanELResolverMethodVisibilityTest
    *
-   * @test_Strategy: Verify that API calls work as expected for a property that is not visible via the implementing
+   * @test_Strategy  Verify that API calls work as expected for a property that is not visible via the implementing
    *                 class (it is in an internal, non-exported class) but is visible via an interface method:
    *                 beanELResolver() getValue() getType() setValue() isReadOnly() getCommonPropertyType()
    */
diff --git a/tck/src/main/java/ee/jakarta/tck/el/api/beannameelresolver/ELClientIT.java b/tck/src/main/java/ee/jakarta/tck/el/api/beannameelresolver/ELClientIT.java
index ab2c655..2f4de79 100644
--- a/tck/src/main/java/ee/jakarta/tck/el/api/beannameelresolver/ELClientIT.java
+++ b/tck/src/main/java/ee/jakarta/tck/el/api/beannameelresolver/ELClientIT.java
@@ -57,13 +57,13 @@
   }
 
   /**
-   * @testName: beanNameELResolverTest
+   * @testName  beanNameELResolverTest
    *
-   * @assertion_ids: EL:JAVADOC:152; EL:JAVADOC:153; EL:JAVADOC:154;
+   * @assertion_ids  EL:JAVADOC:152; EL:JAVADOC:153; EL:JAVADOC:154;
    *                 EL:JAVADOC:155; EL:JAVADOC:158; EL:JAVADOC:161;
    *                 EL:JAVADOC:164
    *
-   * @test_Strategy: Verify the following method calls work as expected:
+   * @test_Strategy  Verify the following method calls work as expected:
    *                 getValue() getType() setValue() isReadOnly()
    *                 getCommonPropertyType()
    */
@@ -98,13 +98,13 @@
   }
 
   /**
-   * @testName: beanNameELResolverInvokeMNFETest
+   * @testName  beanNameELResolverInvokeMNFETest
    *
-   * @assertion_ids: EL:JAVADOC:9; EL:JAVADOC:11; EL:JAVADOC:12; EL:JAVADOC:13;
+   * @assertion_ids  EL:JAVADOC:9; EL:JAVADOC:11; EL:JAVADOC:12; EL:JAVADOC:13;
    *                 EL:JAVADOC:14; EL:JAVADOC:15; EL:JAVADOC:16;
    *                 EL:JAVADOC:143; EL:JAVADOC:237
    *
-   * @test_Strategy: Verify that the invoke() method throws
+   * @test_Strategy  Verify that the invoke() method throws
    *                 MethodNotFoundException if no suitable method can be found.
    */
   @Test
@@ -141,14 +141,14 @@
   }// End beanELResolverInvokeMNFETest
 
   /**
-   * @testName: beanNameELResolverInvokeTest
+   * @testName  beanNameELResolverInvokeTest
    *
-   * @assertion_ids: EL:JAVADOC:9; EL:JAVADOC:11; EL:JAVADOC:12; EL:JAVADOC:13;
+   * @assertion_ids  EL:JAVADOC:9; EL:JAVADOC:11; EL:JAVADOC:12; EL:JAVADOC:13;
    *                 EL:JAVADOC:14; EL:JAVADOC:15; EL:JAVADOC:16;
    *                 EL:JAVADOC:142; EL:JAVADOC:199; EL:JAVADOC:200;
    *                 EL:JAVADOC:202; EL:JAVADOC:203; EL:JAVADOC:236
    *
-   * @test_Strategy: Verify that API calls work as expected for
+   * @test_Strategy  Verify that API calls work as expected for
    *                 BeanNameELResolver.invoke().
    */
   @Test
@@ -185,11 +185,11 @@
   }// End beanELResolverInvokeTest
 
   /**
-   * @testName: beanNameELResolverGetTypeNPETest
+   * @testName  beanNameELResolverGetTypeNPETest
    *
-   * @assertion_ids: EL:JAVADOC:156
+   * @assertion_ids  EL:JAVADOC:156
    *
-   * @test_Strategy: Validate a NullPointerException is thrown if context is
+   * @test_Strategy  Validate a NullPointerException is thrown if context is
    *                 null.
    */
   @Test
@@ -204,11 +204,11 @@
   }// End beanNameELResolverGetTypeNPETest
 
   /**
-   * @testName: beanNameELResolverGetValueNPETest
+   * @testName  beanNameELResolverGetValueNPETest
    *
-   * @assertion_ids: EL:JAVADOC:159
+   * @assertion_ids  EL:JAVADOC:159
    *
-   * @test_Strategy: Validate a NullPointerException is thrown if context is
+   * @test_Strategy  Validate a NullPointerException is thrown if context is
    *                 null.
    */
   @Test
@@ -223,11 +223,11 @@
   }// End beanNameELResolverGetValueNPETest
 
   /**
-   * @testName: beanNameELResolverIsReadOnlyNPETest
+   * @testName  beanNameELResolverIsReadOnlyNPETest
    *
-   * @assertion_ids: EL:JAVADOC:162
+   * @assertion_ids  EL:JAVADOC:162
    *
-   * @test_Strategy: Validate a NullPointerException is thrown if context is
+   * @test_Strategy  Validate a NullPointerException is thrown if context is
    *                 null.
    */
   @Test
@@ -242,11 +242,11 @@
   }// End beanNameELResolverIsReadOnlyNPETest
 
   /**
-   * @testName: beanNameELResolverSetValueNPETest
+   * @testName  beanNameELResolverSetValueNPETest
    *
-   * @assertion_ids: EL:JAVADOC:165
+   * @assertion_ids  EL:JAVADOC:165
    *
-   * @test_Strategy: Validate a NullPointerException is thrown if context is
+   * @test_Strategy  Validate a NullPointerException is thrown if context is
    *                 null.
    */
   @Test
diff --git a/tck/src/main/java/ee/jakarta/tck/el/api/compositeelresolver/ELClientIT.java b/tck/src/main/java/ee/jakarta/tck/el/api/compositeelresolver/ELClientIT.java
index 93d489f..9263b30 100644
--- a/tck/src/main/java/ee/jakarta/tck/el/api/compositeelresolver/ELClientIT.java
+++ b/tck/src/main/java/ee/jakarta/tck/el/api/compositeelresolver/ELClientIT.java
@@ -62,13 +62,13 @@
   }
 
   /**
-   * @testName: compositeELResolverTest
+   * @testName  compositeELResolverTest
    *
-   * @assertion_ids: EL:JAVADOC:24; EL:JAVADOC:25; EL:JAVADOC:26; EL:JAVADOC:27;
+   * @assertion_ids  EL:JAVADOC:24; EL:JAVADOC:25; EL:JAVADOC:26; EL:JAVADOC:27;
    *                 EL:JAVADOC:28; EL:JAVADOC:29; EL:JAVADOC:30; EL:JAVADOC:31;
    *                 EL:JAVADOC:34
    *
-   * @test_Strategy: Verify that API calls work as expected:
+   * @test_Strategy  Verify that API calls work as expected:
    *                 CompositeELResolver() add() getValue() getType() setValue()
    *                 isReadOnly() getCommonPropertyType()
    *                 ELContext.getELResolver()
@@ -99,11 +99,11 @@
   }
 
   /**
-   * @testName: compositeELResolverInvokeTest
+   * @testName  compositeELResolverInvokeTest
    *
-   * @assertion_ids: EL:JAVADOC:24; EL:JAVADOC:25; EL:JAVADOC:181
+   * @assertion_ids  EL:JAVADOC:24; EL:JAVADOC:25; EL:JAVADOC:181
    *
-   * @test_Strategy: Verify that API calls work as expected for
+   * @test_Strategy  Verify that API calls work as expected for
    *                 BeanELResolver.invoke().
    */
   @Test
@@ -141,11 +141,11 @@
   }// End beanELResolverInvokeTest
 
   /**
-   * @testName: compositeELResolverAddNPETest
+   * @testName  compositeELResolverAddNPETest
    *
-   * @assertion_ids: EL:JAVADOC:24; EL:JAVADOC:25; EL:JAVADOC:174
+   * @assertion_ids  EL:JAVADOC:24; EL:JAVADOC:25; EL:JAVADOC:174
    *
-   * @test_Strategy: Verify that the CompositeELResolver.add method throws a
+   * @test_Strategy  Verify that the CompositeELResolver.add method throws a
    *                 NullPointerException if the provided resolver is null.
    */
   @Test
@@ -183,14 +183,14 @@
   }
 
   /**
-   * @testName: compositeELResolverNPETest
+   * @testName  compositeELResolverNPETest
    *
-   * @assertion_ids: EL:JAVADOC:25; EL:JAVADOC:26; EL:JAVADOC:27; EL:JAVADOC:28;
+   * @assertion_ids  EL:JAVADOC:25; EL:JAVADOC:26; EL:JAVADOC:27; EL:JAVADOC:28;
    *                 EL:JAVADOC:29; EL:JAVADOC:30; EL:JAVADOC:31;
    *                 EL:JAVADOC:175; EL:JAVADOC:178; EL:JAVADOC:175;
    *                 EL:JAVADOC:182; EL:JAVADOC:185
    *
-   * @test_Strategy: Verify that API calls work as expected: getValue()
+   * @test_Strategy  Verify that API calls work as expected: getValue()
    *                 getType() setValue() isReadOnly() getCommonPropertyType()
    */
   @Test
@@ -226,13 +226,13 @@
   }
 
   /**
-   * @testName: compositeELResolverPNFETest
+   * @testName  compositeELResolverPNFETest
    *
-   * @assertion_ids: EL:JAVADOC:25; EL:JAVADOC:28; EL:JAVADOC:30; EL:JAVADOC:31;
+   * @assertion_ids  EL:JAVADOC:25; EL:JAVADOC:28; EL:JAVADOC:30; EL:JAVADOC:31;
    *                 EL:JAVADOC:176; EL:JAVADOC:179; EL:JAVADOC:183;
    *                 EL:JAVADOC:186
    *
-   * @test_Strategy: Verify that API calls throw PropertyNotFoundException as
+   * @test_Strategy  Verify that API calls throw PropertyNotFoundException as
    *                 expected: getType() setValue() isReadOnly()
    */
   @Test
@@ -266,11 +266,11 @@
   }
 
   /**
-   * @testName: compositeELResolverPNWETest
+   * @testName  compositeELResolverPNWETest
    *
-   * @assertion_ids: EL:JAVADOC:25; EL:JAVADOC:187
+   * @assertion_ids  EL:JAVADOC:25; EL:JAVADOC:187
    *
-   * @test_Strategy: Verify that the setValue() method throws a
+   * @test_Strategy  Verify that the setValue() method throws a
    *                 PropertyNotWritableException, if the resolver was
    *                 constructed in read-only mode.
    *
diff --git a/tck/src/main/java/ee/jakarta/tck/el/api/elcontext/ELClientIT.java b/tck/src/main/java/ee/jakarta/tck/el/api/elcontext/ELClientIT.java
index 787cc73..925bd26 100644
--- a/tck/src/main/java/ee/jakarta/tck/el/api/elcontext/ELClientIT.java
+++ b/tck/src/main/java/ee/jakarta/tck/el/api/elcontext/ELClientIT.java
@@ -57,13 +57,13 @@
   }
 
   /**
-   * @testName: elContextPutGetContextTest
-   * @assertion_ids: EL:JAVADOC:33; EL:JAVADOC:39; EL:JAVADOC:328;
+   * @testName  elContextPutGetContextTest
+   * @assertion_ids  EL:JAVADOC:33; EL:JAVADOC:39; EL:JAVADOC:328;
    *                 EL:JAVADOC:326; EL:JAVADOC:321
-   * @test_Strategy: Assert that we get back the expected value from
+   * @test_Strategy  Assert that we get back the expected value from
    *                 getContext() that we put in with putContext().
    *
-   * @since: 3.0
+   * @since 3.0
    */
   @Test
   public void elContextPutGetContextTest() throws Exception {
@@ -83,12 +83,12 @@
   } // end elContextPutGetContextTest
 
   /**
-   * @testName: elContextGetSetLocaleTest
-   * @assertion_ids: EL:JAVADOC:36; EL:JAVADOC:40; EL:JAVADOC:328;
+   * @testName  elContextGetSetLocaleTest
+   * @assertion_ids  EL:JAVADOC:36; EL:JAVADOC:40; EL:JAVADOC:328;
    *                 EL:JAVADOC:329
-   * @test_Strategy: Assert that we get back the Locale we set.
+   * @test_Strategy  Assert that we get back the Locale we set.
    *
-   * @since: 3.0
+   * @since 3.0
    */
   @Test
   public void elContextGetSetLocaleTest() throws Exception {
@@ -108,13 +108,13 @@
   } // end elContextGetSetLocaleTest
 
   /**
-   * @testName: elContextIsSetPropertyResolvedTest
-   * @assertion_ids: EL:JAVADOC:38; EL:JAVADOC:41; EL:JAVADOC:328;
+   * @testName  elContextIsSetPropertyResolvedTest
+   * @assertion_ids  EL:JAVADOC:38; EL:JAVADOC:41; EL:JAVADOC:328;
    *                 EL:JAVADOC:329; EL:JAVADOC:322
-   * @test_Strategy: Assert that when we call setPropertyResolved that
+   * @test_Strategy  Assert that when we call setPropertyResolved that
    *                 isPropertyResolved returns true.
    *
-   * @since: 3.0
+   * @since 3.0
    */
   @Test
   public void elContextIsSetPropertyResolvedTest() throws Exception {
@@ -141,13 +141,13 @@
   } // end elContextIsSetPropertyResolvedTest
 
   /**
-   * @testName: elContextPutContextNPETest
-   * @assertion_ids: EL:JAVADOC:33; EL:JAVADOC:198; EL:JAVADOC:328;
+   * @testName  elContextPutContextNPETest
+   * @assertion_ids  EL:JAVADOC:33; EL:JAVADOC:198; EL:JAVADOC:328;
    *                 EL:JAVADOC:329; EL:JAVADOC:327
-   * @test_Strategy: Validate that a NullPointerException is thrown if Class is
+   * @test_Strategy  Validate that a NullPointerException is thrown if Class is
    *                 null or Object is null.
    *
-   * @since: 3.0
+   * @since 3.0
    */
   @Test
   public void elContextPutContextNPETest() throws Exception {
@@ -167,13 +167,13 @@
   } // end elContextPutContextNPETest
 
   /**
-   * @testName: elContextGetContextNPETest
-   * @assertion_ids: EL:JAVADOC:33; EL:JAVADOC:194; EL:JAVADOC:328;
+   * @testName  elContextGetContextNPETest
+   * @assertion_ids  EL:JAVADOC:33; EL:JAVADOC:194; EL:JAVADOC:328;
    *                 EL:JAVADOC:329; EL:JAVADOC:321
-   * @test_Strategy: Validate that a NullPointerException is thrown if key is
+   * @test_Strategy  Validate that a NullPointerException is thrown if key is
    *                 null.
    *
-   * @since: 3.0
+   * @since 3.0
    */
   @Test
   public void elContextGetContextNPETest() throws Exception {
@@ -187,13 +187,13 @@
   } // end elContextGetContextNPETest
 
   /**
-   * @testName: elContextAddGetListenersTest
-   * @assertion_ids: EL:JAVADOC:33; EL:JAVADOC:191; EL:JAVADOC:197;
+   * @testName  elContextAddGetListenersTest
+   * @assertion_ids  EL:JAVADOC:33; EL:JAVADOC:191; EL:JAVADOC:197;
    *                 EL:JAVADOC:328; EL:JAVADOC:329
-   * @test_Strategy: Validate that a NullPointerException is thrown if key is
+   * @test_Strategy  Validate that a NullPointerException is thrown if key is
    *                 null.
    *
-   * @since: 3.0
+   * @since 3.0
    */
   @Test
   public void elContextAddGetListenersTest() throws Exception {
diff --git a/tck/src/main/java/ee/jakarta/tck/el/api/elprocessor/ELClientIT.java b/tck/src/main/java/ee/jakarta/tck/el/api/elprocessor/ELClientIT.java
index b2cefa6..8b95bd4 100644
--- a/tck/src/main/java/ee/jakarta/tck/el/api/elprocessor/ELClientIT.java
+++ b/tck/src/main/java/ee/jakarta/tck/el/api/elprocessor/ELClientIT.java
@@ -55,12 +55,12 @@
   }
 
   /**
-   * @testName: elProcessorDefineFunctionNPETest
-   * @assertion_ids: EL:JAVADOC:220; EL:JAVADOC:216; EL:JAVADOC:219
-   * @test_Strategy: Assert that a NullPointerException is thrown if any of the
+   * @testName  elProcessorDefineFunctionNPETest
+   * @assertion_ids  EL:JAVADOC:220; EL:JAVADOC:216; EL:JAVADOC:219
+   * @test_Strategy  Assert that a NullPointerException is thrown if any of the
    *                 arguments is null.
    *
-   * @since: 3.0
+   * @since 3.0
    */
   @Test
   public void elProcessorDefineFunctionNPETest() throws Exception {
@@ -128,12 +128,12 @@
   } // end elProcessorDefineFunctionNPETest
 
   /**
-   * @testName: elProcessorDefineFunctionCNFETest
-   * @assertion_ids: EL:JAVADOC:220; EL:JAVADOC:214; EL:JAVADOC:217
-   * @test_Strategy: Assert that a ClassNotFoundException if the specified class
+   * @testName  elProcessorDefineFunctionCNFETest
+   * @assertion_ids  EL:JAVADOC:220; EL:JAVADOC:214; EL:JAVADOC:217
+   * @test_Strategy  Assert that a ClassNotFoundException if the specified class
    *                 does not exists.
    *
-   * @since: 3.0
+   * @since 3.0
    */
   @Test
   public void elProcessorDefineFunctionCNFETest() throws Exception {
@@ -149,13 +149,13 @@
   } // end elProcessorDefineFunctionCNFETest
 
   /**
-   * @testName: elProcessorDefineFunctionNSMETest
-   * @assertion_ids: EL:JAVADOC:220; EL:JAVADOC:215
-   * @test_Strategy: Assert that a NoSuchMethodException if the method (with or
+   * @testName  elProcessorDefineFunctionNSMETest
+   * @assertion_ids  EL:JAVADOC:220; EL:JAVADOC:215
+   * @test_Strategy  Assert that a NoSuchMethodException if the method (with or
    *                 without the signature) is not a declared method of the
    *                 class, or if the method signature is not valid.
    *
-   * @since: 3.0
+   * @since 3.0
    */
   @Test
   public void elProcessorDefineFunctionNSMETest() throws Exception {
diff --git a/tck/src/main/java/ee/jakarta/tck/el/api/elresolver/ELClientIT.java b/tck/src/main/java/ee/jakarta/tck/el/api/elresolver/ELClientIT.java
index db409b5..da1fa35 100644
--- a/tck/src/main/java/ee/jakarta/tck/el/api/elresolver/ELClientIT.java
+++ b/tck/src/main/java/ee/jakarta/tck/el/api/elresolver/ELClientIT.java
@@ -64,12 +64,12 @@
   }
 
   /**
-   * @testName: elResolverTest
+   * @testName  elResolverTest
    *
-   * @assertion_ids: EL:JAVADOC:50; EL:JAVADOC:51; EL:JAVADOC:52; EL:JAVADOC:53;
+   * @assertion_ids  EL:JAVADOC:50; EL:JAVADOC:51; EL:JAVADOC:52; EL:JAVADOC:53;
    *                 EL:JAVADOC:54; EL:JAVADOC:55; EL:JAVADOC:229
    *
-   * @test_Strategy: Create an ELContext and get its ELResolver. Verify that API
+   * @test_Strategy  Create an ELContext and get its ELResolver. Verify that API
    *                 calls work as expected: getValue() getType() setValue()
    *                 isReadOnly() getCommonPropertyType()
    */
@@ -96,15 +96,15 @@
   } // end elResolverTest
 
   /**
-   * @testName: elResolverNPETest
+   * @testName  elResolverNPETest
    *
-   * @assertion_ids: EL:JAVADOC:233; EL:JAVADOC:239; EL:JAVADOC:242
+   * @assertion_ids  EL:JAVADOC:233; EL:JAVADOC:239; EL:JAVADOC:242
    *
-   * @test_Strategy: Verify that a NullPointerException is thrown as expected
+   * @test_Strategy  Verify that a NullPointerException is thrown as expected
    *                 for the following methods: getValue() getType() setValue()
    *                 isReadOnly()
    *
-   * @since: 3.0
+   * @since 3.0
    */
   @Test
   public void elResolverNPETest() throws Exception {
@@ -138,11 +138,11 @@
   }// end elResolverNPETest
 
   /**
-   * @testName: elResolverPNFETest
+   * @testName  elResolverPNFETest
    *
-   * @assertion_ids: EL:JAVADOC:231; EL:JAVADOC:234; EL:JAVADOC:240
+   * @assertion_ids  EL:JAVADOC:231; EL:JAVADOC:234; EL:JAVADOC:240
    *
-   * @test_Strategy: Verify that API calls throw PropertyNotFoundException as
+   * @test_Strategy  Verify that API calls throw PropertyNotFoundException as
    *                 expected: getType() setValue() isReadOnly()
    */
   @Test
@@ -175,11 +175,11 @@
   }// end elResolverPNFETest
 
   /**
-   * @testName: elResolverPNWETest
+   * @testName  elResolverPNWETest
    *
-   * @assertion_ids: EL:JAVADOC:50; EL:JAVADOC:244
+   * @assertion_ids  EL:JAVADOC:50; EL:JAVADOC:244
    *
-   * @test_Strategy: Verify that the setValue() method throws a
+   * @test_Strategy  Verify that the setValue() method throws a
    *                 PropertyNotWritableException, if the resolver was
    *                 constructed in read-only mode.
    *
diff --git a/tck/src/main/java/ee/jakarta/tck/el/api/expression/ELClientIT.java b/tck/src/main/java/ee/jakarta/tck/el/api/expression/ELClientIT.java
index a93c01e..7b6ea1d 100644
--- a/tck/src/main/java/ee/jakarta/tck/el/api/expression/ELClientIT.java
+++ b/tck/src/main/java/ee/jakarta/tck/el/api/expression/ELClientIT.java
@@ -60,11 +60,11 @@
 
 
   /**
-   * @testName: negativeEqualsTest
+   * @testName  negativeEqualsTest
    *
-   * @assertion_ids: EL:JAVADOC:56
+   * @assertion_ids  EL:JAVADOC:56
    *
-   * @test_Strategy: Validate the behavior of Expression API Expression.equals()
+   * @test_Strategy  Validate the behavior of Expression API Expression.equals()
    *
    *                 Verify that an Expression cannot equal null, and that a
    *                 ValueExpression and a MethodExpression cannot be equal.
@@ -129,11 +129,11 @@
   }// End negativeEqualsTest
 
   /**
-   * @testName: expressionHashCodeTest
+   * @testName  expressionHashCodeTest
    *
-   * @assertion_ids: EL:JAVADOC:59
+   * @assertion_ids  EL:JAVADOC:59
    *
-   * @test_Strategy: Validate the if two objects are equal according to the
+   * @test_Strategy  Validate the if two objects are equal according to the
    *                 equals(Object) method, then calling the hashCode method on
    *                 each of the two objects must produce the same integer
    *                 result.
diff --git a/tck/src/main/java/ee/jakarta/tck/el/api/expressionfactory/ELClientIT.java b/tck/src/main/java/ee/jakarta/tck/el/api/expressionfactory/ELClientIT.java
index d5afb5c..b1d25e9 100644
--- a/tck/src/main/java/ee/jakarta/tck/el/api/expressionfactory/ELClientIT.java
+++ b/tck/src/main/java/ee/jakarta/tck/el/api/expressionfactory/ELClientIT.java
@@ -60,10 +60,10 @@
   }
 
   /**
-   * @testName: newInstanceTest
+   * @testName  newInstanceTest
    *
-   * @assertion_ids: EL:JAVADOC:119; EL:JAVADOC:120
-   * @test_Strategy: Verify that an ExpressionFactory can be instantiated with
+   * @assertion_ids  EL:JAVADOC:119; EL:JAVADOC:120
+   * @test_Strategy  Verify that an ExpressionFactory can be instantiated with
    *                 the newInstance() API.
    */
   @Test
@@ -83,10 +83,10 @@
   }
 
   /**
-   * @testName: createValueExpressionTest
+   * @testName  createValueExpressionTest
    *
-   * @assertion_ids: EL:JAVADOC:63
-   * @test_Strategy: Verify that the ExpressionFactory can handle the types of
+   * @assertion_ids  EL:JAVADOC:63
+   * @test_Strategy  Verify that the ExpressionFactory can handle the types of
    *                 input specified in the javadoc when invoking the
    *                 createValueExpression(ELContext, String, Class) method.
    */
@@ -154,10 +154,10 @@
   }
 
   /**
-   * @testName: createValueExpression2Test
+   * @testName  createValueExpression2Test
    *
-   * @assertion_ids: EL:JAVADOC:64
-   * @test_Strategy: Verify the functionality of the
+   * @assertion_ids  EL:JAVADOC:64
+   * @test_Strategy  Verify the functionality of the
    *                 createValueExpression(Object, Class) method.
    */
   @Test
@@ -194,10 +194,10 @@
   }
 
   /**
-   * @testName: createValueExpressionELExceptionTest
+   * @testName  createValueExpressionELExceptionTest
    *
-   * @assertion_ids: EL:JAVADOC:63
-   * @test_Strategy: Verify that
+   * @assertion_ids  EL:JAVADOC:63
+   * @test_Strategy  Verify that
    *                 ExpressionFactory.createValueExpression(ELContext, String,
    *                 Class) throws an ELException for mixed delimiter
    *                 expressions and expressions with syntactical errors.
@@ -259,10 +259,10 @@
   }
 
   /**
-   * @testName: createMethodExpressionTest
+   * @testName  createMethodExpressionTest
    *
-   * @assertion_ids: EL:JAVADOC:62
-   * @test_Strategy: Verify that the ExpressionFactory can handle the types of
+   * @assertion_ids  EL:JAVADOC:62
+   * @test_Strategy  Verify that the ExpressionFactory can handle the types of
    *                 input specified in the javadoc when invoking the
    *                 createMethodExpression(ELContext, String, Class) method,
    *                 with the restriction that only expressions that share the
@@ -323,11 +323,11 @@
   }
 
   /**
-   * @testName: createMethodExpressionELExceptionTest
+   * @testName  createMethodExpressionELExceptionTest
    *
-   * @assertion_ids: EL:JAVADOC:63; EL:JAVADOC:253
+   * @assertion_ids  EL:JAVADOC:63; EL:JAVADOC:253
    *
-   * @test_Strategy: Verify that ExpressionFactory.createMethodExpression()
+   * @test_Strategy  Verify that ExpressionFactory.createMethodExpression()
    *                 throws an ELException for expressions with syntactical
    *                 errors, and for expressions that are not lvalues.
    */
@@ -392,12 +392,12 @@
   }
 
   /**
-   * @testName: createExpressionNPETest
+   * @testName  createExpressionNPETest
    *
-   * @assertion_ids: EL:JAVADOC:62; EL:JAVADOC:63; EL:JAVADOC:64;
+   * @assertion_ids  EL:JAVADOC:62; EL:JAVADOC:63; EL:JAVADOC:64;
    *                 EL:JAVADOC:253; EL:JAVADOC:254; EL:JAVADOC:256
    *
-   * @test_Strategy: Verify that ExpressionFactory.createValueExpression() and
+   * @test_Strategy  Verify that ExpressionFactory.createValueExpression() and
    *                 ExpressionFactory.createMethodExpression() throw a
    *                 NullPointerException under the conditions stated in the
    *                 javadoc.
@@ -429,10 +429,10 @@
   }
 
   /**
-   * @testName: coerceToTypeTest
+   * @testName  coerceToTypeTest
    *
-   * @assertion_ids: EL:JAVADOC:61
-   * @test_Strategy: Verify that the coerceToType() method coerces an object to
+   * @assertion_ids  EL:JAVADOC:61
+   * @test_Strategy  Verify that the coerceToType() method coerces an object to
    *                 a specific type according to the EL type conversion rules.
    */
   @Test
@@ -481,11 +481,11 @@
   }
 
   /**
-   * @testName: coerceToTypeELExceptionTest
+   * @testName  coerceToTypeELExceptionTest
    *
-   * @assertion_ids: EL:JAVADOC:61; EL:JAVADOC:251
+   * @assertion_ids  EL:JAVADOC:61; EL:JAVADOC:251
    *
-   * @test_Strategy: Verify that the coerceToType() method throws an ELException
+   * @test_Strategy  Verify that the coerceToType() method throws an ELException
    *                 for invalid type conversions.
    */
   @Test
diff --git a/tck/src/main/java/ee/jakarta/tck/el/api/functionmapper/ELClientIT.java b/tck/src/main/java/ee/jakarta/tck/el/api/functionmapper/ELClientIT.java
index 39a6c3b..a647ec1 100644
--- a/tck/src/main/java/ee/jakarta/tck/el/api/functionmapper/ELClientIT.java
+++ b/tck/src/main/java/ee/jakarta/tck/el/api/functionmapper/ELClientIT.java
@@ -57,10 +57,10 @@
 
 
   /**
-   * @testName: functionMapperTest
+   * @testName  functionMapperTest
    *
-   * @assertion_ids: EL:JAVADOC:35; EL:JAVADOC:67
-   * @test_Strategy: Validate the behavior of ELContext.getFunctionMapper()
+   * @assertion_ids  EL:JAVADOC:35; EL:JAVADOC:67
+   * @test_Strategy  Validate the behavior of ELContext.getFunctionMapper()
    *                 FunctionMapper.resolveFunction()
    */
   @Test
diff --git a/tck/src/main/java/ee/jakarta/tck/el/api/lambdaexpression/ELClientIT.java b/tck/src/main/java/ee/jakarta/tck/el/api/lambdaexpression/ELClientIT.java
index 1ab340c..76ad455 100644
--- a/tck/src/main/java/ee/jakarta/tck/el/api/lambdaexpression/ELClientIT.java
+++ b/tck/src/main/java/ee/jakarta/tck/el/api/lambdaexpression/ELClientIT.java
@@ -57,11 +57,11 @@
 
 
   /**
-   * @testName: invokeNPETest
+   * @testName  invokeNPETest
    *
-   * @assertion_ids: EL:JAVADOC:406
+   * @assertion_ids  EL:JAVADOC:406
    *
-   * @test_Strategy: Throws a NullPointerException if elContext is null.
+   * @test_Strategy  Throws a NullPointerException if elContext is null.
    */
   @Test
   public void invokeNPETest() throws Exception {
@@ -75,11 +75,11 @@
   }// End invokeNPETest
 
   /**
-   * @testName: invokeELETest
+   * @testName  invokeELETest
    *
-   * @assertion_ids: EL:JAVADOC:408
+   * @assertion_ids  EL:JAVADOC:408
    *
-   * @test_Strategy: Throws a ELException if not enough arguments are provided.
+   * @test_Strategy  Throws a ELException if not enough arguments are provided.
    */
   @Test
   public void invokeELETest() throws Exception {
diff --git a/tck/src/main/java/ee/jakarta/tck/el/api/listelresolver/ELClientIT.java b/tck/src/main/java/ee/jakarta/tck/el/api/listelresolver/ELClientIT.java
index 16a69d7..2ae2b75 100644
--- a/tck/src/main/java/ee/jakarta/tck/el/api/listelresolver/ELClientIT.java
+++ b/tck/src/main/java/ee/jakarta/tck/el/api/listelresolver/ELClientIT.java
@@ -69,12 +69,12 @@
 
 
   /**
-   * @testName: listELResolverTest
+   * @testName  listELResolverTest
    *
-   * @assertion_ids: EL:JAVADOC:68; EL:JAVADOC:69; EL:JAVADOC:70; EL:JAVADOC:71;
+   * @assertion_ids  EL:JAVADOC:68; EL:JAVADOC:69; EL:JAVADOC:70; EL:JAVADOC:71;
    *                 EL:JAVADOC:72; EL:JAVADOC:73; EL:JAVADOC:75
    *
-   * @test_Strategy: Verify that API calls work as expected: ListELResolver()
+   * @test_Strategy  Verify that API calls work as expected: ListELResolver()
    *                 getValue() getType() setValue() isReadOnly()
    *                 getCommonPropertyType()
    */
@@ -101,13 +101,13 @@
   }
 
   /**
-   * @testName: listELResolverNPETest
+   * @testName  listELResolverNPETest
    *
-   * @assertion_ids: EL:JAVADOC:70; EL:JAVADOC:71; EL:JAVADOC:72; EL:JAVADOC:73;
+   * @assertion_ids  EL:JAVADOC:70; EL:JAVADOC:71; EL:JAVADOC:72; EL:JAVADOC:73;
    *                 EL:JAVADOC:75; EL:JAVADOC:276; EL:JAVADOC:279;
    *                 EL:JAVADOC:282; EL:JAVADOC:285
    *
-   * @test_Strategy: Verify that the following methods throw a
+   * @test_Strategy  Verify that the following methods throw a
    *                 NullPointerException, if context is null:
    *
    *                 getType() getValue() isReadOnly() setValue()
@@ -132,11 +132,11 @@
   }
 
   /**
-   * @testName: listELResolverPNFETest
+   * @testName  listELResolverPNFETest
    *
-   * @assertion_ids: EL:JAVADOC:70; EL:JAVADOC:72; EL:JAVADOC:73; EL:JAVADOC:75;
+   * @assertion_ids  EL:JAVADOC:70; EL:JAVADOC:72; EL:JAVADOC:73; EL:JAVADOC:75;
    *                 EL:JAVADOC:275; EL:JAVADOC:281; EL:JAVADOC:288
-   * @test_Strategy: Verify that the following methods throw a
+   * @test_Strategy  Verify that the following methods throw a
    *                 PropertyNotFoundException, if the given index is out of
    *                 bounds for this list:
    *
@@ -165,12 +165,12 @@
   }
 
   /**
-   * @testName: listELResolverIAETest
+   * @testName  listELResolverIAETest
    *
-   * @assertion_ids: EL:JAVADOC:71; EL:JAVADOC:73; EL:JAVADOC:75;
+   * @assertion_ids  EL:JAVADOC:71; EL:JAVADOC:73; EL:JAVADOC:75;
    *                 EL:JAVADOC:278; EL:JAVADOC:286
    *
-   * @test_Strategy: Verify that the following methods throw an
+   * @test_Strategy  Verify that the following methods throw an
    *                 IllegalArgumentException, if the property could not be
    *                 coerced into an integer:
    *
@@ -199,11 +199,11 @@
   }
 
   /**
-   * @testName: listELResolverPNWETest
+   * @testName  listELResolverPNWETest
    *
-   * @assertion_ids: EL:JAVADOC:74; EL:JAVADOC:75; EL:JAVADOC:287
+   * @assertion_ids  EL:JAVADOC:74; EL:JAVADOC:75; EL:JAVADOC:287
    *
-   * @test_Strategy: Verify that the single-parameter constructor for
+   * @test_Strategy  Verify that the single-parameter constructor for
    *                 listELResolver can be used to construct a read-only
    *                 resolver, and that the setValue() method throws a
    *                 PropertyNotWritableException, if the resolver was
diff --git a/tck/src/main/java/ee/jakarta/tck/el/api/mapelresolver/ELClientIT.java b/tck/src/main/java/ee/jakarta/tck/el/api/mapelresolver/ELClientIT.java
index 22e18c7..ff05362 100644
--- a/tck/src/main/java/ee/jakarta/tck/el/api/mapelresolver/ELClientIT.java
+++ b/tck/src/main/java/ee/jakarta/tck/el/api/mapelresolver/ELClientIT.java
@@ -69,11 +69,11 @@
 
 
   /**
-   * @testName: mapELResolverTest
+   * @testName  mapELResolverTest
    *
-   * @assertion_ids: EL:JAVADOC:76; EL:JAVADOC:77; EL:JAVADOC:78; EL:JAVADOC:79;
+   * @assertion_ids  EL:JAVADOC:76; EL:JAVADOC:77; EL:JAVADOC:78; EL:JAVADOC:79;
    *                 EL:JAVADOC:80; EL:JAVADOC:81; EL:JAVADOC:83
-   * @test_Strategy: Verify that API calls work as expected: MapELResolver()
+   * @test_Strategy  Verify that API calls work as expected: MapELResolver()
    *                 getValue() getType() setValue() isReadOnly()
    *                 getCommonPropertyType()
    */
@@ -100,13 +100,13 @@
   }
 
   /**
-   * @testName: mapELResolverNPETest
+   * @testName  mapELResolverNPETest
    *
-   * @assertion_ids: EL:JAVADOC:78; EL:JAVADOC:79; EL:JAVADOC:80; EL:JAVADOC:81;
+   * @assertion_ids  EL:JAVADOC:78; EL:JAVADOC:79; EL:JAVADOC:80; EL:JAVADOC:81;
    *                 EL:JAVADOC:83; EL:JAVADOC:293; EL:JAVADOC:295;
    *                 EL:JAVADOC:298; EL:JAVADOC:290
    *
-   * @test_Strategy: Verify that the following methods throw a
+   * @test_Strategy  Verify that the following methods throw a
    *                 NullPointerException, if context is null:
    *
    *                 getType() getValue() isReadOnly() setValue()
@@ -132,11 +132,11 @@
   }
 
   /**
-   * @testName: mapELResolverPNWETest
+   * @testName  mapELResolverPNWETest
    *
-   * @assertion_ids: EL:JAVADOC:82; EL:JAVADOC:83; EL:JAVADOC:301
+   * @assertion_ids  EL:JAVADOC:82; EL:JAVADOC:83; EL:JAVADOC:301
    *
-   * @test_Strategy: Verify that the single-parameter constructor for
+   * @test_Strategy  Verify that the single-parameter constructor for
    *                 mapELResolver can be used to construct a read-only
    *                 resolver, and that the setValue() method throws a
    *                 PropertyNotWritableException, if the resolver was
diff --git a/tck/src/main/java/ee/jakarta/tck/el/api/methodexpression/ELClientIT.java b/tck/src/main/java/ee/jakarta/tck/el/api/methodexpression/ELClientIT.java
index 5f7e6cc..0f0c740 100644
--- a/tck/src/main/java/ee/jakarta/tck/el/api/methodexpression/ELClientIT.java
+++ b/tck/src/main/java/ee/jakarta/tck/el/api/methodexpression/ELClientIT.java
@@ -73,10 +73,10 @@
   }
 
   /**
-   * @testName: positiveMethodExpressionTest
+   * @testName  positiveMethodExpressionTest
    * 
-   * @assertion_ids: EL:JAVADOC:84; EL:JAVADOC:85; EL:JAVADOC:58; EL:JAVADOC:60
-   * @test_Strategy: Validate the behavior of MethodExpression API
+   * @assertion_ids  EL:JAVADOC:84; EL:JAVADOC:85; EL:JAVADOC:58; EL:JAVADOC:60
+   * @test_Strategy  Validate the behavior of MethodExpression API
    *                 MethodExpression.getMethodInfo() MethodExpression.invoke()
    *                 Expression.isLiteralText() Expression.getExpressionString()
    */
@@ -143,14 +143,14 @@
   }
 
   /**
-   * @testName: negativeMethodExpressionTest
+   * @testName  negativeMethodExpressionTest
    * 
-   * @assertion_ids: EL:JAVADOC:84; EL:JAVADOC:85; EL:JAVADOC:302;
+   * @assertion_ids  EL:JAVADOC:84; EL:JAVADOC:85; EL:JAVADOC:302;
    *                 EL:JAVADOC:306; EL:JAVADOC:303; EL:JAVADOC:307;
    *                 EL:JAVADOC:309; EL:JAVADOC:310; EL:JAVADOC:304;
    *                 EL:JAVADOC:308
    * 
-   * @test_Strategy: Validate the behavior of MethodExpression API
+   * @test_Strategy  Validate the behavior of MethodExpression API
    *                 MethodExpression.getMethodInfo() MethodExpression.invoke()
    */
   @Test
@@ -384,11 +384,11 @@
   }
 
   /*
-   * @testName: methodExpressionSerializableTest
+   * @testName  methodExpressionSerializableTest
    * 
-   * @assertion_ids: EL:SPEC:44
+   * @assertion_ids  EL:SPEC:44
    * 
-   * @test_Strategy: Validate that MethodExpression implements Serializable and
+   * @test_Strategy  Validate that MethodExpression implements Serializable and
    * that a MethodExpression can be manually serialized and deserialized.
    */
   @Test
@@ -435,11 +435,11 @@
   }
 
   /*
-   * @testName: methodExpressionMatchingExactPreferredTest
+   * @testName  methodExpressionMatchingExactPreferredTest
    * 
-   * @assertion_ids: EL:SPEC:80
+   * @assertion_ids  EL:SPEC:80
    * 
-   * @test_Strategy: Validate that MethodExpression identifies the correct
+   * @test_Strategy  Validate that MethodExpression identifies the correct
    * method for the given parameters and that exact type matches are always
    * preferred.
    */
@@ -480,11 +480,11 @@
   }
   
   /*
-   * @testName: methodExpressionMatchingOverloadBeatsCoercionTest
+   * @testName  methodExpressionMatchingOverloadBeatsCoercionTest
    * 
-   * @assertion_ids: EL:SPEC:80
+   * @assertion_ids  EL:SPEC:80
    * 
-   * @test_Strategy: Validate that MethodExpression identifies the correct
+   * @test_Strategy  Validate that MethodExpression identifies the correct
    * method for the given parameters and that overloading is preferred to
    * coercion.
    */
@@ -524,11 +524,11 @@
   }
 
   /*
-   * @testName: methodExpressionMatchingOverloadBeatsExactVarArgsTest
+   * @testName  methodExpressionMatchingOverloadBeatsExactVarArgsTest
    * 
-   * @assertion_ids: EL:SPEC:80
+   * @assertion_ids  EL:SPEC:80
    * 
-   * @test_Strategy: Validate that MethodExpression identifies the correct
+   * @test_Strategy  Validate that MethodExpression identifies the correct
    * method for the given parameters and that any match without varags is
    * preferred to all matches with varrags
    */
@@ -568,11 +568,11 @@
   }
 
   /*
-   * @testName: methodExpressionMatchingCoercionBeatsExactVarArgsTest
+   * @testName  methodExpressionMatchingCoercionBeatsExactVarArgsTest
    * 
-   * @assertion_ids: EL:SPEC:80
+   * @assertion_ids  EL:SPEC:80
    * 
-   * @test_Strategy: Validate that MethodExpression identifies the correct
+   * @test_Strategy  Validate that MethodExpression identifies the correct
    * method for the given parameters and that any match without varags is
    * preferred to all matches with varrags
    */
@@ -612,11 +612,11 @@
   }
 
   /*
-   * @testName: methodExpressionMatchingVarArgsTest
+   * @testName  methodExpressionMatchingVarArgsTest
    * 
-   * @assertion_ids: EL:SPEC:80
+   * @assertion_ids  EL:SPEC:80
    * 
-   * @test_Strategy: Validate that MethodExpression identifies the correct
+   * @test_Strategy  Validate that MethodExpression identifies the correct
    * method for the given parameters and that varags will be matched if no other
    * suitable match is available
    */
@@ -656,11 +656,11 @@
   }
 
   /*
-   * @testName: methodExpressionMatchingAmbiguousTest
+   * @testName  methodExpressionMatchingAmbiguousTest
    * 
-   * @assertion_ids: EL:SPEC:80
+   * @assertion_ids  EL:SPEC:80
    * 
-   * @test_Strategy: Validate that MethodExpression does not match a method when
+   * @test_Strategy  Validate that MethodExpression does not match a method when
    * the match is ambiguous and that a MethodNotFoundException is thrown
    */
   @Test
diff --git a/tck/src/main/java/ee/jakarta/tck/el/api/methodinfo/ELClientIT.java b/tck/src/main/java/ee/jakarta/tck/el/api/methodinfo/ELClientIT.java
index 69e5efe..3ea46d6 100644
--- a/tck/src/main/java/ee/jakarta/tck/el/api/methodinfo/ELClientIT.java
+++ b/tck/src/main/java/ee/jakarta/tck/el/api/methodinfo/ELClientIT.java
@@ -58,10 +58,10 @@
   }
 
   /**
-   * @testName: methodInfoTest
+   * @testName  methodInfoTest
    *
-   * @assertion_ids: EL:JAVADOC:411;EL:JAVADOC:412;EL:JAVADOC:413
-   * @test_Strategy: Validate the behavior of MethodInfo MethodInfo class
+   * @assertion_ids  EL:JAVADOC:411;EL:JAVADOC:412;EL:JAVADOC:413
+   * @test_Strategy  Validate the behavior of MethodInfo MethodInfo class
    *                 methods: MethodInfo.getName() MethodInfo.getReturnType()
    *                 MethodInfo.getParamTypes()
    */
diff --git a/tck/src/main/java/ee/jakarta/tck/el/api/methodreference/ELClientIT.java b/tck/src/main/java/ee/jakarta/tck/el/api/methodreference/ELClientIT.java
index 1b8dae7..0cb6553 100644
--- a/tck/src/main/java/ee/jakarta/tck/el/api/methodreference/ELClientIT.java
+++ b/tck/src/main/java/ee/jakarta/tck/el/api/methodreference/ELClientIT.java
@@ -67,10 +67,10 @@
   }
 
   /**
-   * @testName: methodReferenceTest
+   * @testName  methodReferenceTest
    * 
-   * @assertion_ids: EL:JAVADOC:87; EL:JAVADOC:88; EL:JAVADOC:89
-   * @test_Strategy: Validate the behavior of MethodReference class methods:
+   * @assertion_ids  EL:JAVADOC:87; EL:JAVADOC:88; EL:JAVADOC:89
+   * @test_Strategy  Validate the behavior of MethodReference class methods:
    *                 MethodReference.getBase() MethodReference.getMethodInfo()
    *                 MethodReference.getAnnotations()
    *                 MethodReference.getEvaluatedParameters
diff --git a/tck/src/main/java/ee/jakarta/tck/el/api/optionalelresolver/ELClientIT.java b/tck/src/main/java/ee/jakarta/tck/el/api/optionalelresolver/ELClientIT.java
index aa0753e..f213c41 100644
--- a/tck/src/main/java/ee/jakarta/tck/el/api/optionalelresolver/ELClientIT.java
+++ b/tck/src/main/java/ee/jakarta/tck/el/api/optionalelresolver/ELClientIT.java
@@ -53,9 +53,9 @@
   }
 
   /**
-   * @testName: optionalELResolverEmptyNullTest
+   * @testName  optionalELResolverEmptyNullTest
    *
-   * @test_Strategy: Verify that API calls work as expected for: getValue() getType() setValue() isReadOnly()
+   * @test_Strategy  Verify that API calls work as expected for: getValue() getType() setValue() isReadOnly()
    * getCommonPropertyType() when the base object is an empty Optional and the property is null
    */
   @Test
@@ -74,9 +74,9 @@
   }
   
   /**
-   * @testName: optionalELResolverEmptyNonNullTest
+   * @testName  optionalELResolverEmptyNonNullTest
    *
-   * @test_Strategy: Verify that API calls work as expected for: getValue() getType() setValue() isReadOnly()
+   * @test_Strategy  Verify that API calls work as expected for: getValue() getType() setValue() isReadOnly()
    * getCommonPropertyType() when the base object is an empty Optional and the property is non-null
    */
   @Test
@@ -95,9 +95,9 @@
   }
 
   /**
-   * @testName: optionalELResolverObjectNullTest
+   * @testName  optionalELResolverObjectNullTest
    *
-   * @test_Strategy: Verify that API calls work as expected for: getValue() getType() setValue() isReadOnly()
+   * @test_Strategy  Verify that API calls work as expected for: getValue() getType() setValue() isReadOnly()
    * getCommonPropertyType() when the base object is an non-empty Optional and the property is null
    */
   @Test
@@ -117,9 +117,9 @@
   }
 
   /**
-   * @testName: optionalELResolverObjectNonNullTest
+   * @testName  optionalELResolverObjectNonNullTest
    *
-   * @test_Strategy: Verify that API calls work as expected for: getValue() getType() setValue() isReadOnly()
+   * @test_Strategy  Verify that API calls work as expected for: getValue() getType() setValue() isReadOnly()
    * getCommonPropertyType() when the base object is an non-empty Optional and the property is non-null
    */
   @Test
diff --git a/tck/src/main/java/ee/jakarta/tck/el/api/recordelresolver/ELClientIT.java b/tck/src/main/java/ee/jakarta/tck/el/api/recordelresolver/ELClientIT.java
index 4ee4f55..9b82ed7 100644
--- a/tck/src/main/java/ee/jakarta/tck/el/api/recordelresolver/ELClientIT.java
+++ b/tck/src/main/java/ee/jakarta/tck/el/api/recordelresolver/ELClientIT.java
@@ -48,9 +48,9 @@
   }
 
   /**
-   * @testName: recordELResolverTest
+   * @testName  recordELResolverTest
    *
-   * @test_Strategy: Verify that API calls work as expected for: arrayELResolver() getValue() getType() setValue()
+   * @test_Strategy  Verify that API calls work as expected for: arrayELResolver() getValue() getType() setValue()
    * isReadOnly() getCommonPropertyType(). Records should behave similarly to read-only beans.
    */
   @Test
diff --git a/tck/src/main/java/ee/jakarta/tck/el/api/resourcebundleelresolver/ELClientIT.java b/tck/src/main/java/ee/jakarta/tck/el/api/resourcebundleelresolver/ELClientIT.java
index 44a62f4..4c7f45b 100644
--- a/tck/src/main/java/ee/jakarta/tck/el/api/resourcebundleelresolver/ELClientIT.java
+++ b/tck/src/main/java/ee/jakarta/tck/el/api/resourcebundleelresolver/ELClientIT.java
@@ -68,13 +68,13 @@
   }
 
   /**
-   * @testName: resourceBundleELResolverTest
+   * @testName  resourceBundleELResolverTest
    *
-   * @assertion_ids: EL:JAVADOC:103; EL:JAVADOC:104; EL:JAVADOC:105;
+   * @assertion_ids  EL:JAVADOC:103; EL:JAVADOC:104; EL:JAVADOC:105;
    *                 EL:JAVADOC:106; EL:JAVADOC:107; EL:JAVADOC:108;
    *                 EL:JAVADOC:109
    *
-   * @test_Strategy: Verify that API calls work as expected:
+   * @test_Strategy  Verify that API calls work as expected:
    *                 ResourceBundleELResolver() setValue() getValue() getType()
    *                 isReadOnly() getCommonPropertyType()
    */
@@ -101,13 +101,13 @@
   }
 
   /**
-   * @testName: resourceBundleELResolverNPETest
+   * @testName  resourceBundleELResolverNPETest
    *
-   * @assertion_ids: EL:JAVADOC:106; EL:JAVADOC:105; EL:JAVADOC:107;
+   * @assertion_ids  EL:JAVADOC:106; EL:JAVADOC:105; EL:JAVADOC:107;
    *                 EL:JAVADOC:108; EL:JAVADOC:109; EL:JAVADOC:313;
    *                 EL:JAVADOC:314; EL:JAVADOC:316; EL:JAVADOC:317
    *
-   * @test_Strategy: Verify that the following methods throw a
+   * @test_Strategy  Verify that the following methods throw a
    *                 NullPointerException, if context is null:
    *
    *                 getValue() getType() setValue() isReadOnly()
@@ -133,11 +133,11 @@
   }
 
   /**
-   * @testName: resourceBundleELResolverPNWETest
+   * @testName  resourceBundleELResolverPNWETest
    *
-   * @assertion_ids: EL:JAVADOC:108; EL:JAVADOC:109; EL:JAVADOC:318
+   * @assertion_ids  EL:JAVADOC:108; EL:JAVADOC:109; EL:JAVADOC:318
    *
-   * @test_Strategy: Verify that the following methods throw a
+   * @test_Strategy  Verify that the following methods throw a
    *                 PropertyNotWritableException, since
    *                 ResourceBundleELResolvers are non-writable.
    *
diff --git a/tck/src/main/java/ee/jakarta/tck/el/api/staticfieldelresolver/ELClientIT.java b/tck/src/main/java/ee/jakarta/tck/el/api/staticfieldelresolver/ELClientIT.java
index 3539e1b..10bed30 100644
--- a/tck/src/main/java/ee/jakarta/tck/el/api/staticfieldelresolver/ELClientIT.java
+++ b/tck/src/main/java/ee/jakarta/tck/el/api/staticfieldelresolver/ELClientIT.java
@@ -58,15 +58,15 @@
   }
 
   /**
-   * @testName: staticFieldELResolverTest
+   * @testName  staticFieldELResolverTest
    *
-   * @assertion_ids: EL:JAVADOC:330; EL:JAVADOC:331; EL:JAVADOC:332;
+   * @assertion_ids  EL:JAVADOC:330; EL:JAVADOC:331; EL:JAVADOC:332;
    *                 EL:JAVADOC:335; EL:JAVADOC:338; EL:JAVADOC:341;
    *                 EL:JAVADOC:343; EL:JAVADOC:346; EL:JAVADOC:189;
    *                 EL:JAVADOC:204
    *
    *
-   * @test_Strategy: Verify the following method calls work as expected:
+   * @test_Strategy  Verify the following method calls work as expected:
    *                 getValue() getType() setValue() isReadOnly()
    *                 getCommonPropertyType()
    */
@@ -165,11 +165,11 @@
   } // End staticFieldELResolverTest
 
   /**
-   * @testName: staticFieldResolverInvokeMNFETest
+   * @testName  staticFieldResolverInvokeMNFETest
    *
-   * @assertion_ids: EL:JAVADOC:339; EL:JAVADOC:189; EL:JAVADOC:204
+   * @assertion_ids  EL:JAVADOC:339; EL:JAVADOC:189; EL:JAVADOC:204
    *
-   * @test_Strategy: Verify that the invoke() method throws
+   * @test_Strategy  Verify that the invoke() method throws
    *                 MethodNotFoundException if no suitable method can be found.
    */
   @Test
@@ -202,11 +202,11 @@
   }// End staticFieldResolverInvokeMNFETest
 
   /**
-   * @testName: staticFieldELResolverInvokeTest
+   * @testName  staticFieldELResolverInvokeTest
    *
-   * @assertion_ids: EL:JAVADOC:338; EL:JAVADOC:189; EL:JAVADOC:204
+   * @assertion_ids  EL:JAVADOC:338; EL:JAVADOC:189; EL:JAVADOC:204
    *
-   * @test_Strategy: Verify that API calls work as expected for
+   * @test_Strategy  Verify that API calls work as expected for
    *                 BeanNameELResolver.invoke().
    */
   @Test
@@ -239,12 +239,12 @@
   }// End staticFieldELResolverInvokeTest
 
   /**
-   * @testName: staticFieldELResolverNPETest
+   * @testName  staticFieldELResolverNPETest
    *
-   * @assertion_ids: EL:JAVADOC:333; EL:JAVADOC:336; EL:JAVADOC:342;
+   * @assertion_ids  EL:JAVADOC:333; EL:JAVADOC:336; EL:JAVADOC:342;
    *                 EL:JAVADOC:344; EL:JAVADOC:189
    *
-   * @test_Strategy: Verify that the following methods throw a
+   * @test_Strategy  Verify that the following methods throw a
    *                 NullPointerException, if context is null:
    *
    *                 getType() getValue() isReadOnly() setValue()
@@ -275,11 +275,11 @@
   } // End staticFieldELResolverNPETest
 
   /**
-   * @testName: staticFieldResolverInvokePNFETest
+   * @testName  staticFieldResolverInvokePNFETest
    *
-   * @assertion_ids: EL:JAVADOC:334; EL:JAVADOC:337
+   * @assertion_ids  EL:JAVADOC:334; EL:JAVADOC:337
    *
-   * @test_Strategy: Verify that the invoke() method throws
+   * @test_Strategy  Verify that the invoke() method throws
    *                 PropertyNotFoundException the specified class does not
    *                 exist, or if the field is not a public static filed of the
    *                 class, or if the field is inaccessible.
diff --git a/tck/src/main/java/ee/jakarta/tck/el/api/valueexpression/ELClientIT.java b/tck/src/main/java/ee/jakarta/tck/el/api/valueexpression/ELClientIT.java
index 6b7ba22..280d043 100644
--- a/tck/src/main/java/ee/jakarta/tck/el/api/valueexpression/ELClientIT.java
+++ b/tck/src/main/java/ee/jakarta/tck/el/api/valueexpression/ELClientIT.java
@@ -70,11 +70,11 @@
   }
 
   /**
-   * @testName: positiveValueExpressionTest
-   * @assertion_ids: EL:JAVADOC:110; EL:JAVADOC:111; EL:JAVADOC:112;
+   * @testName  positiveValueExpressionTest
+   * @assertion_ids  EL:JAVADOC:110; EL:JAVADOC:111; EL:JAVADOC:112;
    *                 EL:JAVADOC:113; EL:JAVADOC:114; EL:JAVADOC:60;
    *                 EL:JAVADOC:58
-   * @test_Strategy: Validate the behavior of ValueExpression API
+   * @test_Strategy  Validate the behavior of ValueExpression API
    *                 ValueExpression.getValue() ValueExpression.setValue()
    *                 ValueExpression.getType() ValueExpression.getExpectedType()
    *                 ValueExpression.isReadOTestUtil.NEW_LINEy()
@@ -164,13 +164,13 @@
   }
 
   /**
-   * @testName: negativeValueExpressionTest
-   * @assertion_ids: EL:JAVADOC:111; EL:JAVADOC:112; EL:JAVADOC:113;
+   * @testName  negativeValueExpressionTest
+   * @assertion_ids  EL:JAVADOC:111; EL:JAVADOC:112; EL:JAVADOC:113;
    *                 EL:JAVADOC:114; EL:JAVADOC:368; EL:JAVADOC:371;
    *                 EL:JAVADOC:372; EL:JAVADOC:375; EL:JAVADOC:376;
    *                 EL:JAVADOC:378; EL:JAVADOC:379; EL:JAVADOC:380
    *
-   * @test_Strategy: Validate the behavior of ValueExpression API
+   * @test_Strategy  Validate the behavior of ValueExpression API
    *                 ValueExpression.getValue() ValueExpression.setValue()
    *                 ValueExpression.getType()
    *                 ValueExpression.isReadOTestUtil.NEW_LINEy()
@@ -352,11 +352,11 @@
   }
 
   /**
-   * @testName: valueExpressionSerializableTest
+   * @testName  valueExpressionSerializableTest
    *
-   * @assertion_ids: EL:SPEC:44
+   * @assertion_ids  EL:SPEC:44
    *
-   * @test_Strategy: Validate that ValueExpression implements Serializable and
+   * @test_Strategy  Validate that ValueExpression implements Serializable and
    *                 that a ValueExpression can be manually serialized and
    *                 deserialized.
    */
@@ -432,11 +432,11 @@
   }
 
   /**
-   * @testName: valueExpressionEqualsTest
+   * @testName  valueExpressionEqualsTest
    *
-   * @assertion_ids: EL:JAVADOC:56
+   * @assertion_ids  EL:JAVADOC:56
    *
-   * @test_Strategy: Validate that ValueExpression implements equals() and that
+   * @test_Strategy  Validate that ValueExpression implements equals() and that
    *                 the behavior is as expected
    */
   @Test
diff --git a/tck/src/main/java/ee/jakarta/tck/el/api/variablemapper/ELClientIT.java b/tck/src/main/java/ee/jakarta/tck/el/api/variablemapper/ELClientIT.java
index 91fcdd7..fc57894 100644
--- a/tck/src/main/java/ee/jakarta/tck/el/api/variablemapper/ELClientIT.java
+++ b/tck/src/main/java/ee/jakarta/tck/el/api/variablemapper/ELClientIT.java
@@ -63,10 +63,10 @@
   }
 
   /**
-   * @testName: variableMapperTest
+   * @testName  variableMapperTest
    * 
-   * @assertion_ids: EL:JAVADOC:37; EL:JAVADOC:116; EL:JAVADOC:117
-   * @test_Strategy: Validate the behavior of ELContext.getVariableMapper()
+   * @assertion_ids  EL:JAVADOC:37; EL:JAVADOC:116; EL:JAVADOC:117
+   * @test_Strategy  Validate the behavior of ELContext.getVariableMapper()
    *                 VariableMapper.resolveVariable()
    *                 VariableMapper.setVariable()
    */
diff --git a/tck/src/main/java/ee/jakarta/tck/el/signaturetest/ELSigTestIT.java b/tck/src/main/java/ee/jakarta/tck/el/signaturetest/ELSigTestIT.java
index 7a83ada..809c89a 100644
--- a/tck/src/main/java/ee/jakarta/tck/el/signaturetest/ELSigTestIT.java
+++ b/tck/src/main/java/ee/jakarta/tck/el/signaturetest/ELSigTestIT.java
@@ -71,12 +71,12 @@
   // signature tests need. Please do not use both comments.
 
   /*
-   * @testName: signatureTest
+   * @testName  signatureTest
    *
    * @assertion: An EL container must implement the required classes and APIs
    * specified in the EL Specification.
    *
-   * @test_Strategy: Using reflection, gather the implementation specific
+   * @test_Strategy  Using reflection, gather the implementation specific
    * classes and APIs. Compare these results with the expected (required)
    * classes and APIs.
    *
diff --git a/tck/src/main/java/ee/jakarta/tck/el/spec/assignmentoperator/ELClientIT.java b/tck/src/main/java/ee/jakarta/tck/el/spec/assignmentoperator/ELClientIT.java
index bda16ff..9b0c77c 100644
--- a/tck/src/main/java/ee/jakarta/tck/el/spec/assignmentoperator/ELClientIT.java
+++ b/tck/src/main/java/ee/jakarta/tck/el/spec/assignmentoperator/ELClientIT.java
@@ -60,10 +60,10 @@
 
 
   /**
-   * @testName: elAssignmentOperatorBigDecimalTest
-   * @assertion_ids: EL:SPEC:48.1.1; EL:SPEC:48.1.2; EL:SPEC:48.1.3;
+   * @testName  elAssignmentOperatorBigDecimalTest
+   * @assertion_ids  EL:SPEC:48.1.1; EL:SPEC:48.1.2; EL:SPEC:48.1.3;
    *                 EL:SPEC:48.1.4
-   * @test_Strategy: Validate that when we have variable A set to a specific
+   * @test_Strategy  Validate that when we have variable A set to a specific
    *                 data type that we coerce and receive back the correct value
    *                 and Class type.
    *
@@ -77,7 +77,7 @@
    *
    *                 Excluded: none
    *
-   * @since: 3.0
+   * @since 3.0
    *
    */
   @Test
@@ -135,10 +135,10 @@
   } // End elAssignmentOperatorBigDecimalTest
 
   /**
-   * @testName: elAssignmentOperatorFloatTest
-   * @assertion_ids: EL:SPEC:48.1.1; EL:SPEC:48.1.2; EL:SPEC:48.1.3;
+   * @testName  elAssignmentOperatorFloatTest
+   * @assertion_ids  EL:SPEC:48.1.1; EL:SPEC:48.1.2; EL:SPEC:48.1.3;
    *                 EL:SPEC:48.1.4
-   * @test_Strategy: Validate that when we have variable A set to a specific
+   * @test_Strategy  Validate that when we have variable A set to a specific
    *                 data type that we coerce and receive back the correct value
    *                 and Class type.
    *
@@ -151,7 +151,7 @@
    *
    *                 Exclude: BigDecimal
    *
-   * @since: 3.0
+   * @since 3.0
    *
    */
   @Test
@@ -247,10 +247,10 @@
   } // End elAssignmentOperatorFloatTest
 
   /**
-   * @testName: elAssignmentOperatorDoubleTest
-   * @assertion_ids: EL:SPEC:48.1.1; EL:SPEC:48.1.2; EL:SPEC:48.1.3;
+   * @testName  elAssignmentOperatorDoubleTest
+   * @assertion_ids  EL:SPEC:48.1.1; EL:SPEC:48.1.2; EL:SPEC:48.1.3;
    *                 EL:SPEC:48.1.4
-   * @test_Strategy: Validate that when we have variable A set to a specific
+   * @test_Strategy  Validate that when we have variable A set to a specific
    *                 data type that we coerce and receive back the correct value
    *                 and Class type.
    *
@@ -263,7 +263,7 @@
    *
    *                 Exclude: BigDecimal, Float
    *
-   * @since: 3.0
+   * @since 3.0
    *
    */
   @Test
@@ -360,10 +360,10 @@
   } // End elAssignmentOperatorDoubleTest
 
   /**
-   * @testName: elAssignmentOperatorBigIntegerTest
-   * @assertion_ids: EL:SPEC:48.1.1; EL:SPEC:48.1.2; EL:SPEC:48.1.3;
+   * @testName  elAssignmentOperatorBigIntegerTest
+   * @assertion_ids  EL:SPEC:48.1.1; EL:SPEC:48.1.2; EL:SPEC:48.1.3;
    *                 EL:SPEC:48.1.4
-   * @test_Strategy: Validate that when we have variable A set to a specific
+   * @test_Strategy  Validate that when we have variable A set to a specific
    *                 data type that we coerce and receive back the correct value
    *                 and Class type.
    *
@@ -376,7 +376,7 @@
    *
    *                 Exclude: BigDecimal, Float, Double
    *
-   * @since: 3.0
+   * @since 3.0
    *
    */
   @Test
@@ -448,10 +448,10 @@
   } // End elAssignmentOperatorBigIntegerTest
 
   /**
-   * @testName: elAssignmentOperatorIntegerTest
-   * @assertion_ids: EL:SPEC:48.1.1; EL:SPEC:48.1.2; EL:SPEC:48.1.3;
+   * @testName  elAssignmentOperatorIntegerTest
+   * @assertion_ids  EL:SPEC:48.1.1; EL:SPEC:48.1.2; EL:SPEC:48.1.3;
    *                 EL:SPEC:48.1.4
-   * @test_Strategy: Validate that when we have variable A set to a specific
+   * @test_Strategy  Validate that when we have variable A set to a specific
    *                 data type that we coerce and receive back the correct value
    *                 and Class type.
    *
@@ -464,7 +464,7 @@
    *
    *                 Exclude: BigDecimal, BigInteger, Float, Double
    *
-   * @since: 3.0
+   * @since 3.0
    *
    */
   @Test
@@ -537,10 +537,10 @@
   } // End elAssignmentOperatorIntegerTest
 
   /**
-   * @testName: elAssignmentOperatorLongTest
-   * @assertion_ids: EL:SPEC:48.1.1; EL:SPEC:48.1.2; EL:SPEC:48.1.3;
+   * @testName  elAssignmentOperatorLongTest
+   * @assertion_ids  EL:SPEC:48.1.1; EL:SPEC:48.1.2; EL:SPEC:48.1.3;
    *                 EL:SPEC:48.1.4
-   * @test_Strategy: Validate that when we have variable A set to a specific
+   * @test_Strategy  Validate that when we have variable A set to a specific
    *                 data type that we coerce and receive back the correct value
    *                 and Class type.
    *
@@ -553,7 +553,7 @@
    *
    *                 Exclude: BigDecimal, BigInteger, Float, Double, Integer
    *
-   * @since: 3.0
+   * @since 3.0
    *
    */
   @Test
@@ -627,10 +627,10 @@
   } // End elAssignmentOperatorLongTest
 
   /**
-   * @testName: elAssignmentOperatorShortTest
-   * @assertion_ids: EL:SPEC:48.1.1; EL:SPEC:48.1.2; EL:SPEC:48.1.3;
+   * @testName  elAssignmentOperatorShortTest
+   * @assertion_ids  EL:SPEC:48.1.1; EL:SPEC:48.1.2; EL:SPEC:48.1.3;
    *                 EL:SPEC:48.1.4
-   * @test_Strategy: Validate that when we have variable A set to a specific
+   * @test_Strategy  Validate that when we have variable A set to a specific
    *                 data type that we coerce and receive back the correct value
    *                 and Class type.
    *
@@ -644,7 +644,7 @@
    *                 Exclude: BigDecimal, BigInteger, Float, Double, Integer,
    *                 Long
    *
-   * @since: 3.0
+   * @since 3.0
    *
    */
   @Test
@@ -719,10 +719,10 @@
   } // End elAssignmentOperatorShortTest
 
   /**
-   * @testName: elAssignmentOperatorByteTest
-   * @assertion_ids: EL:SPEC:48.1.1; EL:SPEC:48.1.2; EL:SPEC:48.1.3;
+   * @testName  elAssignmentOperatorByteTest
+   * @assertion_ids  EL:SPEC:48.1.1; EL:SPEC:48.1.2; EL:SPEC:48.1.3;
    *                 EL:SPEC:48.1.4
-   * @test_Strategy: Validate that when we have variable A set to a specific
+   * @test_Strategy  Validate that when we have variable A set to a specific
    *                 data type that we coerce and receive back the correct value
    *                 and Class type.
    *
@@ -736,7 +736,7 @@
    *                 Exclude: BigDecimal, BigInteger, Float, Double, Integer,
    *                 Long, Short
    *
-   * @since: 3.0
+   * @since 3.0
    *
    */
   @Test
@@ -812,10 +812,10 @@
   } // End elAssignmentOperatorByteTest
 
   /**
-   * @testName: elAssignmentOperatorNullTest
-   * @assertion_ids: EL:SPEC:48.1.1; EL:SPEC:48.1.2; EL:SPEC:48.1.3;
+   * @testName  elAssignmentOperatorNullTest
+   * @assertion_ids  EL:SPEC:48.1.1; EL:SPEC:48.1.2; EL:SPEC:48.1.3;
    *                 EL:SPEC:48.1.4
-   * @test_Strategy: Validate that when we have variable A set to a specific
+   * @test_Strategy  Validate that when we have variable A set to a specific
    *                 data type that we coerce and receive back the correct value
    *                 and Class type.
    *
@@ -825,7 +825,7 @@
    *
    *                 Variable B - null
    *
-   * @since: 3.0
+   * @since 3.0
    *
    */
   @Test
@@ -865,10 +865,10 @@
   } // End elAssignmentOperatorNullTest
 
   /**
-   * @testName: elAssignmentOperatorMultiTest
-   * @assertion_ids: EL:SPEC:48.1.1; EL:SPEC:48.1.2; EL:SPEC:48.1.3;
+   * @testName  elAssignmentOperatorMultiTest
+   * @assertion_ids  EL:SPEC:48.1.1; EL:SPEC:48.1.2; EL:SPEC:48.1.3;
    *                 EL:SPEC:48.1.4
-   * @test_Strategy: Validate that when we have variable A set to a specific
+   * @test_Strategy  Validate that when we have variable A set to a specific
    *                 data type that we coerce and receive back the correct value
    *                 and Class type.
    *
@@ -882,7 +882,7 @@
    *
    *                 Excluded: none
    *
-   * @since: 3.0
+   * @since 3.0
    *
    */
   @Test
diff --git a/tck/src/main/java/ee/jakarta/tck/el/spec/binaryoperator/ELClientIT.java b/tck/src/main/java/ee/jakarta/tck/el/spec/binaryoperator/ELClientIT.java
index 8afc82d..ffef1de 100644
--- a/tck/src/main/java/ee/jakarta/tck/el/spec/binaryoperator/ELClientIT.java
+++ b/tck/src/main/java/ee/jakarta/tck/el/spec/binaryoperator/ELClientIT.java
@@ -57,9 +57,9 @@
 
 
   /**
-   * @testName: elNullOperandAddTest
-   * @assertion_ids: EL:SPEC:17.1
-   * @test_Strategy: Validate that if both of the operands in an EL "+"
+   * @testName  elNullOperandAddTest
+   * @assertion_ids  EL:SPEC:17.1
+   * @test_Strategy  Validate that if both of the operands in an EL "+"
    *                 (addition) operation are null, the result is (Long) 0.
    */
   @Test
@@ -87,9 +87,9 @@
   }
 
   /**
-   * @testName: elNullOperandSubtractTest
-   * @assertion_ids: EL:SPEC:17.1
-   * @test_Strategy: Validate that if both of the operands in an EL "-"
+   * @testName  elNullOperandSubtractTest
+   * @assertion_ids  EL:SPEC:17.1
+   * @test_Strategy  Validate that if both of the operands in an EL "-"
    *                 (subtraction) operation are null, the result is (Long) 0.
    */
   @Test
@@ -117,9 +117,9 @@
   }
 
   /**
-   * @testName: elNullOperandMultiplyTest
-   * @assertion_ids: EL:SPEC:17.1
-   * @test_Strategy: Validate that if both of the operands in an EL "*"
+   * @testName  elNullOperandMultiplyTest
+   * @assertion_ids  EL:SPEC:17.1
+   * @test_Strategy  Validate that if both of the operands in an EL "*"
    *                 (multiplication) operation are null, the result is (Long)
    *                 0.
    */
@@ -148,9 +148,9 @@
   }
 
   /**
-   * @testName: elNullOperandDivisionTest
-   * @assertion_ids: EL:SPEC:18.1
-   * @test_Strategy: Validate that if both of the operands in an EL "/"
+   * @testName  elNullOperandDivisionTest
+   * @assertion_ids  EL:SPEC:18.1
+   * @test_Strategy  Validate that if both of the operands in an EL "/"
    *                 (division) operation are null, the result is (Long) 0.
    *
    */
@@ -179,9 +179,9 @@
   }
 
   /**
-   * @testName: elNullOperandModulusTest
-   * @assertion_ids: EL:SPEC:19.1
-   * @test_Strategy: Validate that if both of the operands in an EL "%" (mod)
+   * @testName  elNullOperandModulusTest
+   * @assertion_ids  EL:SPEC:19.1
+   * @test_Strategy  Validate that if both of the operands in an EL "%" (mod)
    *                 operation are null, the result is (Long) 0.
    *
    */
@@ -210,9 +210,9 @@
   }
 
   /**
-   * @testName: elBigDecimalAddTest
-   * @assertion_ids: EL:SPEC:17.2.1
-   * @test_Strategy: Validate that if one of the operands in an EL "+"
+   * @testName  elBigDecimalAddTest
+   * @assertion_ids  EL:SPEC:17.2.1
+   * @test_Strategy  Validate that if one of the operands in an EL "+"
    *                 (addition) operation is a BigDecimal, the result is coerced
    *                 to BigDecimal and is the sum of the operands.
    *
@@ -233,9 +233,9 @@
   }
 
   /**
-   * @testName: elBigDecimalSubtractTest
-   * @assertion_ids: EL:SPEC:17.2.2
-   * @test_Strategy: Validate that if one of the operands in an EL "-"
+   * @testName  elBigDecimalSubtractTest
+   * @assertion_ids  EL:SPEC:17.2.2
+   * @test_Strategy  Validate that if one of the operands in an EL "-"
    *                 (subtraction) operation is a BigDecimal, the result is
    *                 coerced to BigDecimal and is the difference of the
    *                 operands.
@@ -257,9 +257,9 @@
   }
 
   /**
-   * @testName: elBigDecimalMultiplyTest
-   * @assertion_ids: EL:SPEC:17.2.3
-   * @test_Strategy: Validate that if one of the operands in an EL "*"
+   * @testName  elBigDecimalMultiplyTest
+   * @assertion_ids  EL:SPEC:17.2.3
+   * @test_Strategy  Validate that if one of the operands in an EL "*"
    *                 (multiplication) operation is a BigDecimal, the result is
    *                 coerced to BigDecimal and is the product of the operands.
    *
@@ -280,9 +280,9 @@
   }
 
   /**
-   * @testName: elBigDecimalDivisionTest
-   * @assertion_ids: EL:SPEC:18.2
-   * @test_Strategy: Validate that if one of the operands in an EL "/" (div)
+   * @testName  elBigDecimalDivisionTest
+   * @assertion_ids  EL:SPEC:18.2
+   * @test_Strategy  Validate that if one of the operands in an EL "/" (div)
    *                 operation is a BigDecimal, the result is coerced to
    *                 BigDecimal and is the quotient of the operands.
    *
@@ -303,9 +303,9 @@
   }
 
   /**
-   * @testName: elBigDecimalModulusTest
-   * @assertion_ids: EL:SPEC:19.2
-   * @test_Strategy: Validate that if one of the operands in an EL "%" (mod)
+   * @testName  elBigDecimalModulusTest
+   * @assertion_ids  EL:SPEC:19.2
+   * @test_Strategy  Validate that if one of the operands in an EL "%" (mod)
    *                 operation is a BigDecimal, the result is coerced to Double
    *                 and is the remainder of the quotient of the operands.
    *
@@ -326,9 +326,9 @@
   }
 
   /**
-   * @testName: elBigIntegerAddTest
-   * @assertion_ids: EL:SPEC:17.4.1
-   * @test_Strategy: Validate that if one of the operands in an EL "+"
+   * @testName  elBigIntegerAddTest
+   * @assertion_ids  EL:SPEC:17.4.1
+   * @test_Strategy  Validate that if one of the operands in an EL "+"
    *                 (addition) operation is a BigInteger, the result is coerced
    *                 to BigInteger and is the sum of the operands.
    *
@@ -347,9 +347,9 @@
   }
 
   /**
-   * @testName: elBigIntegerSubtractTest
-   * @assertion_ids: EL:SPEC:17.4.2
-   * @test_Strategy: Validate that if one of the operands in an EL "-"
+   * @testName  elBigIntegerSubtractTest
+   * @assertion_ids  EL:SPEC:17.4.2
+   * @test_Strategy  Validate that if one of the operands in an EL "-"
    *                 (subtraction) operation is a BigInteger, the result is
    *                 coerced to BigInteger and is the difference of the
    *                 operands.
@@ -369,9 +369,9 @@
   }
 
   /**
-   * @testName: elBigIntegerMultiplyTest
-   * @assertion_ids: EL:SPEC:17.4.3
-   * @test_Strategy: Validate that if one of the operands in an EL "*" operation
+   * @testName  elBigIntegerMultiplyTest
+   * @assertion_ids  EL:SPEC:17.4.3
+   * @test_Strategy  Validate that if one of the operands in an EL "*" operation
    *                 is a BigInteger, the result is coerced to BigInteger and is
    *                 the product of the operands.
    *
@@ -389,9 +389,9 @@
   }
 
   /**
-   * @testName: elBigIntegerDivisionTest
-   * @assertion_ids: EL:SPEC:18.2
-   * @test_Strategy: Validate that if one of the operands in an EL "/" (div)
+   * @testName  elBigIntegerDivisionTest
+   * @assertion_ids  EL:SPEC:18.2
+   * @test_Strategy  Validate that if one of the operands in an EL "/" (div)
    *                 operation is a BigInteger, the result is coerced to
    *                 BigDecimal and is the quotient of the operands.
    *
@@ -409,9 +409,9 @@
   }
 
   /**
-   * @testName: elBigIntegerModulusTest
-   * @assertion_ids: EL:SPEC:19.3
-   * @test_Strategy: Validate that if one of the operands in an EL "%" (mod)
+   * @testName  elBigIntegerModulusTest
+   * @assertion_ids  EL:SPEC:19.3
+   * @test_Strategy  Validate that if one of the operands in an EL "%" (mod)
    *                 operation is a BigInteger, the result is coerced to
    *                 BigInteger and is the remainder of the quotient of the
    *                 operands.
@@ -430,9 +430,9 @@
   }
 
   /**
-   * @testName: elFloatAddTest
-   * @assertion_ids: EL:SPEC:17.3.1; EL:SPEC:17.3.2
-   * @test_Strategy: Validate that if one of the operands in an EL "+"
+   * @testName  elFloatAddTest
+   * @assertion_ids  EL:SPEC:17.3.1; EL:SPEC:17.3.2
+   * @test_Strategy  Validate that if one of the operands in an EL "+"
    *                 (addition) operation is a Float, the result is coerced to
    *                 Double and is the sum of the operands.
    *
@@ -454,9 +454,9 @@
   }
 
   /**
-   * @testName: elFloatSubtractTest
-   * @assertion_ids: EL:SPEC:17.3.1; EL:SPEC:17.3.2
-   * @test_Strategy: Validate that if one of the operands in an EL "-"
+   * @testName  elFloatSubtractTest
+   * @assertion_ids  EL:SPEC:17.3.1; EL:SPEC:17.3.2
+   * @test_Strategy  Validate that if one of the operands in an EL "-"
    *                 (subtraction) operation is a Float, the result is coerced
    *                 to Double and is the difference of the operands.
    *
@@ -478,9 +478,9 @@
   }
 
   /**
-   * @testName: elFloatMultiplyTest
-   * @assertion_ids: EL:SPEC:17.3.1; EL:SPEC:17.3.2
-   * @test_Strategy: Validate that if one of the operands in an EL "*"
+   * @testName  elFloatMultiplyTest
+   * @assertion_ids  EL:SPEC:17.3.1; EL:SPEC:17.3.2
+   * @test_Strategy  Validate that if one of the operands in an EL "*"
    *                 (multiplication) operation is a Float, the result is
    *                 coerced to Double and is the product of the operands.
    *
@@ -502,9 +502,9 @@
   }
 
   /**
-   * @testName: elFloatDivisionTest
-   * @assertion_ids: EL:SPEC:18.2; EL:SPEC:18.3
-   * @test_Strategy: Validate that if one of the operands in an EL "/" (div)
+   * @testName  elFloatDivisionTest
+   * @assertion_ids  EL:SPEC:18.2; EL:SPEC:18.3
+   * @test_Strategy  Validate that if one of the operands in an EL "/" (div)
    *                 operation is a Float, the result is coerced to Double and
    *                 is the quotient of the operands.
    *
@@ -526,9 +526,9 @@
   }
 
   /**
-   * @testName: elFloatModulusTest
-   * @assertion_ids: EL:SPEC:19.2
-   * @test_Strategy: Validate that if one of the operands in an EL "%" (mod)
+   * @testName  elFloatModulusTest
+   * @assertion_ids  EL:SPEC:19.2
+   * @test_Strategy  Validate that if one of the operands in an EL "%" (mod)
    *                 operation is a Float, the result is coerced to Double and
    *                 is the remainder of the quotient of the operands.
    *
@@ -550,9 +550,9 @@
   }
 
   /**
-   * @testName: elDoubleAddTest
-   * @assertion_ids: EL:SPEC:17.3.1; EL:SPEC:17.3.2
-   * @test_Strategy: Validate that if one of the operands in an EL "+"
+   * @testName  elDoubleAddTest
+   * @assertion_ids  EL:SPEC:17.3.1; EL:SPEC:17.3.2
+   * @test_Strategy  Validate that if one of the operands in an EL "+"
    *                 (addition) operation is a Double, the result is coerced to
    *                 Double and is the sum of the operands.
    *
@@ -571,9 +571,9 @@
   }
 
   /**
-   * @testName: elDoubleSubtractTest
-   * @assertion_ids: EL:SPEC:17.3.1; EL:SPEC:17.3.2
-   * @test_Strategy: Validate that if one of the operands in an EL "-"
+   * @testName  elDoubleSubtractTest
+   * @assertion_ids  EL:SPEC:17.3.1; EL:SPEC:17.3.2
+   * @test_Strategy  Validate that if one of the operands in an EL "-"
    *                 (subtraction) operation is a Double, the result is coerced
    *                 to Double and is the difference of the operands.
    *
@@ -592,9 +592,9 @@
   }
 
   /**
-   * @testName: elDoubleMultiplyTest
-   * @assertion_ids: EL:SPEC:17.3.1; EL:SPEC:17.3.2
-   * @test_Strategy: Validate that if one of the operands in an EL "*"
+   * @testName  elDoubleMultiplyTest
+   * @assertion_ids  EL:SPEC:17.3.1; EL:SPEC:17.3.2
+   * @test_Strategy  Validate that if one of the operands in an EL "*"
    *                 (multiplication) operation is a Double, the result is
    *                 coerced to Double and is the product of the operands.
    *
@@ -613,9 +613,9 @@
   }
 
   /**
-   * @testName: elDoubleDivisionTest
-   * @assertion_ids: EL:SPEC:18.2; EL:SPEC:18.3
-   * @test_Strategy: Validate that if one of the operands in an EL "/" (div)
+   * @testName  elDoubleDivisionTest
+   * @assertion_ids  EL:SPEC:18.2; EL:SPEC:18.3
+   * @test_Strategy  Validate that if one of the operands in an EL "/" (div)
    *                 operation is a Double, the result is coerced to Double and
    *                 is the quotient of the operands.
    *
@@ -634,9 +634,9 @@
   }
 
   /**
-   * @testName: elDoubleModulusTest
-   * @assertion_ids: EL:SPEC:19.2
-   * @test_Strategy: Validate that if one of the operands in an EL "%" (mod)
+   * @testName  elDoubleModulusTest
+   * @assertion_ids  EL:SPEC:19.2
+   * @test_Strategy  Validate that if one of the operands in an EL "%" (mod)
    *                 operation is a Double, the result is coerced to Double and
    *                 is the remainder of the quotient of the operands.
    *
@@ -654,9 +654,9 @@
   }
 
   /**
-   * @testName: elNumericStringSubtractTest
-   * @assertion_ids: EL:SPEC:17.3.1; EL:SPEC:17.3.2
-   * @test_Strategy: Validate that if one of the operands in an EL "-"
+   * @testName  elNumericStringSubtractTest
+   * @assertion_ids  EL:SPEC:17.3.1; EL:SPEC:17.3.2
+   * @test_Strategy  Validate that if one of the operands in an EL "-"
    *                 (subtraction) operation is a numeric string, the result is
    *                 coerced to Double and is the difference of the operands.
    *
@@ -676,9 +676,9 @@
   }
 
   /**
-   * @testName: elNumericStringMultiplyTest
-   * @assertion_ids: EL:SPEC:17.3.1; EL:SPEC:17.3.2
-   * @test_Strategy: Validate that if one of the operands in an EL "*"
+   * @testName  elNumericStringMultiplyTest
+   * @assertion_ids  EL:SPEC:17.3.1; EL:SPEC:17.3.2
+   * @test_Strategy  Validate that if one of the operands in an EL "*"
    *                 (multiplication) operation is a numeric string, the result
    *                 is coerced to Double and is the product of the operands.
    *
@@ -698,9 +698,9 @@
   }
 
   /**
-   * @testName: elNumericStringDivisionTest
-   * @assertion_ids: EL:SPEC:18.2; EL:SPEC:18.3
-   * @test_Strategy: Validate that if one of the operands in an EL "/" (div)
+   * @testName  elNumericStringDivisionTest
+   * @assertion_ids  EL:SPEC:18.2; EL:SPEC:18.3
+   * @test_Strategy  Validate that if one of the operands in an EL "/" (div)
    *                 operation is a numeric string, the result is coerced to
    *                 Double and is the quotient of the operands.
    *
@@ -720,9 +720,9 @@
   }
 
   /**
-   * @testName: elNumericStringModulusTest
-   * @assertion_ids: EL:SPEC:19.2
-   * @test_Strategy: Validate that if one of the operands in an EL "%" (mod)
+   * @testName  elNumericStringModulusTest
+   * @assertion_ids  EL:SPEC:19.2
+   * @test_Strategy  Validate that if one of the operands in an EL "%" (mod)
    *                 operation is a numeric string, the result is coerced to
    *                 Double and is the remainder of the quotient of the
    *                 operands.
@@ -743,9 +743,9 @@
   }
 
   /**
-   * @testName: elLongAddTest
-   * @assertion_ids: EL:SPEC:17.5
-   * @test_Strategy: Validate that if one of the operands in an EL "+"
+   * @testName  elLongAddTest
+   * @assertion_ids  EL:SPEC:17.5
+   * @test_Strategy  Validate that if one of the operands in an EL "+"
    *                 (addition) operation is a Long, the result is coerced to
    *                 Long and is the sum of the operands.
    *
@@ -763,9 +763,9 @@
   }
 
   /**
-   * @testName: elLongSubtractTest
-   * @assertion_ids: EL:SPEC:17.5
-   * @test_Strategy: Validate that if one of the operands in an EL "-"
+   * @testName  elLongSubtractTest
+   * @assertion_ids  EL:SPEC:17.5
+   * @test_Strategy  Validate that if one of the operands in an EL "-"
    *                 (subtraction) operation is a Long, the result is coerced to
    *                 Long and is the difference of the operands.
    *
@@ -783,9 +783,9 @@
   }
 
   /**
-   * @testName: elLongMultiplyTest
-   * @assertion_ids: EL:SPEC:17.5
-   * @test_Strategy: Validate that if one of the operands in an EL "*"
+   * @testName  elLongMultiplyTest
+   * @assertion_ids  EL:SPEC:17.5
+   * @test_Strategy  Validate that if one of the operands in an EL "*"
    *                 (multiplication) operation is a Long, the result is coerced
    *                 to Long and is the product of the operands.
    *
@@ -803,9 +803,9 @@
   }
 
   /**
-   * @testName: elLongDivisionTest
-   * @assertion_ids: EL:SPEC:18.3
-   * @test_Strategy: Validate that if one of the operands in an EL "/" (div)
+   * @testName  elLongDivisionTest
+   * @assertion_ids  EL:SPEC:18.3
+   * @test_Strategy  Validate that if one of the operands in an EL "/" (div)
    *                 operation is a Long, the result is coerced to Double and is
    *                 the quotient of the operands.
    *
@@ -823,9 +823,9 @@
   }
 
   /**
-   * @testName: elLongModulusTest
-   * @assertion_ids: EL:SPEC:19.4
-   * @test_Strategy: Validate that if one of the operands in an EL "%" (mod)
+   * @testName  elLongModulusTest
+   * @assertion_ids  EL:SPEC:19.4
+   * @test_Strategy  Validate that if one of the operands in an EL "%" (mod)
    *                 operation is a Long, the result is coerced to Long and is
    *                 the remainder of the quotient of the operands.
    *
@@ -843,9 +843,9 @@
   }
 
   /**
-   * @testName: elIntegerAddTest
-   * @assertion_ids: EL:SPEC:17.5
-   * @test_Strategy: Validate that if one of the operands in an EL "+"
+   * @testName  elIntegerAddTest
+   * @assertion_ids  EL:SPEC:17.5
+   * @test_Strategy  Validate that if one of the operands in an EL "+"
    *                 (addition) operation is a Integer, the result is coerced to
    *                 Long and is the sum of the operands.
    *
@@ -863,9 +863,9 @@
   }
 
   /**
-   * @testName: elIntegerSubtractTest
-   * @assertion_ids: EL:SPEC:17.5
-   * @test_Strategy: Validate that if one of the operands in an EL "-"
+   * @testName  elIntegerSubtractTest
+   * @assertion_ids  EL:SPEC:17.5
+   * @test_Strategy  Validate that if one of the operands in an EL "-"
    *                 (subtraction) operation is a Integer, the result is coerced
    *                 to Long and is the difference of the operands.
    *
@@ -882,9 +882,9 @@
   }
 
   /**
-   * @testName: elIntegerMultiplyTest
-   * @assertion_ids: EL:SPEC:17.5
-   * @test_Strategy: Validate that if one of the operands in an EL "*"
+   * @testName  elIntegerMultiplyTest
+   * @assertion_ids  EL:SPEC:17.5
+   * @test_Strategy  Validate that if one of the operands in an EL "*"
    *                 (multiplication) operation is a Integer, the result is
    *                 coerced to Long and is the product of the operands.
    *
@@ -902,9 +902,9 @@
   }
 
   /**
-   * @testName: elIntegerDivisionTest
-   * @assertion_ids: EL:SPEC:18.3
-   * @test_Strategy: Validate that if one of the operands in an EL "/" (div)
+   * @testName  elIntegerDivisionTest
+   * @assertion_ids  EL:SPEC:18.3
+   * @test_Strategy  Validate that if one of the operands in an EL "/" (div)
    *                 operation is a Integer, the result is coerced to Double and
    *                 is the quotient of the operands.
    *
@@ -922,9 +922,9 @@
   }
 
   /**
-   * @testName: elIntegerModulusTest
-   * @assertion_ids: EL:SPEC:19.4
-   * @test_Strategy: Validate that if one of the operands in an EL "%" (mod)
+   * @testName  elIntegerModulusTest
+   * @assertion_ids  EL:SPEC:19.4
+   * @test_Strategy  Validate that if one of the operands in an EL "%" (mod)
    *                 operation is a Integer, the result is coerced to Long and
    *                 is the remainder of the quotient of the operands.
    *
@@ -942,9 +942,9 @@
   }
 
   /**
-   * @testName: elShortAddTest
-   * @assertion_ids: EL:SPEC:17.5
-   * @test_Strategy: Validate that if one of the operands in an EL "+"
+   * @testName  elShortAddTest
+   * @assertion_ids  EL:SPEC:17.5
+   * @test_Strategy  Validate that if one of the operands in an EL "+"
    *                 (addition) operation is a Short, the result is coerced to
    *                 Long and is the sum of the operands.
    *
@@ -961,9 +961,9 @@
   }
 
   /**
-   * @testName: elShortSubtractTest
-   * @assertion_ids: EL:SPEC:17.5
-   * @test_Strategy: Validate that if one of the operands in an EL "-"
+   * @testName  elShortSubtractTest
+   * @assertion_ids  EL:SPEC:17.5
+   * @test_Strategy  Validate that if one of the operands in an EL "-"
    *                 (subtraction) operation is a Short, the result is coerced
    *                 to Long and is the difference of the operands.
    *
@@ -980,9 +980,9 @@
   }
 
   /**
-   * @testName: elShortMultiplyTest
-   * @assertion_ids: EL:SPEC:17.5
-   * @test_Strategy: Validate that if one of the operands in an EL "*"
+   * @testName  elShortMultiplyTest
+   * @assertion_ids  EL:SPEC:17.5
+   * @test_Strategy  Validate that if one of the operands in an EL "*"
    *                 (multiplication) operation is a Short, the result is
    *                 coerced to Long and is the product of the operands.
    *
@@ -999,9 +999,9 @@
   }
 
   /**
-   * @testName: elShortDivisionTest
-   * @assertion_ids: EL:SPEC:18.3
-   * @test_Strategy: Validate that if one of the operands in an EL "/" (div)
+   * @testName  elShortDivisionTest
+   * @assertion_ids  EL:SPEC:18.3
+   * @test_Strategy  Validate that if one of the operands in an EL "/" (div)
    *                 operation is a Short, the result is coerced to Double and
    *                 is the quotient of the operands.
    *
@@ -1018,9 +1018,9 @@
   }
 
   /**
-   * @testName: elShortModulusTest
-   * @assertion_ids: EL:SPEC:19.4
-   * @test_Strategy: Validate that if one of the operands in an EL "%" (mod)
+   * @testName  elShortModulusTest
+   * @assertion_ids  EL:SPEC:19.4
+   * @test_Strategy  Validate that if one of the operands in an EL "%" (mod)
    *                 operation is a Short, the result is coerced to Long and is
    *                 the remainder of the quotient of the operands.
    *
@@ -1037,9 +1037,9 @@
   }
 
   /**
-   * @testName: elByteAddTest
-   * @assertion_ids: EL:SPEC:17.5
-   * @test_Strategy: Validate that if both operands in an EL "+" (addition)
+   * @testName  elByteAddTest
+   * @assertion_ids  EL:SPEC:17.5
+   * @test_Strategy  Validate that if both operands in an EL "+" (addition)
    *                 operation are Bytes, the result is coerced to Long and is
    *                 the sum of the operands.
    *
@@ -1056,9 +1056,9 @@
   }
 
   /**
-   * @testName: elByteSubtractTest
-   * @assertion_ids: EL:SPEC:17.5
-   * @test_Strategy: Validate that if both operands in an EL "-" (subtraction)
+   * @testName  elByteSubtractTest
+   * @assertion_ids  EL:SPEC:17.5
+   * @test_Strategy  Validate that if both operands in an EL "-" (subtraction)
    *                 operation are Bytes, the result is coerced to Long and is
    *                 the difference of the operands.
    *
@@ -1075,9 +1075,9 @@
   }
 
   /**
-   * @testName: elByteMultiplyTest
-   * @assertion_ids: EL:SPEC:17.5
-   * @test_Strategy: Validate that if both operands in an EL "*"
+   * @testName  elByteMultiplyTest
+   * @assertion_ids  EL:SPEC:17.5
+   * @test_Strategy  Validate that if both operands in an EL "*"
    *                 (multiplication) operation are Bytes, the result is coerced
    *                 to Long and is the product of the operands.
    *
@@ -1094,9 +1094,9 @@
   }
 
   /**
-   * @testName: elByteDivisionTest
-   * @assertion_ids: EL:SPEC:18.3
-   * @test_Strategy: Validate that if both operands in an EL "/" (div) operation
+   * @testName  elByteDivisionTest
+   * @assertion_ids  EL:SPEC:18.3
+   * @test_Strategy  Validate that if both operands in an EL "/" (div) operation
    *                 are Bytes, the result is coerced to Double and is the
    *                 quotient of the operands.
    *
@@ -1113,9 +1113,9 @@
   }
 
   /**
-   * @testName: elByteModulusTest
-   * @assertion_ids: EL:SPEC:19.4
-   * @test_Strategy: Validate that if both operands in an EL "%" (mod) operation
+   * @testName  elByteModulusTest
+   * @assertion_ids  EL:SPEC:19.4
+   * @test_Strategy  Validate that if both operands in an EL "%" (mod) operation
    *                 are Bytes, the result is coerced to Long and is the
    *                 remainder of the quotient of the operands.
    *
@@ -1132,12 +1132,12 @@
   }
 
   /**
-   * @testName: elBooleanAndTest
-   * @assertion_ids: EL:SPEC:23.1; EL:SPEC:24.2.1
-   * @test_Strategy: Validate that if one of the operands in an EL "&&", "and"
+   * @testName  elBooleanAndTest
+   * @assertion_ids  EL:SPEC:23.1; EL:SPEC:24.2.1
+   * @test_Strategy  Validate that if one of the operands in an EL "&amp;&amp;", "and"
    *                 operation is a Boolean, the result is coerced to Boolean.
    *
-   *                 Equations tested: Boolean && String Boolean && Boolean
+   *                 Equations tested: Boolean &amp;&amp; String Boolean &amp;&amp; Boolean
    *                 Boolean and String Boolean and Boolean
    *
    */
@@ -1153,9 +1153,9 @@
   }
 
   /**
-   * @testName: elBooleanOrTest
-   * @assertion_ids: EL:SPEC:23.1; EL:SPEC:24.2.1
-   * @test_Strategy: Validate that if one of the operands in an EL "||", "or"
+   * @testName  elBooleanOrTest
+   * @assertion_ids  EL:SPEC:23.1; EL:SPEC:24.2.1
+   * @test_Strategy  Validate that if one of the operands in an EL "||", "or"
    *                 operation is a Boolean, the result is coerced to Boolean.
    *
    *                 Equations tested: Boolean || String Boolean || Boolean
diff --git a/tck/src/main/java/ee/jakarta/tck/el/spec/coercion/ELClientIT.java b/tck/src/main/java/ee/jakarta/tck/el/spec/coercion/ELClientIT.java
index 0179e01..52a8a14 100644
--- a/tck/src/main/java/ee/jakarta/tck/el/spec/coercion/ELClientIT.java
+++ b/tck/src/main/java/ee/jakarta/tck/el/spec/coercion/ELClientIT.java
@@ -99,9 +99,9 @@
   }
 
   /**
-   * @testName: positivePrimitiveToBoxedTest
-   * @assertion_ids: EL:SPEC:37.3; EL:SPEC:37.5
-   * @test_Strategy: Validate that the primitive types - boolean - char - byte -
+   * @testName  positivePrimitiveToBoxedTest
+   * @assertion_ids  EL:SPEC:37.3; EL:SPEC:37.5
+   * @test_Strategy  Validate that the primitive types - boolean - char - byte -
    *                 short - int - long - float - double when found in an
    *                 expression are converted to the appropriate 'boxed' types.
    */
@@ -165,9 +165,9 @@
   }
 
   /**
-   * @testName: positiveBoxedToPrimitiveTest
-   * @assertion_ids: EL:SPEC:37.3; EL:SPEC:37.4
-   * @test_Strategy: Validate that the 'boxed' types - Boolean - Character -
+   * @testName  positiveBoxedToPrimitiveTest
+   * @assertion_ids  EL:SPEC:37.3; EL:SPEC:37.4
+   * @test_Strategy  Validate that the 'boxed' types - Boolean - Character -
    *                 Byte - Short - Integer - Long - Float - Double when found
    *                 in an expression are converted to the appropriate primitive
    *                 types. Note that the conversion takes place in
@@ -264,9 +264,9 @@
   }
 
   /**
-   * @testName: positiveElBooleanCoercionTest
-   * @assertion_ids: EL:SPEC:41.1; EL:SPEC:41.2; EL:SPEC:41.3
-   * @test_Strategy: Validate that null, the empty String, a Boolean, and a
+   * @testName  positiveElBooleanCoercionTest
+   * @assertion_ids  EL:SPEC:41.1; EL:SPEC:41.2; EL:SPEC:41.3
+   * @test_Strategy  Validate that null, the empty String, a Boolean, and a
    *                 proper String argument to Boolean.valueOf() are coerced to
    *                 the expected Boolean values.
    */
@@ -304,9 +304,9 @@
   }
 
   /**
-   * @testName: negativeElBooleanCoercionTest
-   * @assertion_ids: EL:SPEC:41.4; EL:JAVADOC:112
-   * @test_Strategy: Validate that an error occurs when an attempt is made to
+   * @testName  negativeElBooleanCoercionTest
+   * @assertion_ids  EL:SPEC:41.4; EL:JAVADOC:112
+   * @test_Strategy  Validate that an error occurs when an attempt is made to
    *                 coerce an invalid class to a Boolean. The coercion is
    *                 performed with a call to ValueExpression.getValue(), which
    *                 must throw an ELException.
@@ -333,9 +333,9 @@
   }
 
   /**
-   * @testName: elPrimitiveToStringCoercionTest
-   * @assertion_ids: EL:SPEC:38.1; EL:SPEC:38.2; EL:SPEC:38.3; EL:SPEC:38.5
-   * @test_Strategy: Validate that the following types coerce to type of String
+   * @testName  elPrimitiveToStringCoercionTest
+   * @assertion_ids  EL:SPEC:38.1; EL:SPEC:38.2; EL:SPEC:38.3; EL:SPEC:38.5
+   * @test_Strategy  Validate that the following types coerce to type of String
    *                 and the expected String value is returned.
    *
    *                 Types: String(), boolean, null, byte, char, short, int,
@@ -477,9 +477,9 @@
   }
 
   /**
-   * @testName: elWrapperToStringCoercionTest
-   * @assertion_ids: EL:SPEC:38.5
-   * @test_Strategy: Validate that the following types coerce to type of String
+   * @testName  elWrapperToStringCoercionTest
+   * @assertion_ids  EL:SPEC:38.5
+   * @test_Strategy  Validate that the following types coerce to type of String
    *                 and the expected String value is returned.
    *
    *                 Types: Boolean, Byte, Character, Short, Integer, Long,
@@ -595,9 +595,9 @@
   }
 
   /**
-   * @testName: positiveElCharacterCoercionTest
-   * @assertion_ids: EL:SPEC:40.1; EL:SPEC:40.2; EL:SPEC:40.4; EL:SPEC:40.5
-   * @test_Strategy: Validate that the following types coerce to type of
+   * @testName  positiveElCharacterCoercionTest
+   * @assertion_ids  EL:SPEC:40.1; EL:SPEC:40.2; EL:SPEC:40.4; EL:SPEC:40.5
+   * @test_Strategy  Validate that the following types coerce to type of
    *                 Character and the expected Character value is returned.
    *
    *                 Types: String, Byte, Character, Short, Integer, Long,
@@ -724,9 +724,9 @@
   }
 
   /**
-   * @testName: negativeElCharacterCoercionTest
-   * @assertion_ids: EL:SPEC:40.3; EL:JAVADOC:112
-   * @test_Strategy: Validate that an error occurs when an attempt is made to
+   * @testName  negativeElCharacterCoercionTest
+   * @assertion_ids  EL:SPEC:40.3; EL:JAVADOC:112
+   * @test_Strategy  Validate that an error occurs when an attempt is made to
    *                 coerce a boolean to Character. The coercion is performed
    *                 with a call to ValueExpression.getValue(), which must throw
    *                 an ELException.
@@ -755,10 +755,10 @@
   }
 
   /**
-   * @testName: negativeElNumberCoercionTest
-   * @assertion_ids: EL:SPEC:39.3; EL:SPEC:39.6.1.1; EL:SPEC:39.7.3;
+   * @testName  negativeElNumberCoercionTest
+   * @assertion_ids  EL:SPEC:39.3; EL:SPEC:39.6.1.1; EL:SPEC:39.7.3;
    *                 EL:SPEC:39.7.1; EL:SPEC:39.6.1.1; EL:JAVADOC:112
-   * @test_Strategy: Validate that an error occurs when an attempt is made to
+   * @test_Strategy  Validate that an error occurs when an attempt is made to
    *                 coerce a: -Boolean to Number. -String to a Number. The
    *                 coercion is performed with a call to
    *                 ValueExpression.getValue(), which must throw an
@@ -815,9 +815,9 @@
   }
 
   /**
-   * @testName: elNullToNumberCoercionTest
-   * @assertion_ids: EL:SPEC:39.1
-   * @test_Strategy: Validate that when null or empty String is given. That the
+   * @testName  elNullToNumberCoercionTest
+   * @assertion_ids  EL:SPEC:39.1
+   * @test_Strategy  Validate that when null or empty String is given. That the
    *                 returned value is 0. Test this for the Following types.
    *
    *                 Types: Byte, Short, Integer, Long, Float, Double,
@@ -876,9 +876,9 @@
   }
 
   /**
-   * @testName: elNumberToByteCoercionTest
-   * @assertion_ids: EL:SPEC:39.5.3
-   * @test_Strategy: Validate that following Number types coerce to Byte and the
+   * @testName  elNumberToByteCoercionTest
+   * @assertion_ids  EL:SPEC:39.5.3
+   * @test_Strategy  Validate that following Number types coerce to Byte and the
    *                 expected Byte value is returned.
    *
    *                 Types: Byte, Short, Integer, Long, Float, Double,
@@ -950,9 +950,9 @@
   }
 
   /**
-   * @testName: elNumberToShortCoercionTest
-   * @assertion_ids: EL:SPEC:39.5.4
-   * @test_Strategy: Validate that following Number types coerce to Short and
+   * @testName  elNumberToShortCoercionTest
+   * @assertion_ids  EL:SPEC:39.5.4
+   * @test_Strategy  Validate that following Number types coerce to Short and
    *                 the expected Short value is returned.
    *
    *                 Types: Byte, Short, Integer, Long, Float, Double,
@@ -1024,9 +1024,9 @@
   }
 
   /**
-   * @testName: elNumberToIntegerCoercionTest
-   * @assertion_ids: EL:SPEC:39.5.5
-   * @test_Strategy: Validate that following Number types coerce to Integer and
+   * @testName  elNumberToIntegerCoercionTest
+   * @assertion_ids  EL:SPEC:39.5.5
+   * @test_Strategy  Validate that following Number types coerce to Integer and
    *                 the expected Integer value is returned.
    *
    *                 Types: Byte, Short, Integer, Long, Float, Double,
@@ -1097,9 +1097,9 @@
   }
 
   /**
-   * @testName: elNumberToLongCoercionTest
-   * @assertion_ids: EL:SPEC:39.5.6
-   * @test_Strategy: Validate that following Number types coerce to Long and the
+   * @testName  elNumberToLongCoercionTest
+   * @assertion_ids  EL:SPEC:39.5.6
+   * @test_Strategy  Validate that following Number types coerce to Long and the
    *                 expected Long value is returned.
    *
    *                 Types: Byte, Short, Integer, Long, Float, Double,
@@ -1171,9 +1171,9 @@
   }
 
   /**
-   * @testName: elNumberToFloatCoercionTest
-   * @assertion_ids: EL:SPEC:39.5.7
-   * @test_Strategy: Validate that following Number types coerce to Float and
+   * @testName  elNumberToFloatCoercionTest
+   * @assertion_ids  EL:SPEC:39.5.7
+   * @test_Strategy  Validate that following Number types coerce to Float and
    *                 the expected Float value is returned.
    *
    *                 Types: Byte, Short, Integer, Long, Float, Double,
@@ -1245,9 +1245,9 @@
   }
 
   /**
-   * @testName: elNumberToDoubleCoercionTest
-   * @assertion_ids: EL:SPEC:39.5.8
-   * @test_Strategy: Validate that following Number types coerce to Double and
+   * @testName  elNumberToDoubleCoercionTest
+   * @assertion_ids  EL:SPEC:39.5.8
+   * @test_Strategy  Validate that following Number types coerce to Double and
    *                 the expected Double value is returned.
    *
    *                 Types: Byte, Short, Integer, Long, Float, Double,
@@ -1319,9 +1319,9 @@
   }
 
   /**
-   * @testName: elStringToNumberCoercionTest
-   * @assertion_ids: EL:SPEC:39.6.1.2; EL:SPEC:39.7.2; EL:SPEC:39.7.4
-   * @test_Strategy: Validate that String types coerce to the following types
+   * @testName  elStringToNumberCoercionTest
+   * @assertion_ids  EL:SPEC:39.6.1.2; EL:SPEC:39.7.2; EL:SPEC:39.7.4
+   * @test_Strategy  Validate that String types coerce to the following types
    *                 and the expected value is returned.
    *
    *                 Types: Byte, Short, Integer, Long, Float, Double,
@@ -1394,9 +1394,9 @@
   }
 
   /**
-   * @testName: elCharacterToNumberCoercionTest
-   * @assertion_ids: EL:SPEC:39.2
-   * @test_Strategy: Validate that Character types coerce to the following types
+   * @testName  elCharacterToNumberCoercionTest
+   * @assertion_ids  EL:SPEC:39.2
+   * @test_Strategy  Validate that Character types coerce to the following types
    *                 and the expected value is returned.
    *
    *                 Types: Byte, Short, Integer, Long, Float, Double,
@@ -1468,9 +1468,9 @@
   }
 
   /**
-   * @testName: elNumberToBigIntegerCoercionTest
-   * @assertion_ids: EL:SPEC:39.5.1.1; EL:SPEC:39.5.1.2
-   * @test_Strategy: Validate that following Number types coerce to BigInteger
+   * @testName  elNumberToBigIntegerCoercionTest
+   * @assertion_ids  EL:SPEC:39.5.1.1; EL:SPEC:39.5.1.2
+   * @test_Strategy  Validate that following Number types coerce to BigInteger
    *                 and the expected value is returned.
    *
    *                 Types: Byte, Short, Integer, Long, Float, Double,
@@ -1543,9 +1543,9 @@
   }
 
   /**
-   * @testName: elNumberToBigDecimalCoercionTest
-   * @assertion_ids: EL:SPEC:39.5.2.1; EL:SPEC:39.5.2.2
-   * @test_Strategy: Validate that following Number types coerce to BigDecimal
+   * @testName  elNumberToBigDecimalCoercionTest
+   * @assertion_ids  EL:SPEC:39.5.2.1; EL:SPEC:39.5.2.2
+   * @test_Strategy  Validate that following Number types coerce to BigDecimal
    *                 and the expected value is returned.
    *
    *                 Types: Byte, Short, Integer, Long, Float, Double,
@@ -1617,9 +1617,9 @@
   }
 
   /**
-   * @testName: elCoerceToEnumTypeTest
-   * @assertion_ids: EL:SPEC:42.1; EL:SPEC:42.2; EL:SPEC:42.3; EL:SPEC:42.4
-   * @test_Strategy: Validate that - an assignable enum type can be coerced to
+   * @testName  elCoerceToEnumTypeTest
+   * @assertion_ids  EL:SPEC:42.1; EL:SPEC:42.2; EL:SPEC:42.3; EL:SPEC:42.4
+   * @test_Strategy  Validate that - an assignable enum type can be coerced to
    *                 an enum - coercing a null value to an enum type returns a
    *                 null value - coercing an empty string to an enum type
    *                 returns a null value - coercing a string to an enum is
@@ -1683,10 +1683,10 @@
   }
 
   /**
-   * @testName: elCoerceToArrayTest
-   * @assertion_ids: EL:SPEC:81.1; EL:SPEC:81.2; EL:SPEC:81.3; EL:SPEC:81.4;
+   * @testName  elCoerceToArrayTest
+   * @assertion_ids  EL:SPEC:81.1; EL:SPEC:81.2; EL:SPEC:81.3; EL:SPEC:81.4;
    *                 EL:SPEC:81.5
-   * @test_Strategy: Validate that - coercing a null to an array returns a null
+   * @test_Strategy  Validate that - coercing a null to an array returns a null
    *                 value, coercing an array of type T returns an array of type
    *                 T, coercing an array coerces each member of the array to
    *                 the expected type, coercing an array where at least one
@@ -1771,9 +1771,9 @@
 
 
   /**
-   * @testName: elCoerceLambdaExpressionToFunctionalInterfaceTest
-   * @assertion_ids: EL:SPEC:79.1; EL:SPEC:79.2; EL:SPEC:79.3
-   * @test_Strategy: Validate that - a lambda expression can be coerced to a
+   * @testName  elCoerceLambdaExpressionToFunctionalInterfaceTest
+   * @assertion_ids  EL:SPEC:79.1; EL:SPEC:79.2; EL:SPEC:79.3
+   * @test_Strategy  Validate that - a lambda expression can be coerced to a
    *                 functional interface invocation if the parameter types
    *                 match or can be made to match via the standard coercion
    *                 rules.
@@ -1884,9 +1884,9 @@
   }
 
   /**
-   * @testName: elCoerceToOtherTypeTest
-   * @assertion_ids: EL:SPEC:43.1; EL:SPEC:43.2
-   * @test_Strategy: Validate that - an assignable "other" type can be coerced
+   * @testName  elCoerceToOtherTypeTest
+   * @assertion_ids  EL:SPEC:43.1; EL:SPEC:43.2
+   * @test_Strategy  Validate that - an assignable "other" type can be coerced
    *                 to an "other" type. We coerce an instance of the class
    *                 java.sql.Time to its parent class java.util.Date. -
    *                 coercing a null value to an "other" type returns a null
diff --git a/tck/src/main/java/ee/jakarta/tck/el/spec/collectionoperators/ELClientIT.java b/tck/src/main/java/ee/jakarta/tck/el/spec/collectionoperators/ELClientIT.java
index 5f8b06b..4122114 100644
--- a/tck/src/main/java/ee/jakarta/tck/el/spec/collectionoperators/ELClientIT.java
+++ b/tck/src/main/java/ee/jakarta/tck/el/spec/collectionoperators/ELClientIT.java
@@ -60,15 +60,15 @@
 
 
   /**
-   * @testName: elCollectionMapFilterTest
+   * @testName  elCollectionMapFilterTest
    *
-   * @assertion_ids: EL:SPEC:53; EL:SPEC:53.1; EL:SPEC:53.2; EL:SPEC:53.3;
+   * @assertion_ids  EL:SPEC:53; EL:SPEC:53.1; EL:SPEC:53.2; EL:SPEC:53.3;
    *                 EL:SPEC:59; EL:SPEC:59.1; EL:SPEC:58.1; EL:SPEC:58.2
    *
-   * @test_Strategy: Test to make sure the 'map'& "filter' operator works
+   * @test_Strategy  Test to make sure the 'map'&amp; "filter' operator works
    *                 properly.
    *
-   * @since: 3.0
+   * @since 3.0
    *
    */
   @Test
@@ -92,13 +92,13 @@
   } // End elCollectionMapFilterTest
 
   /**
-   * @testName: elCollectionMinTest
+   * @testName  elCollectionMinTest
    *
-   * @assertion_ids: EL:SPEC:72; EL:SPEC:72.1; EL:SPEC:72.2
+   * @assertion_ids  EL:SPEC:72; EL:SPEC:72.1; EL:SPEC:72.2
    *
-   * @test_Strategy: Test to make sure the 'min' operator works properly.
+   * @test_Strategy  Test to make sure the 'min' operator works properly.
    *
-   * @since: 3.0
+   * @since 3.0
    *
    */
   @Test
@@ -120,13 +120,13 @@
   } // End elCollectionMinTest()
 
   /**
-   * @testName: elCollectionMaxTest
+   * @testName  elCollectionMaxTest
    *
-   * @assertion_ids: EL:SPEC:71; EL:SPEC:71.1; EL:SPEC:71.2
+   * @assertion_ids  EL:SPEC:71; EL:SPEC:71.1; EL:SPEC:71.2
    *
-   * @test_Strategy: Test to make sure the 'max' operator works properly.
+   * @test_Strategy  Test to make sure the 'max' operator works properly.
    *
-   * @since: 3.0
+   * @since 3.0
    *
    */
   @Test
@@ -147,13 +147,13 @@
   } // End elCollectionMaxTest()
 
   /**
-   * @testName: elCollectionDistinctTest
+   * @testName  elCollectionDistinctTest
    *
-   * @assertion_ids: EL:SPEC:61; EL:SPEC:61.1
+   * @assertion_ids  EL:SPEC:61; EL:SPEC:61.1
    *
-   * @test_Strategy: Test to make sure the 'distinct' operator works properly.
+   * @test_Strategy  Test to make sure the 'distinct' operator works properly.
    *
-   * @since: 3.0
+   * @since 3.0
    *
    */
   @Test
@@ -167,13 +167,13 @@
   } // End elCollectionDistinctTest()
 
   /**
-   * @testName: elCollectionForEachTest
+   * @testName  elCollectionForEachTest
    *
-   * @assertion_ids: EL:SPEC:63; EL:SPEC:63.1
+   * @assertion_ids  EL:SPEC:63; EL:SPEC:63.1
    *
-   * @test_Strategy: Test to make sure the 'forEach' operator works properly.
+   * @test_Strategy  Test to make sure the 'forEach' operator works properly.
    *
-   * @since: 3.0
+   * @since 3.0
    *
    */
   @Test
@@ -189,14 +189,14 @@
   } // End elCollectionForEachTest()
 
   /**
-   * @testName: elCollectionFindFirstTest
+   * @testName  elCollectionFindFirstTest
    *
-   * @assertion_ids: EL:SPEC:78; EL:SPEC:78.1; EL:SPEC:62; EL:SPEC:62.1;
+   * @assertion_ids  EL:SPEC:78; EL:SPEC:78.1; EL:SPEC:62; EL:SPEC:62.1;
    *                 EL:SPEC:62.2
    *
-   * @test_Strategy: Test to make sure the 'findFirst' operator works properly.
+   * @test_Strategy  Test to make sure the 'findFirst' operator works properly.
    *
-   * @since: 3.0
+   * @since 3.0
    *
    */
   @Test
@@ -211,13 +211,13 @@
   } // End elCollectionFindFirstTest()
 
   /**
-   * @testName: elCollectionLimitTest
+   * @testName  elCollectionLimitTest
    *
-   * @assertion_ids: EL:SPEC:66; EL:SPEC:66.1
+   * @assertion_ids  EL:SPEC:66; EL:SPEC:66.1
    *
-   * @test_Strategy: Test to make sure the 'limit' operator works properly.
+   * @test_Strategy  Test to make sure the 'limit' operator works properly.
    *
-   * @since: 3.0
+   * @since 3.0
    *
    */
   @Test
@@ -244,11 +244,11 @@
   /**
    * testName: elCollectionAnyMatchTest
    *
-   * @assertion_ids: EL:SPEC:75; EL:SPEC:75.1
+   * @assertion_ids  EL:SPEC:75; EL:SPEC:75.1
    *
-   * @test_Strategy: Test to make sure the 'anyMatch' operator works properly.
+   * @test_Strategy  Test to make sure the 'anyMatch' operator works properly.
    *
-   * @since: 3.0
+   * @since 3.0
    *
    *         Bug 20438221 : Commented the test for now
    */
@@ -266,11 +266,11 @@
   /**
    * testName: elCollectionNoneMatchTest
    *
-   * @assertion_ids: EL:SPEC:77; EL:SPEC:77.1
+   * @assertion_ids  EL:SPEC:77; EL:SPEC:77.1
    *
-   * @test_Strategy: Test to make sure the 'noneMatch' operator works properly.
+   * @test_Strategy  Test to make sure the 'noneMatch' operator works properly.
    *
-   * @since: 3.0
+   * @since 3.0
    *
    *         Bug 20438221 : Commented the test for now
    */
@@ -288,11 +288,11 @@
   /**
    * testName: elCollectionAllMatchTest
    *
-   * @assertion_ids: EL:SPEC:76; EL:SPEC:76.1
+   * @assertion_ids  EL:SPEC:76; EL:SPEC:76.1
    *
-   * @test_Strategy: Test to make sure the 'allMatch' operator works properly.
+   * @test_Strategy  Test to make sure the 'allMatch' operator works properly.
    *
-   * @since: 3.0
+   * @since 3.0
    *
    *         Bug 20438221 : Commented the test for now.
    */
@@ -308,13 +308,13 @@
   } // End elCollectionAllMatchTest()
 
   /**
-   * @testName: elCollectionSumTest
+   * @testName  elCollectionSumTest
    *
-   * @assertion_ids: EL:SPEC:74; EL:SPEC:74.1
+   * @assertion_ids  EL:SPEC:74; EL:SPEC:74.1
    *
-   * @test_Strategy: Test to make sure the 'sum' operator works properly.
+   * @test_Strategy  Test to make sure the 'sum' operator works properly.
    *
-   * @since: 3.0
+   * @since 3.0
    *
    */
   @Test
@@ -329,13 +329,13 @@
   } // End elCollectionSumTest()
 
   /**
-   * @testName: elCollectionCountTest
+   * @testName  elCollectionCountTest
    *
-   * @assertion_ids: EL:SPEC:79; EL:SPEC:79.1
+   * @assertion_ids  EL:SPEC:79; EL:SPEC:79.1
    *
-   * @test_Strategy: Test to make sure the 'count' operator works properly.
+   * @test_Strategy  Test to make sure the 'count' operator works properly.
    *
-   * @since: 3.0
+   * @since 3.0
    *
    */
   @Test
@@ -347,13 +347,13 @@
   } // End elCollectionCountTest()
 
   /**
-   * @testName: elCollectionAverageTest
+   * @testName  elCollectionAverageTest
    *
-   * @assertion_ids: EL:SPEC:73; EL:SPEC:73.1
+   * @assertion_ids  EL:SPEC:73; EL:SPEC:73.1
    *
-   * @test_Strategy: Test to make sure the 'average' operator works properly.
+   * @test_Strategy  Test to make sure the 'average' operator works properly.
    *
-   * @since: 3.0
+   * @since 3.0
    *
    */
   @Test
@@ -367,13 +367,13 @@
   } // End elCollectionAverageTest()
 
   /**
-   * @testName: elCollectionToArrayTest
+   * @testName  elCollectionToArrayTest
    *
-   * @assertion_ids: EL:SPEC:68; EL:SPEC:68.1
+   * @assertion_ids  EL:SPEC:68; EL:SPEC:68.1
    *
-   * @test_Strategy: Test to make sure the 'toArray' operator works properly.
+   * @test_Strategy  Test to make sure the 'toArray' operator works properly.
    *
-   * @since: 3.0
+   * @since 3.0
    *
    */
   @Test
@@ -393,14 +393,14 @@
   }// End elCollectionToArrayTest()
 
   /**
-   * @testName: elCollectionReduceTest
+   * @testName  elCollectionReduceTest
    *
-   * @assertion_ids: EL:SPEC:70; EL:SPEC:70.1; EL:SPEC:70.2; EL:SPEC:56.2;
+   * @assertion_ids  EL:SPEC:70; EL:SPEC:70.1; EL:SPEC:70.2; EL:SPEC:56.2;
    *                 EL:SPEC:56.3
    *
-   * @test_Strategy: Test to make sure the 'reduce' operator works properly.
+   * @test_Strategy  Test to make sure the 'reduce' operator works properly.
    *
-   * @since: 3.0
+   * @since 3.0
    *
    */
   @Test
@@ -423,13 +423,13 @@
   }// End elCollectionReduceTest()
 
   /**
-   * @testName: elCollectionSubStreamTest
+   * @testName  elCollectionSubStreamTest
    *
-   * @assertion_ids: EL:SPEC:67; EL:SPEC:67.1; EL:SPEC:67.2
+   * @assertion_ids  EL:SPEC:67; EL:SPEC:67.1; EL:SPEC:67.2
    *
-   * @test_Strategy: Test to make sure the 'substream' operator works properly.
+   * @test_Strategy  Test to make sure the 'substream' operator works properly.
    *
-   * @since: 3.0
+   * @since 3.0
    *
    */
   @Test
@@ -446,13 +446,13 @@
   }// End elCollectionSubStreamTest()
 
   /**
-   * @testName: elCollectionPeekTest
+   * @testName  elCollectionPeekTest
    *
-   * @assertion_ids: EL:SPEC:4; EL:SPEC:64.1
+   * @assertion_ids  EL:SPEC:4; EL:SPEC:64.1
    *
-   * @test_Strategy: Test to make sure the 'peek' operator works properly.
+   * @test_Strategy  Test to make sure the 'peek' operator works properly.
    *
-   * @since: 3.0
+   * @since 3.0
    *
    */
   @Test
@@ -468,13 +468,13 @@
   }// End elCollectionPeekTest()
 
   /**
-   * @testName: elCollectionFlatMapTest
+   * @testName  elCollectionFlatMapTest
    *
-   * @assertion_ids: EL:SPEC:60; EL:SPEC:60.1
+   * @assertion_ids  EL:SPEC:60; EL:SPEC:60.1
    *
-   * @test_Strategy: Test to make sure the 'flatMap' operator works properly.
+   * @test_Strategy  Test to make sure the 'flatMap' operator works properly.
    *
-   * @since: 3.0
+   * @since 3.0
    *
    */
   @Test
@@ -495,9 +495,9 @@
 
 
   /**
-   * @testName: elCollectionSetLiteralTest
-   * @assertion_ids: EL:SPEC:51; EL:SPEC:51.1; EL:SPEC:51.2; EL:SPEC:51.3;
-   * @test+Strategy: Verify that a value in a literal List constructed from
+   * @testName  elCollectionSetLiteralTest
+   * @assertion_ids  EL:SPEC:51; EL:SPEC:51.1; EL:SPEC:51.2; EL:SPEC:51.3;
+   * @test_Strategy  Verify that a value in a literal List constructed from
    *                 variables can be retrieved using the associated index.
    */
   @Test
@@ -531,9 +531,9 @@
 
 
   /**
-   * @testName: elCollectionListLiteralTest
-   * @assertion_ids: EL:SPEC:52; EL:SPEC:52.1; EL:SPEC:52.2; EL:SPEC:52.3;
-   * @test+Strategy: Verify that a value in a literal List constructed from
+   * @testName  elCollectionListLiteralTest
+   * @assertion_ids  EL:SPEC:52; EL:SPEC:52.1; EL:SPEC:52.2; EL:SPEC:52.3;
+   * @test_Strategy  Verify that a value in a literal List constructed from
    *                 variables can be retrieved using the associated index.
    */
   @Test
@@ -567,9 +567,9 @@
 
 
   /**
-   * @testName: elCollectionMapLiteralTest
-   * @assertion_ids: EL:SPEC:53; EL:SPEC:53.1; EL:SPEC:53.2; EL:SPEC:53.3;
-   * @test+Strategy: Verify that a value in a literal Map constructed from
+   * @testName  elCollectionMapLiteralTest
+   * @assertion_ids  EL:SPEC:53; EL:SPEC:53.1; EL:SPEC:53.2; EL:SPEC:53.3;
+   * @test_Strategy  Verify that a value in a literal Map constructed from
    *                 variables can be retrieved using the associated key.
    */
   @Test
diff --git a/tck/src/main/java/ee/jakarta/tck/el/spec/concatoperator/ELClientIT.java b/tck/src/main/java/ee/jakarta/tck/el/spec/concatoperator/ELClientIT.java
index e16253e..eb33b9f 100644
--- a/tck/src/main/java/ee/jakarta/tck/el/spec/concatoperator/ELClientIT.java
+++ b/tck/src/main/java/ee/jakarta/tck/el/spec/concatoperator/ELClientIT.java
@@ -55,11 +55,11 @@
   }
 
   /**
-   * @testName: elBigDecimalConcatenationTest
+   * @testName  elBigDecimalConcatenationTest
    *
-   * @assertion_ids: EL:SPEC:38; EL:SPEC:47.1; EL:SPEC:47.1.1; EL:SPEC:47.1.2
+   * @assertion_ids  EL:SPEC:38; EL:SPEC:47.1; EL:SPEC:47.1.1; EL:SPEC:47.1.2
    *
-   * @test_Strategy: Validate that if one of the operands is BigDecimal that the
+   * @test_Strategy  Validate that if one of the operands is BigDecimal that the
    *                 operator is '+=' that both operands are coerced to type
    *                 String and concatenated.
    *
@@ -82,9 +82,9 @@
   }
 
   /**
-   * @testName: elBigIntegerConcatenationTest
-   * @assertion_ids: EL:SPEC:38; EL:SPEC:47.1; EL:SPEC:47.1.1; EL:SPEC:47.1.2
-   * @test_Strategy: Validate that if one of the operands is BigInteger that the
+   * @testName  elBigIntegerConcatenationTest
+   * @assertion_ids  EL:SPEC:38; EL:SPEC:47.1; EL:SPEC:47.1.1; EL:SPEC:47.1.2
+   * @test_Strategy  Validate that if one of the operands is BigInteger that the
    *                 operator is '+=' that both operands are coerced to type
    *                 String and concatenated.
    *
@@ -105,9 +105,9 @@
   }
 
   /**
-   * @testName: elFloatConcatenationTest
-   * @assertion_ids: EL:SPEC:38; EL:SPEC:47.1; EL:SPEC:47.1.1; EL:SPEC:47.1.2
-   * @test_Strategy: Validate when the operator is '+=' that the operands are
+   * @testName  elFloatConcatenationTest
+   * @assertion_ids  EL:SPEC:38; EL:SPEC:47.1; EL:SPEC:47.1.1; EL:SPEC:47.1.2
+   * @test_Strategy  Validate when the operator is '+=' that the operands are
    *                 coerced to Strings and the result is a Concatenation.
    *
    *                 Equations tested: Float + Double Float + Float Float +
@@ -130,9 +130,9 @@
   }
 
   /**
-   * @testName: elDoubleConcatenationTest
-   * @assertion_ids: EL:SPEC:38; EL:SPEC:47.1; EL:SPEC:47.1.1; EL:SPEC:47.1.2
-   * @test_Strategy: Validate when the operator is '+=' that the operands are
+   * @testName  elDoubleConcatenationTest
+   * @assertion_ids  EL:SPEC:38; EL:SPEC:47.1; EL:SPEC:47.1.1; EL:SPEC:47.1.2
+   * @test_Strategy  Validate when the operator is '+=' that the operands are
    *                 coerced to Strings and the result is a Concatenation.
    *
    *                 Equations tested: Double += Double Double += String
@@ -152,9 +152,9 @@
   }
 
   /**
-   * @testName: elLongConcatenationTest
-   * @assertion_ids: EL:SPEC:38; EL:SPEC:47.1; EL:SPEC:47.1.1; EL:SPEC:47.1.2
-   * @test_Strategy: Validate when the operator is '+=' that the operands are
+   * @testName  elLongConcatenationTest
+   * @assertion_ids  EL:SPEC:38; EL:SPEC:47.1; EL:SPEC:47.1.1; EL:SPEC:47.1.2
+   * @test_Strategy  Validate when the operator is '+=' that the operands are
    *                 coerced to Strings and the result is a Concatenation.
    *
    *                 Equations tested: Long += Integer Long += Long Long +=
@@ -173,9 +173,9 @@
   }
 
   /**
-   * @testName: elIntegerConcatenationTest
-   * @assertion_ids: EL:SPEC:38; EL:SPEC:47.1; EL:SPEC:47.1.1; EL:SPEC:47.1.2
-   * @test_Strategy: Validate when the operator is '+=' that the operands are
+   * @testName  elIntegerConcatenationTest
+   * @assertion_ids  EL:SPEC:38; EL:SPEC:47.1; EL:SPEC:47.1.1; EL:SPEC:47.1.2
+   * @test_Strategy  Validate when the operator is '+=' that the operands are
    *                 coerced to Strings and the result is a Concatenation.
    *
    *                 Equations tested: Integer += Integer Integer += Short
@@ -194,9 +194,9 @@
   }
 
   /**
-   * @testName: elShortConcatenationTest
-   * @assertion_ids: EL:SPEC:38; EL:SPEC:47.1; EL:SPEC:47.1.1; EL:SPEC:47.1.2
-   * @test_Strategy: Validate when the operator is '+=' that the operands are
+   * @testName  elShortConcatenationTest
+   * @assertion_ids  EL:SPEC:38; EL:SPEC:47.1; EL:SPEC:47.1.1; EL:SPEC:47.1.2
+   * @test_Strategy  Validate when the operator is '+=' that the operands are
    *                 coerced to Strings and the result is a Concatenation.
    *
    *                 Equations tested: Short += Short Short += Byte
@@ -214,9 +214,9 @@
   }
 
   /**
-   * @testName: elByteConcatenationTest
-   * @assertion_ids: EL:SPEC:38; EL:SPEC:47.1; EL:SPEC:47.1.1; EL:SPEC:47.1.2
-   * @test_Strategy: Validate that if the operator is '+=' that both operands
+   * @testName  elByteConcatenationTest
+   * @assertion_ids  EL:SPEC:38; EL:SPEC:47.1; EL:SPEC:47.1.1; EL:SPEC:47.1.2
+   * @test_Strategy  Validate that if the operator is '+=' that both operands
    *                 are coerced to String and the result is a Concatenation of
    *                 the operands.
    *
@@ -235,9 +235,9 @@
   }
 
   /**
-   * @testName: elBooleanConcatenationTest
-   * @assertion_ids: EL:SPEC:38; EL:SPEC:47.1; EL:SPEC:47.1.1; EL:SPEC:47.1.2
-   * @test_Strategy: Validate when the operator is '+=' that both operands are
+   * @testName  elBooleanConcatenationTest
+   * @assertion_ids  EL:SPEC:38; EL:SPEC:47.1; EL:SPEC:47.1.1; EL:SPEC:47.1.2
+   * @test_Strategy  Validate when the operator is '+=' that both operands are
    *                 coerced to Strings and that they result is a Concatenation
    *                 of the operands.
    *
diff --git a/tck/src/main/java/ee/jakarta/tck/el/spec/conditionaloperator/ELClientIT.java b/tck/src/main/java/ee/jakarta/tck/el/spec/conditionaloperator/ELClientIT.java
index 32b1850..261b766 100644
--- a/tck/src/main/java/ee/jakarta/tck/el/spec/conditionaloperator/ELClientIT.java
+++ b/tck/src/main/java/ee/jakarta/tck/el/spec/conditionaloperator/ELClientIT.java
@@ -53,11 +53,11 @@
 
 
   /*
-   * @testName: elConditionalStringTest
+   * @testName  elConditionalStringTest
    *
-   * @assertion_ids: EL:SPEC:26.1.1; EL:SPEC:26.1.2
+   * @assertion_ids  EL:SPEC:26.1.1; EL:SPEC:26.1.2
    *
-   * @test_Strategy: Validate that if a String is passed with the conditional
+   * @test_Strategy  Validate that if a String is passed with the conditional
    * operator, the type is coerced to Boolean and the operator is applied.
    *
    * Example Equation: ${true ? true : false}
@@ -71,11 +71,11 @@
   }
 
   /*
-   * @testName: elConditionalBooleanTest
+   * @testName  elConditionalBooleanTest
    *
-   * @assertion_ids: EL:SPEC:26.1.1; EL:SPEC:26.1.2
+   * @assertion_ids  EL:SPEC:26.1.1; EL:SPEC:26.1.2
    *
-   * @test_Strategy: Validate that if a Boolean is passed with the conditional
+   * @test_Strategy  Validate that if a Boolean is passed with the conditional
    * operator, that the operator is applied.
    *
    * Example Equation: ${true ? true : false}
diff --git a/tck/src/main/java/ee/jakarta/tck/el/spec/emptyoperator/ELClientIT.java b/tck/src/main/java/ee/jakarta/tck/el/spec/emptyoperator/ELClientIT.java
index b2332f6..6729819 100644
--- a/tck/src/main/java/ee/jakarta/tck/el/spec/emptyoperator/ELClientIT.java
+++ b/tck/src/main/java/ee/jakarta/tck/el/spec/emptyoperator/ELClientIT.java
@@ -57,11 +57,11 @@
 
 
   /*
-   * @testName: elEmptyNullTest
+   * @testName  elEmptyNullTest
    *
-   * @assertion_ids: EL:SPEC:25.1
+   * @assertion_ids  EL:SPEC:25.1
    *
-   * @test_Strategy: Validate that if "null" is passed with the Empty operator,
+   * @test_Strategy  Validate that if "null" is passed with the Empty operator,
    * the correct Boolean result is returned.
    */
   @Test
@@ -97,11 +97,11 @@
   }
 
   /*
-   * @testName: elEmptyStringTest
+   * @testName  elEmptyStringTest
    *
-   * @assertion_ids: EL:SPEC:25.2; EL:SPEC:25.6
+   * @assertion_ids  EL:SPEC:25.2; EL:SPEC:25.6
    *
-   * @test_Strategy: Validate that if a String is passed with the Empty
+   * @test_Strategy  Validate that if a String is passed with the Empty
    * operator, the correct Boolean result is returned.
    */
   @Test
@@ -114,11 +114,11 @@
   }
 
   /*
-   * @testName: elEmptyArrayTest
+   * @testName  elEmptyArrayTest
    *
-   * @assertion_ids: EL:SPEC:25.3; EL:SPEC:25.6
+   * @assertion_ids  EL:SPEC:25.3; EL:SPEC:25.6
    *
-   * @test_Strategy: Validate that if a Array is passed with the Empty operator,
+   * @test_Strategy  Validate that if a Array is passed with the Empty operator,
    * the correct Boolean result is returned.
    */
   @Test
@@ -132,11 +132,11 @@
   }
 
   /*
-   * @testName: elEmptyMapTest
+   * @testName  elEmptyMapTest
    *
-   * @assertion_ids: EL:SPEC:25.4; EL:SPEC:25.6
+   * @assertion_ids  EL:SPEC:25.4; EL:SPEC:25.6
    *
-   * @test_Strategy: Validate that if a Map is passed with the Empty operator,
+   * @test_Strategy  Validate that if a Map is passed with the Empty operator,
    * the correct Boolean result is returned.
    */
   @Test
@@ -154,11 +154,11 @@
   }
 
   /*
-   * @testName: elEmptyCollectionTest
+   * @testName  elEmptyCollectionTest
    *
-   * @assertion_ids: EL:SPEC:25.5; EL:SPEC:25.6
+   * @assertion_ids  EL:SPEC:25.5; EL:SPEC:25.6
    *
-   * @test_Strategy: Validate that if a Collection is passed with the Empty
+   * @test_Strategy  Validate that if a Collection is passed with the Empty
    * operator, the correct Boolean result is returned.
    */
   @Test
diff --git a/tck/src/main/java/ee/jakarta/tck/el/spec/lambda/ELClientIT.java b/tck/src/main/java/ee/jakarta/tck/el/spec/lambda/ELClientIT.java
index ec91853..ba30146 100644
--- a/tck/src/main/java/ee/jakarta/tck/el/spec/lambda/ELClientIT.java
+++ b/tck/src/main/java/ee/jakarta/tck/el/spec/lambda/ELClientIT.java
@@ -60,12 +60,12 @@
 
 
   /**
-   * @testName: elLambdaExprBigDecimalTest
+   * @testName  elLambdaExprBigDecimalTest
    *
-   * @assertion_ids: EL:SPEC:50.1; EL:SPEC:50.2; EL:SPEC:50.3; EL:SPEC:50.4;
+   * @assertion_ids  EL:SPEC:50.1; EL:SPEC:50.2; EL:SPEC:50.3; EL:SPEC:50.4;
    *                 EL:SPEC:50.5; EL:SPEC:50.6; EL:JAVADOC:212
    *
-   * @test_Strategy: Evaluate the Lambda Expression, making sure the coercion
+   * @test_Strategy  Evaluate the Lambda Expression, making sure the coercion
    *                 rules are followed.
    *
    *                 Operators: +, -, *, /, div, %, mod
@@ -83,7 +83,7 @@
    *
    *                 Excluded: none
    *
-   * @since: 3.0
+   * @since 3.0
    *
    */
   @Test
@@ -129,12 +129,12 @@
   } // End elLambdaExprBigDecimalTest
 
   /**
-   * @testName: elLambdaExprFloatTest
+   * @testName  elLambdaExprFloatTest
    *
-   * @assertion_ids: EL:SPEC:50.1; EL:SPEC:50.2; EL:SPEC:50.3; EL:SPEC:50.4;
+   * @assertion_ids  EL:SPEC:50.1; EL:SPEC:50.2; EL:SPEC:50.3; EL:SPEC:50.4;
    *                 EL:SPEC:50.5; EL:SPEC:50.6; EL:JAVADOC:212
    *
-   * @test_Strategy: Evaluate the Lambda Expression, making sure the coercion
+   * @test_Strategy  Evaluate the Lambda Expression, making sure the coercion
    *                 rules are followed.
    *
    *                 Operators: +, -, *, /, div, %, mod
@@ -151,7 +151,7 @@
    *
    *                 Exclude: BigDecimal
    *
-   * @since: 3.0
+   * @since 3.0
    *
    */
   @Test
@@ -236,12 +236,12 @@
   } // End elLambdaExprFloatTest
 
   /**
-   * @testName: elLambdaExprDoubleTest
+   * @testName  elLambdaExprDoubleTest
    *
-   * @assertion_ids: EL:SPEC:50.1; EL:SPEC:50.2; EL:SPEC:50.3; EL:SPEC:50.4;
+   * @assertion_ids  EL:SPEC:50.1; EL:SPEC:50.2; EL:SPEC:50.3; EL:SPEC:50.4;
    *                 EL:SPEC:50.5; EL:SPEC:50.6; EL:JAVADOC:212
    *
-   * @test_Strategy: Evaluate the Lambda Expression, making sure the coercion
+   * @test_Strategy  Evaluate the Lambda Expression, making sure the coercion
    *                 rules are followed.
    *
    *                 Operators: +, -, *, /, div, %, mod
@@ -258,7 +258,7 @@
    *
    *                 Exclude: BigDecimal, Float
    *
-   * @since: 3.0
+   * @since 3.0
    *
    */
   @Test
@@ -343,12 +343,12 @@
   } // End elLambdaExprDoubleTest
 
   /**
-   * @testName: elLambdaExprBigIntegerTest
+   * @testName  elLambdaExprBigIntegerTest
    *
-   * @assertion_ids: EL:SPEC:50.1; EL:SPEC:50.2; EL:SPEC:50.3; EL:SPEC:50.4;
+   * @assertion_ids  EL:SPEC:50.1; EL:SPEC:50.2; EL:SPEC:50.3; EL:SPEC:50.4;
    *                 EL:SPEC:50.5; EL:SPEC:50.6; EL:JAVADOC:212
    *
-   * @test_Strategy: Evaluate the Lambda Expression, making sure the coercion
+   * @test_Strategy  Evaluate the Lambda Expression, making sure the coercion
    *                 rules are followed.
    *
    *                 Operators: +, -, *, /, div, %, mod
@@ -363,7 +363,7 @@
    *
    *                 Exclude: BigDecimal, Float, Double
    *
-   * @since: 3.0
+   * @since 3.0
    *
    */
   @Test
@@ -420,12 +420,12 @@
   } // End elLambdaExprBigIntegerTest
 
   /**
-   * @testName: elLambdaExprIntegerTest
+   * @testName  elLambdaExprIntegerTest
    *
-   * @assertion_ids: EL:SPEC:50.1; EL:SPEC:50.2; EL:SPEC:50.3; EL:SPEC:50.4;
+   * @assertion_ids  EL:SPEC:50.1; EL:SPEC:50.2; EL:SPEC:50.3; EL:SPEC:50.4;
    *                 EL:SPEC:50.5; EL:SPEC:50.6; EL:JAVADOC:212
    *
-   * @test_Strategy: Evaluate the Lambda Expression, making sure the coercion
+   * @test_Strategy  Evaluate the Lambda Expression, making sure the coercion
    *                 rules are followed.
    *
    *                 Operators: +, -, *, /, div, %, mod
@@ -440,7 +440,7 @@
    *
    *                 Exclude: BigDecimal, BigInteger, Float, Double
    *
-   * @since: 3.0
+   * @since 3.0
    *
    */
   @Test
@@ -498,12 +498,12 @@
   } // End elLambdaExprIntegerTest
 
   /**
-   * @testName: elLambdaExprLongTest
+   * @testName  elLambdaExprLongTest
    *
-   * @assertion_ids: EL:SPEC:50.1; EL:SPEC:50.2; EL:SPEC:50.3; EL:SPEC:50.4;
+   * @assertion_ids  EL:SPEC:50.1; EL:SPEC:50.2; EL:SPEC:50.3; EL:SPEC:50.4;
    *                 EL:SPEC:50.5; EL:SPEC:50.6; EL:JAVADOC:212
    *
-   * @test_Strategy: Evaluate the Lambda Expression, making sure the coercion
+   * @test_Strategy  Evaluate the Lambda Expression, making sure the coercion
    *                 rules are followed.
    *
    *                 Operators: +, -, *, /, div, %, mod
@@ -518,7 +518,7 @@
    *
    *                 Exclude: BigDecimal, BigInteger, Float, Double, Integer
    *
-   * @since: 3.0
+   * @since 3.0
    *
    */
   @Test
@@ -577,12 +577,12 @@
   } // End elLambdaExprLongTest
 
   /**
-   * @testName: elLambdaExprShortTest
+   * @testName  elLambdaExprShortTest
    *
-   * @assertion_ids: EL:SPEC:50.1; EL:SPEC:50.2; EL:SPEC:50.3; EL:SPEC:50.4;
+   * @assertion_ids  EL:SPEC:50.1; EL:SPEC:50.2; EL:SPEC:50.3; EL:SPEC:50.4;
    *                 EL:SPEC:50.5; EL:SPEC:50.6; EL:JAVADOC:212
    *
-   * @test_Strategy: Evaluate the Lambda Expression, making sure the coercion
+   * @test_Strategy  Evaluate the Lambda Expression, making sure the coercion
    *                 rules are followed.
    *
    *                 Operators: +, -, *, /, div, %, mod
@@ -598,7 +598,7 @@
    *                 Exclude: BigDecimal, BigInteger, Float, Double, Integer,
    *                 Long
    *
-   * @since: 3.0
+   * @since 3.0
    *
    */
   @Test
@@ -658,12 +658,12 @@
   } // End elLambdaExprShortTest
 
   /**
-   * @testName: elLambdaExprByteTest
+   * @testName  elLambdaExprByteTest
    *
-   * @assertion_ids: EL:SPEC:50.1; EL:SPEC:50.2; EL:SPEC:50.3; EL:SPEC:50.4;
+   * @assertion_ids  EL:SPEC:50.1; EL:SPEC:50.2; EL:SPEC:50.3; EL:SPEC:50.4;
    *                 EL:SPEC:50.5; EL:SPEC:50.6; EL:JAVADOC:212
    *
-   * @test_Strategy: Evaluate the Lambda Expression, making sure the coercion
+   * @test_Strategy  Evaluate the Lambda Expression, making sure the coercion
    *                 rules are followed.
    *
    *                 Operators: +, -, *, /, div, %, mod
@@ -679,7 +679,7 @@
    *                 Exclude: BigDecimal, BigInteger, Float, Double, Integer,
    *                 Long, Short
    *
-   * @since: 3.0
+   * @since 3.0
    *
    */
   @Test
@@ -740,11 +740,11 @@
   } // End elLambdaExprByteTest
 
   /**
-   * @testName: elLambdaExprStringTest
+   * @testName  elLambdaExprStringTest
    *
-   * @assertion_ids: EL:SPEC:49.1; EL:JAVADOC:212
+   * @assertion_ids  EL:SPEC:49.1; EL:JAVADOC:212
    *
-   * @test_Strategy: Validate that when we have variable A set to a specific
+   * @test_Strategy  Validate that when we have variable A set to a specific
    *                 data type that we coerce and receive back the correct value
    *                 and Class type.
    *
@@ -756,7 +756,7 @@
    *
    *                 Variable B - String
    *
-   * @since: 3.0
+   * @since 3.0
    *
    */
   @Test
@@ -777,12 +777,12 @@
   } // End elLambdaExprStringTest
 
   /**
-   * @testName: elLambdaExprNullTest
+   * @testName  elLambdaExprNullTest
    *
-   * @assertion_ids: EL:SPEC:50.1; EL:SPEC:50.2; EL:SPEC:50.3; EL:SPEC:50.4;
+   * @assertion_ids  EL:SPEC:50.1; EL:SPEC:50.2; EL:SPEC:50.3; EL:SPEC:50.4;
    *                 EL:SPEC:50.5; EL:SPEC:50.6; EL:JAVADOC:212
    *
-   * @test_Strategy: Evaluate the Lambda Expression, making sure the coercion
+   * @test_Strategy  Evaluate the Lambda Expression, making sure the coercion
    *                 rules are followed.
    *
    *                 Operators: +, -, *, /, div, %, mod
@@ -793,7 +793,7 @@
    *
    *                 Variable B - null
    *
-   * @since: 3.0
+   * @since 3.0
    *
    */
   @Test
diff --git a/tck/src/main/java/ee/jakarta/tck/el/spec/language/ELClientIT.java b/tck/src/main/java/ee/jakarta/tck/el/spec/language/ELClientIT.java
index 53b92af..ffb16c5 100644
--- a/tck/src/main/java/ee/jakarta/tck/el/spec/language/ELClientIT.java
+++ b/tck/src/main/java/ee/jakarta/tck/el/spec/language/ELClientIT.java
@@ -63,11 +63,11 @@
   // ------------------------------------------------------------- Test Methods
 
   /*
-   * @testName: poundDollarSameMeaning1Test
+   * @testName  poundDollarSameMeaning1Test
    *
-   * @assertion_ids: EL:SPEC:1
+   * @assertion_ids  EL:SPEC:1
    *
-   * @test_Strategy: Confirm that two EL expressions, identical except for the
+   * @test_Strategy  Confirm that two EL expressions, identical except for the
    * '$' and '#' delimiters, are evaluated the same. Case 1: base is null.
    */
   @Test
@@ -99,11 +99,11 @@
   }
 
   /*
-   * @testName: poundDollarSameMeaning2Test
+   * @testName  poundDollarSameMeaning2Test
    *
-   * @assertion_ids: EL:SPEC:1
+   * @assertion_ids  EL:SPEC:1
    *
-   * @test_Strategy: Confirm that two EL expressions, identical except for the
+   * @test_Strategy  Confirm that two EL expressions, identical except for the
    * '$' and '#' delimiters, are evaluated the same. Case 2: base is non-null.
    */
   @Test
@@ -140,11 +140,11 @@
   }
 
   /*
-   * @testName: nestedEvalExpressionsTest
+   * @testName  nestedEvalExpressionsTest
    *
-   * @assertion_ids: EL:SPEC:2
+   * @assertion_ids  EL:SPEC:2
    *
-   * @test_Strategy: Verify that nested eval-expressions are illegal.
+   * @test_Strategy  Verify that nested eval-expressions are illegal.
    */
   @Test
   public void nestedEvalExpressionsTest() throws Exception {
@@ -180,11 +180,11 @@
   }
 
   /*
-   * @testName: mixedCompositeExpressionsTest
+   * @testName  mixedCompositeExpressionsTest
    *
-   * @assertion_ids: EL:SPEC:12
+   * @assertion_ids  EL:SPEC:12
    *
-   * @test_Strategy: Verify that composite expressions that mix the '$' and '#'
+   * @test_Strategy  Verify that composite expressions that mix the '$' and '#'
    * delimiters are illegal.
    */
   @Test
@@ -221,11 +221,11 @@
   }
 
   /*
-   * @testName: compositeExprEval1Test
+   * @testName  compositeExprEval1Test
    *
-   * @assertion_ids: EL:SPEC:11
+   * @assertion_ids  EL:SPEC:11
    *
-   * @test_Strategy: Verify that in a composite expression eval-expressions are
+   * @test_Strategy  Verify that in a composite expression eval-expressions are
    * coerced to Strings according to the EL type conversion rules and
    * concatenated with any intervening literal-expressions.
    */
@@ -259,11 +259,11 @@
   }
 
   /*
-   * @testName: compositeExprEval2Test
+   * @testName  compositeExprEval2Test
    *
-   * @assertion_ids: EL:SPEC:11
+   * @assertion_ids  EL:SPEC:11
    *
-   * @test_Strategy: Verify that in a composite expression eval-expressions are
+   * @test_Strategy  Verify that in a composite expression eval-expressions are
    * evaluated left to right, coerced to Strings according to the EL type
    * conversion rules, and concatenated with any intervening
    * literal-expressions.
@@ -294,11 +294,11 @@
   }
 
   /*
-   * @testName: dotAndIndexOperatorsSameTest
+   * @testName  dotAndIndexOperatorsSameTest
    *
-   * @assertion_ids: EL:SPEC:15
+   * @assertion_ids  EL:SPEC:15
    *
-   * @test_Strategy: [DotAndIndexOperatorsSame] Verify that the dot and index
+   * @test_Strategy  [DotAndIndexOperatorsSame] Verify that the dot and index
    * operators are evaluated in the same way.
    */
   @Test
@@ -328,11 +328,11 @@
   }
 
   /*
-   * @testName: elSyntaxEscapeTest
+   * @testName  elSyntaxEscapeTest
    *
-   * @assertion_ids: EL:SPEC:8
+   * @assertion_ids  EL:SPEC:8
    *
-   * @test_Strategy: [ELSyntaxEscape] Verify that the EL special characters '$'
+   * @test_Strategy  [ELSyntaxEscape] Verify that the EL special characters '$'
    * and '#' are treated as literals when preceded with '\'.
    */
   @Test
@@ -365,11 +365,11 @@
   }
 
   /*
-   * @testName: literalExprEval1Test
+   * @testName  literalExprEval1Test
    *
-   * @assertion_ids: EL:SPEC:6
+   * @assertion_ids  EL:SPEC:6
    *
-   * @test_Strategy: [LiteralExprEval] Set the value of a ValueExpression to a
+   * @test_Strategy  [LiteralExprEval] Set the value of a ValueExpression to a
    * literal String type. Verify that the value retrieved when the expression is
    * evaluated is a String equal to the value set.
    */
@@ -397,11 +397,11 @@
   }
 
   /*
-   * @testName: literalExprEval2Test
+   * @testName  literalExprEval2Test
    *
-   * @assertion_ids: EL:SPEC:6
+   * @assertion_ids  EL:SPEC:6
    *
-   * @test_Strategy: [LiteralExprEval] Coerce a String literal to a Boolean in a
+   * @test_Strategy  [LiteralExprEval] Coerce a String literal to a Boolean in a
    * ValueExpression. Verify that the value retrieved when the expression is
    * evaluated is a Boolean of the expected value.
    */
@@ -429,11 +429,11 @@
   }
 
   /*
-   * @testName: literalExprAsMethodExpr1Test
+   * @testName  literalExprAsMethodExpr1Test
    *
-   * @assertion_ids: EL:SPEC:10
+   * @assertion_ids  EL:SPEC:10
    *
-   * @test_Strategy: [LiteralExprAsMethodExpr] Verify that a literal-expression
+   * @test_Strategy  [LiteralExprAsMethodExpr] Verify that a literal-expression
    * can also be used as a method expression that returns a non-void value.
    */
   @Test
@@ -470,11 +470,11 @@
   }
 
   /*
-   * @testName: literalExprAsMethodExpr2Test
+   * @testName  literalExprAsMethodExpr2Test
    *
-   * @assertion_ids: EL:SPEC:10
+   * @assertion_ids  EL:SPEC:10
    *
-   * @test_Strategy: [LiteralExprAsMethodExpr] Verify that a literal-expression
+   * @test_Strategy  [LiteralExprAsMethodExpr] Verify that a literal-expression
    * can also be used as a method expression that returns a non-void value.
    * Verify that the standard coercion rules apply if the return type is not
    * java.lang.String.
@@ -513,11 +513,11 @@
   }
 
   /*
-   * @testName: rValueCoercion1Test
+   * @testName  rValueCoercion1Test
    *
-   * @assertion_ids: EL:SPEC:3
+   * @assertion_ids  EL:SPEC:3
    *
-   * @test_Strategy: [RValueCoercion] Set the value of a ValueExpression to a
+   * @test_Strategy  [RValueCoercion] Set the value of a ValueExpression to a
    * String type and verify that the value retrieved when the expression is
    * evaluated is also a String type.
    */
@@ -543,11 +543,11 @@
   }
 
   /*
-   * @testName: rValueCoercion2Test
+   * @testName  rValueCoercion2Test
    *
-   * @assertion_ids: EL:SPEC:3
+   * @assertion_ids  EL:SPEC:3
    *
-   * @test_Strategy: [RValueCoercion] Set the value of a ValueExpression to a
+   * @test_Strategy  [RValueCoercion] Set the value of a ValueExpression to a
    * complex type and verify that the value retrieved when the expression is
    * evaluated is a String type in accordance with the coercion rules.
    */
@@ -576,11 +576,11 @@
   }
 
   /*
-   * @testName: parseOnceEvalManyTest
+   * @testName  parseOnceEvalManyTest
    *
-   * @assertion_ids: EL:SPEC:45
+   * @assertion_ids  EL:SPEC:45
    *
-   * @test_Strategy: [ExprParsedEvalMany] Verify that once an expression is
+   * @test_Strategy  [ExprParsedEvalMany] Verify that once an expression is
    * parsed, it can be evaluated multiple times, and that the result of the
    * evaluation will be the same even when the EL context is modified.
    */
diff --git a/tck/src/main/java/ee/jakarta/tck/el/spec/literal/ELClientIT.java b/tck/src/main/java/ee/jakarta/tck/el/spec/literal/ELClientIT.java
index 7b85ba2..f6ad068 100644
--- a/tck/src/main/java/ee/jakarta/tck/el/spec/literal/ELClientIT.java
+++ b/tck/src/main/java/ee/jakarta/tck/el/spec/literal/ELClientIT.java
@@ -61,9 +61,9 @@
   // Methods
 
   /**
-   * @testName: elBooleanLiteralTest
-   * @assertion_ids: EL:SPEC:13.1
-   * @test_Strategy: Validate that the EL Boolean literal: - 'true' is evaluated
+   * @testName  elBooleanLiteralTest
+   * @assertion_ids  EL:SPEC:13.1
+   * @test_Strategy  Validate that the EL Boolean literal: - 'true' is evaluated
    *                 as expected. - 'false' is evaluated as expected.
    */
   @Test
@@ -109,9 +109,9 @@
   }
 
   /**
-   * @testName: elIntegerLiteralTest
-   * @assertion_ids: EL:SPEC:13.2
-   * @test_Strategy: Validate that the EL Integer literal with the: - '$' is
+   * @testName  elIntegerLiteralTest
+   * @assertion_ids  EL:SPEC:13.2
+   * @test_Strategy  Validate that the EL Integer literal with the: - '$' is
    *                 evaluated as expected. - '#' is evaluated as expected.
    */
   @Test
@@ -165,9 +165,9 @@
   }
 
   /**
-   * @testName: elFloatingPointLiteralTest
-   * @assertion_ids: EL:SPEC:13.3
-   * @test_Strategy: Validate that the EL Float literal with the: - '$' is
+   * @testName  elFloatingPointLiteralTest
+   * @assertion_ids  EL:SPEC:13.3
+   * @test_Strategy  Validate that the EL Float literal with the: - '$' is
    *                 evaluated as expected. - '#' is evaluated as expected.
    */
   @Test
@@ -220,9 +220,9 @@
   }
 
   /**
-   * @testName: elStringLiteralTest
-   * @assertion_ids: EL:SPEC:13.4; EL:SPEC:13.5
-   * @test_Strategy: Validate that the EL String literal with the: - '$' is
+   * @testName  elStringLiteralTest
+   * @assertion_ids  EL:SPEC:13.4; EL:SPEC:13.5
+   * @test_Strategy  Validate that the EL String literal with the: - '$' is
    *                 evaluated as expected. - '#' is evaluated as expected.
    */
   @Test
@@ -279,9 +279,9 @@
   }
 
   /**
-   * @testName: elNullLiteralTest
-   * @assertion_ids: EL:SPEC:13.6
-   * @test_Strategy: Validate that the EL 'null' literal evalutes correctly.
+   * @testName  elNullLiteralTest
+   * @assertion_ids  EL:SPEC:13.6
+   * @test_Strategy  Validate that the EL 'null' literal evalutes correctly.
    */
   @Test
   public void elNullLiteralTest() throws Exception {
@@ -320,9 +320,9 @@
   }
 
   /**
-   * @testName: elSyntaxAsLiteralTest
-   * @assertion_ids: EL:SPEC:7
-   * @test_Strategy: [ELSyntaxAsLiteral] Verify that to generate literal values
+   * @testName  elSyntaxAsLiteralTest
+   * @assertion_ids  EL:SPEC:7
+   * @test_Strategy  [ELSyntaxAsLiteral] Verify that to generate literal values
    *                 that include the character sequence "${" or "#{" a
    *                 composite expression can be used.
    */
diff --git a/tck/src/main/java/ee/jakarta/tck/el/spec/mapper/ELClientIT.java b/tck/src/main/java/ee/jakarta/tck/el/spec/mapper/ELClientIT.java
index 7ba7329..cbd4465 100644
--- a/tck/src/main/java/ee/jakarta/tck/el/spec/mapper/ELClientIT.java
+++ b/tck/src/main/java/ee/jakarta/tck/el/spec/mapper/ELClientIT.java
@@ -68,10 +68,10 @@
 
 
   /**
-   * @testName: ELFunctionBindingTest
+   * @testName  ELFunctionBindingTest
    *
-   * @assertion_ids: EL:SPEC:31
-   * @test_Strategy: [ELFunctionsBinding] Create an ELContext that uses a
+   * @assertion_ids  EL:SPEC:31
+   * @test_Strategy  [ELFunctionsBinding] Create an ELContext that uses a
    *                 non-null FunctionMapper. Create a ValueExpression from the
    *                 ELContext that references a function assigned by the
    *                 FunctionMapper. Change the function mapping in the
@@ -139,10 +139,10 @@
   }
 
   /**
-   * @testName: ELVariableBindingTest
+   * @testName  ELVariableBindingTest
    *
-   * @assertion_ids: EL:SPEC:34
-   * @test_Strategy: [ELVariablesBinding] Create an ELContext that uses a
+   * @assertion_ids  EL:SPEC:34
+   * @test_Strategy  [ELVariablesBinding] Create an ELContext that uses a
    *                 non-null VariableMapper. Create a ValueExpression from the
    *                 ELContext that references a variable assigned by the
    *                 VariableMapper. Remove the assignment from the
diff --git a/tck/src/main/java/ee/jakarta/tck/el/spec/operatorprecedence/ELClientIT.java b/tck/src/main/java/ee/jakarta/tck/el/spec/operatorprecedence/ELClientIT.java
index 2e89f09..37fb6f9 100644
--- a/tck/src/main/java/ee/jakarta/tck/el/spec/operatorprecedence/ELClientIT.java
+++ b/tck/src/main/java/ee/jakarta/tck/el/spec/operatorprecedence/ELClientIT.java
@@ -63,11 +63,11 @@
 
 
   /*
-   * @testName: elMultiPreBinaryTest
+   * @testName  elMultiPreBinaryTest
    *
-   * @assertion_ids: EL:SPEC:28
+   * @assertion_ids  EL:SPEC:28
    *
-   * @test_Strategy: Validate that the order of precedence is followed when an
+   * @test_Strategy  Validate that the order of precedence is followed when an
    * EL Expression is evaluated.
    *
    * Rules tested: "*" is evaluated before "+" "*" is evaluated before "-"
@@ -81,11 +81,11 @@
   }
 
   /*
-   * @testName: elDivPreBinaryTest
+   * @testName  elDivPreBinaryTest
    *
-   * @assertion_ids: EL:SPEC:28
+   * @assertion_ids  EL:SPEC:28
    *
-   * @test_Strategy: Validate that the order of precedence is followed when an
+   * @test_Strategy  Validate that the order of precedence is followed when an
    * EL Expression is evaluated.
    *
    * Rules tested: "div, /" is evaluated before "+" "div, /" is evaluated before
@@ -102,11 +102,11 @@
   }
 
   /*
-   * @testName: elModPreBinaryTest
+   * @testName  elModPreBinaryTest
    *
-   * @assertion_ids: EL:SPEC:28
+   * @assertion_ids  EL:SPEC:28
    *
-   * @test_Strategy: Validate that the order of precedence is followed when an
+   * @test_Strategy  Validate that the order of precedence is followed when an
    * EL Expression is evaluated.
    *
    * Rules tested: "mod, %" is evaluated before "+" "mod, %" is evaluated before
@@ -123,11 +123,11 @@
   }
 
   /*
-   * @testName: elMultiPreRelationalTest
+   * @testName  elMultiPreRelationalTest
    *
-   * @assertion_ids: EL:SPEC:28
+   * @assertion_ids  EL:SPEC:28
    *
-   * @test_Strategy: Validate that the order of precedence is followed when an
+   * @test_Strategy  Validate that the order of precedence is followed when an
    * EL Expression is evaluated.
    *
    * Rules tested: "*" is evaluated before ">" "*" is evaluated before "<" "*"
@@ -158,11 +158,11 @@
   }
 
   /*
-   * @testName: elDivPreRelationalTest
+   * @testName  elDivPreRelationalTest
    *
-   * @assertion_ids: EL:SPEC:28
+   * @assertion_ids  EL:SPEC:28
    *
-   * @test_Strategy: Validate that the order of precedence is followed when an
+   * @test_Strategy  Validate that the order of precedence is followed when an
    * EL Expression is evaluated.
    *
    * Rules tested: "div, /" is evaluated before ">" "div, /" is evaluated before
@@ -195,11 +195,11 @@
   }
 
   /*
-   * @testName: elModPreRelationalTest
+   * @testName  elModPreRelationalTest
    *
-   * @assertion_ids: EL:SPEC:28
+   * @assertion_ids  EL:SPEC:28
    *
-   * @test_Strategy: Validate that the order of precedence is followed when an
+   * @test_Strategy  Validate that the order of precedence is followed when an
    * EL Expression is evaluated.
    *
    * Rules tested: "mod, %" is evaluated before ">" "mod, %" is evaluated before
@@ -232,11 +232,11 @@
   }
 
   /*
-   * @testName: elMultiEqualPreAndTest
+   * @testName  elMultiEqualPreAndTest
    *
-   * @assertion_ids: EL:SPEC:28
+   * @assertion_ids  EL:SPEC:28
    *
-   * @test_Strategy: Validate that the order of precedence is followed when an
+   * @test_Strategy  Validate that the order of precedence is followed when an
    * EL Expression is evaluated.
    *
    * Rules tested: "*, ==" is evaluated before "&&, and"
@@ -252,11 +252,11 @@
   }
 
   /*
-   * @testName: elDivEqualPreAndTest
+   * @testName  elDivEqualPreAndTest
    *
-   * @assertion_ids: EL:SPEC:28
+   * @assertion_ids  EL:SPEC:28
    *
-   * @test_Strategy: Validate that the order of precedence is followed when an
+   * @test_Strategy  Validate that the order of precedence is followed when an
    * EL Expression is evaluated.
    *
    * Rules tested: "div, /, ==" is evaluated before "&&, and"
@@ -276,11 +276,11 @@
   }
 
   /*
-   * @testName: elModEqualPreAndTest
+   * @testName  elModEqualPreAndTest
    *
-   * @assertion_ids: EL:SPEC:28
+   * @assertion_ids  EL:SPEC:28
    *
-   * @test_Strategy: Validate that the order of precedence is followed when an
+   * @test_Strategy  Validate that the order of precedence is followed when an
    * EL Expression is evaluated.
    *
    * Rules tested: "mod, %, ==" is evaluated before "&&, and"
@@ -300,11 +300,11 @@
   }
 
   /*
-   * @testName: elMultiEqualOrCondTest
+   * @testName  elMultiEqualOrCondTest
    *
-   * @assertion_ids: EL:SPEC:28
+   * @assertion_ids  EL:SPEC:28
    *
-   * @test_Strategy: Validate that the order of precedence is followed when an
+   * @test_Strategy  Validate that the order of precedence is followed when an
    * EL Expression is evaluated.
    *
    * Rules tested: "*, ==" is evaluated before "||, or"
@@ -321,11 +321,11 @@
   }
 
   /*
-   * @testName: elDivEqualPreOrTest
+   * @testName  elDivEqualPreOrTest
    *
-   * @assertion_ids: EL:SPEC:28
+   * @assertion_ids  EL:SPEC:28
    *
-   * @test_Strategy: Validate that the order of precedence is followed when an
+   * @test_Strategy  Validate that the order of precedence is followed when an
    * EL Expression is evaluated.
    *
    * Rules tested: "div, /, ==" is evaluated before "||, or"
@@ -347,11 +347,11 @@
   }
 
   /*
-   * @testName: elModEqualPreOrTest
+   * @testName  elModEqualPreOrTest
    *
-   * @assertion_ids: EL:SPEC:28
+   * @assertion_ids  EL:SPEC:28
    *
-   * @test_Strategy: Validate that the order of precedence is followed when an
+   * @test_Strategy  Validate that the order of precedence is followed when an
    * EL Expression is evaluated.
    *
    * Rules tested: "mod, %, ==" is evaluated before "||, or"
@@ -372,11 +372,11 @@
   }
 
   /*
-   * @testName: elMultiEqualPreCondTest
+   * @testName  elMultiEqualPreCondTest
    *
-   * @assertion_ids: EL:SPEC:28
+   * @assertion_ids  EL:SPEC:28
    *
-   * @test_Strategy: Validate that the order of precedence is followed when an
+   * @test_Strategy  Validate that the order of precedence is followed when an
    * EL Expression is evaluated.
    *
    * Rules tested: "*" is evaluated before "? :"
@@ -391,11 +391,11 @@
   }
 
   /*
-   * @testName: elDivEqualPreCondTest
+   * @testName  elDivEqualPreCondTest
    *
-   * @assertion_ids: EL:SPEC:28
+   * @assertion_ids  EL:SPEC:28
    *
-   * @test_Strategy: Validate that the order of precedence is followed when an
+   * @test_Strategy  Validate that the order of precedence is followed when an
    * EL Expression is evaluated.
    *
    * Rules tested: "div, /, ==" is evaluated before "? :"
@@ -411,11 +411,11 @@
   }
 
   /*
-   * @testName: elModEqualPreCondTest
+   * @testName  elModEqualPreCondTest
    *
-   * @assertion_ids: EL:SPEC:28
+   * @assertion_ids  EL:SPEC:28
    *
-   * @test_Strategy: Validate that the order of precedence is followed when an
+   * @test_Strategy  Validate that the order of precedence is followed when an
    * EL Expression is evaluated.
    *
    * Rules tested: "mod, %, ==" is evaluated before "||, or"
@@ -430,11 +430,11 @@
   }
 
   /*
-   * @testName: elParenPreBinaryTest
+   * @testName  elParenPreBinaryTest
    *
-   * @assertion_ids: EL:SPEC:28; EL:SPEC:27
+   * @assertion_ids  EL:SPEC:28; EL:SPEC:27
    *
-   * @test_Strategy: Validate that the order of precedence is followed when an
+   * @test_Strategy  Validate that the order of precedence is followed when an
    * EL Expression is evaluated.
    *
    * Rules tested: "( )" is evaluated before "+" "( )" is evaluated before "-"
@@ -467,11 +467,11 @@
   }
 
   /*
-   * @testName: functionPrecedenceTest
+   * @testName  functionPrecedenceTest
    *
-   * @assertion_ids: EL:SPEC:29
+   * @assertion_ids  EL:SPEC:29
    *
-   * @test_Strategy: Validate that qualified functions with a namespace prefix
+   * @test_Strategy  Validate that qualified functions with a namespace prefix
    * have precedence over the operators by constructing an expression which
    * cannot be parsed due to this rule.
    */
diff --git a/tck/src/main/java/ee/jakarta/tck/el/spec/relationaloperator/ELClientIT.java b/tck/src/main/java/ee/jakarta/tck/el/spec/relationaloperator/ELClientIT.java
index a404597..604358b 100644
--- a/tck/src/main/java/ee/jakarta/tck/el/spec/relationaloperator/ELClientIT.java
+++ b/tck/src/main/java/ee/jakarta/tck/el/spec/relationaloperator/ELClientIT.java
@@ -72,9 +72,9 @@
 
 
   /**
-   * @testName: elEqualOperandLessThanOrEqualTest
-   * @assertion_ids: EL:SPEC:21.1
-   * @test_Strategy: Validate that if the operands in an EL <= or le operation
+   * @testName  elEqualOperandLessThanOrEqualTest
+   * @assertion_ids  EL:SPEC:21.1
+   * @test_Strategy  Validate that if the operands in an EL &lt;= or le operation
    *                 are equal, the result is true.
    */
   @Test
@@ -121,9 +121,9 @@
   }
 
   /**
-   * @testName: elEqualOperandGreaterThanOrEqualTest
-   * @assertion_ids: EL:SPEC:21.1
-   * @test_Strategy: Validate that if the operands in an EL >= or ge operation
+   * @testName  elEqualOperandGreaterThanOrEqualTest
+   * @assertion_ids  EL:SPEC:21.1
+   * @test_Strategy  Validate that if the operands in an EL >= or ge operation
    *                 are equal, the result is true.
    */
   @Test
@@ -170,9 +170,9 @@
   }
 
   /**
-   * @testName: elNullOperandLessThanOrEqualTest
-   * @assertion_ids: EL:SPEC:21.2
-   * @test_Strategy: Validate that if one of the operands in an EL <= or le
+   * @testName  elNullOperandLessThanOrEqualTest
+   * @assertion_ids  EL:SPEC:21.2
+   * @test_Strategy  Validate that if one of the operands in an EL &lt;= or le
    *                 operation is null, the result is false.
    */
   @Test
@@ -204,9 +204,9 @@
   }
 
   /**
-   * @testName: elNullOperandGreaterThanOrEqualTest
-   * @assertion_ids: EL:SPEC:21.2
-   * @test_Strategy: Validate that if one of the operands in an EL >= or ge
+   * @testName  elNullOperandGreaterThanOrEqualTest
+   * @assertion_ids  EL:SPEC:21.2
+   * @test_Strategy  Validate that if one of the operands in an EL >= or ge
    *                 operation is null, the result is false.
    */
   @Test
@@ -238,9 +238,9 @@
   }
 
   /**
-   * @testName: elNullOperandNotEqualTest
-   * @assertion_ids: EL:SPEC:22.2
-   * @test_Strategy: Validate that if one of the operands is null in an EL !=,
+   * @testName  elNullOperandNotEqualTest
+   * @assertion_ids  EL:SPEC:22.2
+   * @test_Strategy  Validate that if one of the operands is null in an EL !=,
    *                 ne operation return true.
    */
   @Test
@@ -273,9 +273,9 @@
   } // End elNullOperandNotEqualTest
 
   /**
-   * @testName: elNullOperandEqualTest
-   * @assertion_ids: EL:SPEC:22.2
-   * @test_Strategy: Validate that if one of the operands is null in an EL =, eq
+   * @testName  elNullOperandEqualTest
+   * @assertion_ids  EL:SPEC:22.2
+   * @test_Strategy  Validate that if one of the operands is null in an EL =, eq
    *                 operation return false.
    */
   @Test
@@ -308,17 +308,17 @@
   } // End elNullOperandEqualTest
 
   /**
-   * @testName: elBigDecimalLessThanTest
-   * @assertion_ids: EL:SPEC:21.3
-   * @test_Strategy: Validate that if one of the operands in an EL "<" or "lt"
+   * @testName  elBigDecimalLessThanTest
+   * @assertion_ids  EL:SPEC:21.3
+   * @test_Strategy  Validate that if one of the operands in an EL "&lt;" or "lt"
    *                 operation is a BigDecimal, the result is coerced to
    *                 BigDecimal and the correct boolean value is returned.
    *
-   *                 Equations tested: BigDecimal "<" & "lt" BigDecimal
-   *                 BigDecimal "<" & "lt" Double BigDecimal "<" & "lt" Float
-   *                 BigDecimal "<" & "lt" BigInteger BigDecimal "<" & "lt"
-   *                 Integer BigDecimal "<" & "lt" Long BigDecimal "<" & "lt"
-   *                 Short BigDecimal "<" & "lt" Byte
+   *                 Equations tested: BigDecimal "&lt;" &amp; "lt" BigDecimal
+   *                 BigDecimal "&lt;" &amp; "lt" Double BigDecimal "&lt;" &amp; "lt" Float
+   *                 BigDecimal "&lt;" &amp; "lt" BigInteger BigDecimal "&lt;" &amp; "lt"
+   *                 Integer BigDecimal "&lt;" &amp; "lt" Long BigDecimal "&lt;" &amp; "lt"
+   *                 Short BigDecimal "&lt;" &amp; "lt" Byte
    */
   @Test
   public void elBigDecimalLessThanTest() throws Exception {
@@ -335,17 +335,17 @@
   }
 
   /**
-   * @testName: elBigDecimalLessThanEqualTest
-   * @assertion_ids: EL:SPEC:21.1; EL:SPEC:21.3
-   * @test_Strategy: Validate that if one of the operands in an EL "<=" or "le"
+   * @testName  elBigDecimalLessThanEqualTest
+   * @assertion_ids  EL:SPEC:21.1; EL:SPEC:21.3
+   * @test_Strategy  Validate that if one of the operands in an EL "&lt;=" or "le"
    *                 operation is a BigDecimal, the result is coerced to
    *                 BigDecimal and the correct boolean value is returned.
    *
-   *                 Equations tested: BigDecimal "<=" & "le" BigDecimal
-   *                 BigDecimal "<=" & "le" Double BigDecimal "<=" & "le" Float
-   *                 BigDecimal "<=" & "le" BigInteger BigDecimal "<=" & "le"
-   *                 Integer BigDecimal "<=" & "le" Long BigDecimal "<=" & "le"
-   *                 Short BigDecimal "<=" & "le" Byte
+   *                 Equations tested: BigDecimal "&lt;=" &amp; "le" BigDecimal
+   *                 BigDecimal "&lt;=" &amp; "le" Double BigDecimal "&lt;=" &amp; "le" Float
+   *                 BigDecimal "&lt;=" &amp; "le" BigInteger BigDecimal "&lt;=" &amp; "le"
+   *                 Integer BigDecimal "&lt;=" &amp; "le" Long BigDecimal "&lt;=" &amp; "le"
+   *                 Short BigDecimal "&lt;=" &amp; "le" Byte
    */
   @Test
   public void elBigDecimalLessThanEqualTest() throws Exception {
@@ -361,17 +361,17 @@
   }
 
   /**
-   * @testName: elBigDecimalGreaterThanTest
-   * @assertion_ids: EL:SPEC:21.3
-   * @test_Strategy: Validate that if one of the operands in an EL ">" or "gt"
+   * @testName  elBigDecimalGreaterThanTest
+   * @assertion_ids  EL:SPEC:21.3
+   * @test_Strategy  Validate that if one of the operands in an EL ">" or "gt"
    *                 operation is a BigDecimal, the result is coerced to
    *                 BigDecimal and the correct boolean value is returned.
    *
-   *                 Equations tested: BigDecimal ">" & "gt" BigDecimal
-   *                 BigDecimal ">" & "gt" Double BigDecimal ">" & "gt" Float
-   *                 BigDecimal ">" & "gt" BigInteger BigDecimal ">" & "gt"
-   *                 Integer BigDecimal ">" & "gt" Long BigDecimal ">" & "gt"
-   *                 Short BigDecimal ">" & "gt" Byte
+   *                 Equations tested: BigDecimal ">" &amp; "gt" BigDecimal
+   *                 BigDecimal ">" &amp; "gt" Double BigDecimal ">" &amp; "gt" Float
+   *                 BigDecimal ">" &amp; "gt" BigInteger BigDecimal ">" &amp; "gt"
+   *                 Integer BigDecimal ">" &amp; "gt" Long BigDecimal ">" &amp; "gt"
+   *                 Short BigDecimal ">" &amp; "gt" Byte
    */
   @Test
   public void elBigDecimalGreaterThanTest() throws Exception {
@@ -388,17 +388,17 @@
   }
 
   /**
-   * @testName: elBigDecimalGreaterThanEqualTest
-   * @assertion_ids: EL:SPEC:21.1; EL:SPEC:21.3
-   * @test_Strategy: Validate that if one of the operands in an EL ">=" or "ge"
+   * @testName  elBigDecimalGreaterThanEqualTest
+   * @assertion_ids  EL:SPEC:21.1; EL:SPEC:21.3
+   * @test_Strategy  Validate that if one of the operands in an EL ">=" or "ge"
    *                 operation is a BigDecimal, the result is coerced to
    *                 BigDecimal and the correct boolean value is returned.
    *
-   *                 Equations tested: BigDecimal ">=" & "ge" BigDecimal
-   *                 BigDecimal ">=" & "ge" Double BigDecimal ">=" & "ge" Float
-   *                 BigDecimal ">=" & "ge" BigInteger BigDecimal ">=" & "ge"
-   *                 Integer BigDecimal ">=" & "ge" Long BigDecimal ">=" & "ge"
-   *                 Short BigDecimal ">=" & "ge" Byte
+   *                 Equations tested: BigDecimal ">=" &amp; "ge" BigDecimal
+   *                 BigDecimal ">=" &amp; "ge" Double BigDecimal ">=" &amp; "ge" Float
+   *                 BigDecimal ">=" &amp; "ge" BigInteger BigDecimal ">=" &amp; "ge"
+   *                 Integer BigDecimal ">=" &amp; "ge" Long BigDecimal ">=" &amp; "ge"
+   *                 Short BigDecimal ">=" &amp; "ge" Byte
    */
   @Test
   public void elBigDecimalGreaterThanEqualTest() throws Exception {
@@ -415,17 +415,17 @@
   }
 
   /**
-   * @testName: elBigDecimalEqualToTest
-   * @assertion_ids: EL:SPEC:22.1; EL:SPEC:22.3.1
-   * @test_Strategy: Validate that if one of the operands in an EL "==" or "eq"
+   * @testName  elBigDecimalEqualToTest
+   * @assertion_ids  EL:SPEC:22.1; EL:SPEC:22.3.1
+   * @test_Strategy  Validate that if one of the operands in an EL "==" or "eq"
    *                 operation is a BigDecimal, the result is coerced to
    *                 BigDecimal and the correct boolean value is returned.
    *
-   *                 Equations tested: BigDecimal "==" & "eq" BigDecimal
-   *                 BigDecimal "==" & "eq" Double BigDecimal "==" & "eq" Float
-   *                 BigDecimal "==" & "eq" BigInteger BigDecimal "==" & "eq"
-   *                 Integer BigDecimal "==" & "eq" Long BigDecimal "==" & "eq"
-   *                 Short BigDecimal "==" & "eq" Byte
+   *                 Equations tested: BigDecimal "==" &amp; "eq" BigDecimal
+   *                 BigDecimal "==" &amp; "eq" Double BigDecimal "==" &amp; "eq" Float
+   *                 BigDecimal "==" &amp; "eq" BigInteger BigDecimal "==" &amp; "eq"
+   *                 Integer BigDecimal "==" &amp; "eq" Long BigDecimal "==" &amp; "eq"
+   *                 Short BigDecimal "==" &amp; "eq" Byte
    */
   @Test
   public void elBigDecimalEqualToTest() throws Exception {
@@ -439,17 +439,17 @@
   }
 
   /**
-   * @testName: elBigDecimalNotEqualToTest
-   * @assertion_ids: EL:SPEC:22.3.2
-   * @test_Strategy: Validate that if one of the operands in an EL "!=" or "ne"
+   * @testName  elBigDecimalNotEqualToTest
+   * @assertion_ids  EL:SPEC:22.3.2
+   * @test_Strategy  Validate that if one of the operands in an EL "!=" or "ne"
    *                 operation is a BigDecimal, the result is coerced to
    *                 BigDecimal and the correct boolean value is returned.
    *
-   *                 Equations tested: BigDecimal "!=" & "ne" BigDecimal
-   *                 BigDecimal "!=" & "ne" Double BigDecimal "!=" & "ne" Float
-   *                 BigDecimal "!=" & "ne" BigInteger BigDecimal "!=" & "ne"
-   *                 Integer BigDecimal "!=" & "ne" Long BigDecimal "!=" & "ne"
-   *                 Short BigDecimal "!=" & "ne" Byte
+   *                 Equations tested: BigDecimal "!=" &amp; "ne" BigDecimal
+   *                 BigDecimal "!=" &amp; "ne" Double BigDecimal "!=" &amp; "ne" Float
+   *                 BigDecimal "!=" &amp; "ne" BigInteger BigDecimal "!=" &amp; "ne"
+   *                 Integer BigDecimal "!=" &amp; "ne" Long BigDecimal "!=" &amp; "ne"
+   *                 Short BigDecimal "!=" &amp; "ne" Byte
    */
   @Test
   public void elBigDecimalNotEqualToTest() throws Exception {
@@ -463,15 +463,15 @@
   }
 
   /**
-   * @testName: elFloatLessThanTest
-   * @assertion_ids: EL:SPEC:21.4
-   * @test_Strategy: Validate that if one of the operands in an EL "<" or "lt"
+   * @testName  elFloatLessThanTest
+   * @assertion_ids  EL:SPEC:21.4
+   * @test_Strategy  Validate that if one of the operands in an EL "&lt;" or "lt"
    *                 operation is a Float, the result is coerced to Double and
    *                 the correct boolean value is returned.
    *
-   *                 Equations tested: Float "<" & "lt" Double Float "<" & "lt"
-   *                 Float Float "<" & "lt" BigInteger Float "<" & "lt" Integer
-   *                 Float "<" & "lt" Long Float "<" & "lt" Short Float "<" &
+   *                 Equations tested: Float "&lt;" &amp; "lt" Double Float "&lt;" &amp; "lt"
+   *                 Float Float "&lt;" &amp; "lt" BigInteger Float "&lt;" &amp; "lt" Integer
+   *                 Float "&lt;" &amp; "lt" Long Float "&lt;" &amp; "lt" Short Float "&lt;" &amp;
    *                 "lt" Byte
    */
   @Test
@@ -489,16 +489,16 @@
   }
 
   /**
-   * @testName: elFloatLessThanEqualTest
-   * @assertion_ids: EL:SPEC:21.1; EL:SPEC:21.4
-   * @test_Strategy: Validate that if one of the operands in an EL "<=" or "le"
+   * @testName  elFloatLessThanEqualTest
+   * @assertion_ids  EL:SPEC:21.1; EL:SPEC:21.4
+   * @test_Strategy  Validate that if one of the operands in an EL "&lt;=" or "le"
    *                 operation is a Float, the result is coerced to Double and
    *                 the correct boolean value is returned.
    *
-   *                 Equations tested: Float "<=" & "le" Double Float "<=" &
-   *                 "le" Float Float "<=" & "le" BigInteger Float "<=" & "le"
-   *                 Integer Float "<=" & "le" Long Float "<=" & "le" Short
-   *                 Float "<=" & "le" Byte
+   *                 Equations tested: Float "&lt;=" &amp; "le" Double Float "&lt;=" &amp;
+   *                 "le" Float Float "&lt;=" &amp; "le" BigInteger Float "&lt;=" &amp; "le"
+   *                 Integer Float "&lt;=" &amp; "le" Long Float "&lt;=" &amp; "le" Short
+   *                 Float "&lt;=" &amp; "le" Byte
    */
   @Test
   public void elFloatLessThanEqualTest() throws Exception {
@@ -514,15 +514,15 @@
   }
 
   /**
-   * @testName: elFloatGreaterThanTest
-   * @assertion_ids: EL:SPEC:21.4
-   * @test_Strategy: Validate that if one of the operands in an EL ">" or "gt"
+   * @testName  elFloatGreaterThanTest
+   * @assertion_ids  EL:SPEC:21.4
+   * @test_Strategy  Validate that if one of the operands in an EL ">" or "gt"
    *                 operation is a Float, the result is coerced to Double and
    *                 the correct boolean value is returned.
    *
-   *                 Equations tested: Float ">" & "gt" Double Float ">" & "gt"
-   *                 Float Float ">" & "gt" BigInteger Float ">" & "gt" Integer
-   *                 Float ">" & "gt" Long Float ">" & "gt" Short Float ">" &
+   *                 Equations tested: Float ">" &amp; "gt" Double Float ">" &amp; "gt"
+   *                 Float Float ">" &amp; "gt" BigInteger Float ">" &amp; "gt" Integer
+   *                 Float ">" &amp; "gt" Long Float ">" &amp; "gt" Short Float ">" &amp;
    *                 "gt" Byte
    */
   @Test
@@ -540,16 +540,16 @@
   }
 
   /**
-   * @testName: elFloatGreaterThanEqualTest
-   * @assertion_ids: EL:SPEC:21.1; EL:SPEC:21.4
-   * @test_Strategy: Validate that if one of the operands in an EL ">=" or "ge"
+   * @testName  elFloatGreaterThanEqualTest
+   * @assertion_ids  EL:SPEC:21.1; EL:SPEC:21.4
+   * @test_Strategy  Validate that if one of the operands in an EL ">=" or "ge"
    *                 operation is a Float, the result is coerced to Double and
    *                 the correct boolean value is returned.
    *
-   *                 Equations tested: Float ">=" & "ge" Double Float ">=" &
-   *                 "ge" Float Float ">=" & "ge" BigInteger Float ">=" & "ge"
-   *                 Integer Float ">=" & "ge" Long Float ">=" & "ge" Short
-   *                 Float ">=" & "ge" Byte
+   *                 Equations tested: Float ">=" &amp; "ge" Double Float ">=" &amp;
+   *                 "ge" Float Float ">=" &amp; "ge" BigInteger Float ">=" &amp; "ge"
+   *                 Integer Float ">=" &amp; "ge" Long Float ">=" &amp; "ge" Short
+   *                 Float ">=" &amp; "ge" Byte
    */
   @Test
   public void elFloatGreaterThanEqualTest() throws Exception {
@@ -566,16 +566,16 @@
   }
 
   /**
-   * @testName: elFloatEqualToTest
-   * @assertion_ids: EL:SPEC:22.1; EL:SPEC:22.4
-   * @test_Strategy: Validate that if one of the operands in an EL "==" or "eq"
+   * @testName  elFloatEqualToTest
+   * @assertion_ids  EL:SPEC:22.1; EL:SPEC:22.4
+   * @test_Strategy  Validate that if one of the operands in an EL "==" or "eq"
    *                 operation is a Float, the result is coerced to Double and
    *                 the correct boolean value is returned.
    *
-   *                 Equations tested: Float "==" & "eq" Double Float "==" &
-   *                 "eq" Float Float "==" & "eq" BigInteger Float "==" & "eq"
-   *                 Integer Float "==" & "eq" Long Float "==" & "eq" Short
-   *                 Float "==" & "eq" Byte
+   *                 Equations tested: Float "==" &amp; "eq" Double Float "==" &amp;
+   *                 "eq" Float Float "==" &amp; "eq" BigInteger Float "==" &amp; "eq"
+   *                 Integer Float "==" &amp; "eq" Long Float "==" &amp; "eq" Short
+   *                 Float "==" &amp; "eq" Byte
    */
   @Test
   public void elFloatEqualToTest() throws Exception {
@@ -589,16 +589,16 @@
   }
 
   /**
-   * @testName: elFloatNotEqualToTest
-   * @assertion_ids: EL:SPEC:22.4
-   * @test_Strategy: Validate that if one of the operands in an EL "!=" or "ne"
+   * @testName  elFloatNotEqualToTest
+   * @assertion_ids  EL:SPEC:22.4
+   * @test_Strategy  Validate that if one of the operands in an EL "!=" or "ne"
    *                 operation is a Float, the result is coerced to Double and
    *                 the correct boolean value is returned.
    *
-   *                 Equations tested: Float "!=" & "ne" Double Float "!=" &
-   *                 "ne" Float Float "!=" & "ne" BigInteger Float "!=" & "ne"
-   *                 Integer Float "!=" & "ne" Long Float "!=" & "ne" Short
-   *                 Float "!=" & "ne" Byte
+   *                 Equations tested: Float "!=" &amp; "ne" Double Float "!=" &amp;
+   *                 "ne" Float Float "!=" &amp; "ne" BigInteger Float "!=" &amp; "ne"
+   *                 Integer Float "!=" &amp; "ne" Long Float "!=" &amp; "ne" Short
+   *                 Float "!=" &amp; "ne" Byte
    */
   @Test
   public void elFloatNotEqualToTest() throws Exception {
@@ -612,15 +612,15 @@
   }
 
   /**
-   * @testName: elDoubleLessThanTest
-   * @assertion_ids: EL:SPEC:21.4
-   * @test_Strategy: Validate that if one of the operands in an EL "<" or "lt"
+   * @testName  elDoubleLessThanTest
+   * @assertion_ids  EL:SPEC:21.4
+   * @test_Strategy  Validate that if one of the operands in an EL "&lt;" or "lt"
    *                 operation is a Double, the result is coerced to Double and
    *                 the correct boolean value is returned.
    *
-   *                 Equations tested: Double "<" & "lt" Double Double "<" &
-   *                 "lt" BigInteger Double "<" & "lt" Integer Double "<" & "lt"
-   *                 Long Double "<" & "lt" Short Double "<" & "lt" Byte
+   *                 Equations tested: Double "&lt;" &amp; "lt" Double Double "&lt;" &amp;
+   *                 "lt" BigInteger Double "&lt;" &amp; "lt" Integer Double "&lt;" &amp; "lt"
+   *                 Long Double "&lt;" &amp; "lt" Short Double "&lt;" &amp; "lt" Byte
    */
   @Test
   public void elDoubleLessThanTest() throws Exception {
@@ -637,15 +637,15 @@
   }
 
   /**
-   * @testName: elDoubleLessThanEqualTest
-   * @assertion_ids: EL:SPEC:21.1; EL:SPEC:21.4
-   * @test_Strategy: Validate that if one of the operands in an EL "<=" or "le"
+   * @testName  elDoubleLessThanEqualTest
+   * @assertion_ids  EL:SPEC:21.1; EL:SPEC:21.4
+   * @test_Strategy  Validate that if one of the operands in an EL "&lt;=" or "le"
    *                 operation is a Double, the result is coerced to Double and
    *                 the correct boolean value is returned.
    *
-   *                 Equations tested: Double "<=" & "le" Double Double "<=" &
-   *                 "le" BigInteger Double "<=" & "le" Integer Double "<=" &
-   *                 "le" Long Double "<=" & "le" Short Double "<=" & "le" Byte
+   *                 Equations tested: Double "&lt;=" &amp; "le" Double Double "&lt;=" &amp;
+   *                 "le" BigInteger Double "&lt;=" &amp; "le" Integer Double "&lt;=" &amp;
+   *                 "le" Long Double "&lt;=" &amp; "le" Short Double "&lt;=" &amp; "le" Byte
    */
   @Test
   public void elDoubleLessThanEqualTest() throws Exception {
@@ -661,15 +661,15 @@
   }
 
   /**
-   * @testName: elDoubleGreaterThanTest
-   * @assertion_ids: EL:SPEC:21.4
-   * @test_Strategy: Validate that if one of the operands in an EL ">" or "gt"
+   * @testName  elDoubleGreaterThanTest
+   * @assertion_ids  EL:SPEC:21.4
+   * @test_Strategy  Validate that if one of the operands in an EL ">" or "gt"
    *                 operation is a Double, the result is coerced to Double and
    *                 the correct boolean value is returned.
    *
-   *                 Equations tested: Double ">" & "gt" Double Double ">" &
-   *                 "gt" BigInteger Double ">" & "gt" Integer Double ">" & "gt"
-   *                 Long Double ">" & "gt" Short Double ">" & "gt" Byte
+   *                 Equations tested: Double ">" &amp; "gt" Double Double ">" &amp;
+   *                 "gt" BigInteger Double ">" &amp; "gt" Integer Double ">" &amp; "gt"
+   *                 Long Double ">" &amp; "gt" Short Double ">" &amp; "gt" Byte
    */
   @Test
   public void elDoubleGreaterThanTest() throws Exception {
@@ -686,15 +686,15 @@
   }
 
   /**
-   * @testName: elDoubleGreaterThanEqualTest
-   * @assertion_ids: EL:SPEC:21.1; EL:SPEC:21.4
-   * @test_Strategy: Validate that if one of the operands in an EL ">=" or "ge"
+   * @testName  elDoubleGreaterThanEqualTest
+   * @assertion_ids  EL:SPEC:21.1; EL:SPEC:21.4
+   * @test_Strategy  Validate that if one of the operands in an EL ">=" or "ge"
    *                 operation is a Double, the result is coerced to Double and
    *                 the correct boolean value is returned.
    *
-   *                 Equations tested: Double ">=" & "ge" Double Double ">=" &
-   *                 "ge" BigInteger Double ">=" & "ge" Integer Double ">=" &
-   *                 "ge" Long Double ">=" & "ge" Short Double ">=" & "ge" Byte
+   *                 Equations tested: Double ">=" &amp; "ge" Double Double ">=" &amp;
+   *                 "ge" BigInteger Double ">=" &amp; "ge" Integer Double ">=" &amp;
+   *                 "ge" Long Double ">=" &amp; "ge" Short Double ">=" &amp; "ge" Byte
    */
   @Test
   public void elDoubleGreaterThanEqualTest() throws Exception {
@@ -711,15 +711,15 @@
   }
 
   /**
-   * @testName: elDoubleEqualToTest
-   * @assertion_ids: EL:SPEC:22.1; EL:SPEC:22.4
-   * @test_Strategy: Validate that if one of the operands in an EL "==" or "eq"
+   * @testName  elDoubleEqualToTest
+   * @assertion_ids  EL:SPEC:22.1; EL:SPEC:22.4
+   * @test_Strategy  Validate that if one of the operands in an EL "==" or "eq"
    *                 operation is a Double, the result is coerced to Double and
    *                 the correct boolean value is returned.
    *
-   *                 Equations tested: Double "==" & "eq" Double Double "==" &
-   *                 "eq" BigInteger Double "==" & "eq" Integer Double "==" &
-   *                 "eq" Long Double "==" & "eq" Short Double "==" & "eq" Byte
+   *                 Equations tested: Double "==" &amp; "eq" Double Double "==" &amp;
+   *                 "eq" BigInteger Double "==" &amp; "eq" Integer Double "==" &amp;
+   *                 "eq" Long Double "==" &amp; "eq" Short Double "==" &amp; "eq" Byte
    */
   @Test
   public void elDoubleEqualToTest() throws Exception {
@@ -733,15 +733,15 @@
   }
 
   /**
-   * @testName: elDoubleNotEqualToTest
-   * @assertion_ids: EL:SPEC:22.4
-   * @test_Strategy: Validate that if one of the operands in an EL "!=" or "ne"
+   * @testName  elDoubleNotEqualToTest
+   * @assertion_ids  EL:SPEC:22.4
+   * @test_Strategy  Validate that if one of the operands in an EL "!=" or "ne"
    *                 operation is a Double, the result is coerced to Double and
    *                 the correct boolean value is returned.
    *
-   *                 Equations tested: Double "!=" & "ne" Double Double "!=" &
-   *                 "ne" BigInteger Double "!=" & "ne" Integer Double "!=" &
-   *                 "ne" Long Double "!=" & "ne" Short Double "!=" & "ne" Byte
+   *                 Equations tested: Double "!=" &amp; "ne" Double Double "!=" &amp;
+   *                 "ne" BigInteger Double "!=" &amp; "ne" Integer Double "!=" &amp;
+   *                 "ne" Long Double "!=" &amp; "ne" Short Double "!=" &amp; "ne" Byte
    */
   @Test
   public void elDoubleNotEqualToTest() throws Exception {
@@ -755,15 +755,15 @@
   }
 
   /**
-   * @testName: elBigIntegerLessThanTest
-   * @assertion_ids: EL:SPEC:21.5
-   * @test_Strategy: Validate that if one of the operands in an EL "<" or "lt"
+   * @testName  elBigIntegerLessThanTest
+   * @assertion_ids  EL:SPEC:21.5
+   * @test_Strategy  Validate that if one of the operands in an EL "&lt;" or "lt"
    *                 operation is a BigInteger, the result is coerced to
    *                 BigInteger and the correct boolean value is returned.
    *
-   *                 Equations tested: BigInteger "<" & "lt" BigInteger
-   *                 BigInteger "<" & "lt" Integer BigInteger "<" & "lt" Long
-   *                 BigInteger "<" & "lt" Short BigInteger "<" & "lt" Byte
+   *                 Equations tested: BigInteger "&lt;" &amp; "lt" BigInteger
+   *                 BigInteger "&lt;" &amp; "lt" Integer BigInteger "&lt;" &amp; "lt" Long
+   *                 BigInteger "&lt;" &amp; "lt" Short BigInteger "&lt;" &amp; "lt" Byte
    */
   @Test
   public void elBigIntegerLessThanTest() throws Exception {
@@ -780,15 +780,15 @@
   }
 
   /**
-   * @testName: elBigIntegerLessThanEqualTest
-   * @assertion_ids: EL:SPEC:21.1; EL:SPEC:21.5
-   * @test_Strategy: Validate that if one of the operands in an EL "<=" or "le"
+   * @testName  elBigIntegerLessThanEqualTest
+   * @assertion_ids  EL:SPEC:21.1; EL:SPEC:21.5
+   * @test_Strategy  Validate that if one of the operands in an EL "&lt;=" or "le"
    *                 operation is a BigInteger, the result is coerced to
    *                 BigInteger and the correct boolean value is returned.
    *
-   *                 Equations tested: BigInteger "<=" & "le" BigInteger
-   *                 BigInteger "<=" & "le" Integer BigInteger "<=" & "le" Long
-   *                 BigInteger "<=" & "le" Short BigInteger "<=" & "le" Byte
+   *                 Equations tested: BigInteger "&lt;=" &amp; "le" BigInteger
+   *                 BigInteger "&lt;=" &amp; "le" Integer BigInteger "&lt;=" &amp; "le" Long
+   *                 BigInteger "&lt;=" &amp; "le" Short BigInteger "&lt;=" &amp; "le" Byte
    */
   @Test
   public void elBigIntegerLessThanEqualTest() throws Exception {
@@ -804,15 +804,15 @@
   }
 
   /**
-   * @testName: elBigIntegerGreaterThanTest
-   * @assertion_ids: EL:SPEC:21.5
-   * @test_Strategy: Validate that if one of the operands in an EL ">" or "gt"
+   * @testName  elBigIntegerGreaterThanTest
+   * @assertion_ids  EL:SPEC:21.5
+   * @test_Strategy  Validate that if one of the operands in an EL ">" or "gt"
    *                 operation is a BigInteger, the result is coerced to
    *                 BigInteger and the correct boolean value is returned.
    *
-   *                 Equations tested: BigInteger ">" & "gt" BigInteger
-   *                 BigInteger ">" & "gt" Integer BigInteger ">" & "gt" Long
-   *                 BigInteger ">" & "gt" Short BigInteger ">" & "gt" Byte
+   *                 Equations tested: BigInteger ">" &amp; "gt" BigInteger
+   *                 BigInteger ">" &amp; "gt" Integer BigInteger ">" &amp; "gt" Long
+   *                 BigInteger ">" &amp; "gt" Short BigInteger ">" &amp; "gt" Byte
    */
   @Test
   public void elBigIntegerGreaterThanTest() throws Exception {
@@ -829,15 +829,15 @@
   }
 
   /**
-   * @testName: elBigIntegerGreaterThanEqualTest
-   * @assertion_ids: EL:SPEC:21.1; EL:SPEC:21.5
-   * @test_Strategy: Validate that if one of the operands in an EL ">=" or "ge"
+   * @testName  elBigIntegerGreaterThanEqualTest
+   * @assertion_ids  EL:SPEC:21.1; EL:SPEC:21.5
+   * @test_Strategy  Validate that if one of the operands in an EL ">=" or "ge"
    *                 operation is a BigInteger, the result is coerced to
    *                 BigInteger and the correct boolean value is returned.
    *
-   *                 Equations tested: BigInteger ">=" & "ge" BigInteger
-   *                 BigInteger ">=" & "ge" Integer BigInteger ">=" & "ge" Long
-   *                 BigInteger ">=" & "ge" Short BigInteger ">=" & "ge" Byte
+   *                 Equations tested: BigInteger ">=" &amp; "ge" BigInteger
+   *                 BigInteger ">=" &amp; "ge" Integer BigInteger ">=" &amp; "ge" Long
+   *                 BigInteger ">=" &amp; "ge" Short BigInteger ">=" &amp; "ge" Byte
    */
   @Test
   public void elBigIntegerGreaterThanEqualTest() throws Exception {
@@ -854,15 +854,15 @@
   }
 
   /**
-   * @testName: elBigIntegerEqualToTest
-   * @assertion_ids: EL:SPEC:22.1; EL:SPEC:22.5.1
-   * @test_Strategy: Validate that if one of the operands in an EL "==" or "eq"
+   * @testName  elBigIntegerEqualToTest
+   * @assertion_ids  EL:SPEC:22.1; EL:SPEC:22.5.1
+   * @test_Strategy  Validate that if one of the operands in an EL "==" or "eq"
    *                 operation is a BigInteger, the result is coerced to
    *                 BigInteger and the correct boolean value is returned.
    *
-   *                 Equations tested: BigInteger "==" & "eq" BigInteger
-   *                 BigInteger "==" & "eq" Integer BigInteger "==" & "eq" Long
-   *                 BigInteger "==" & "eq" Short BigInteger "==" & "eq" Byte
+   *                 Equations tested: BigInteger "==" &amp; "eq" BigInteger
+   *                 BigInteger "==" &amp; "eq" Integer BigInteger "==" &amp; "eq" Long
+   *                 BigInteger "==" &amp; "eq" Short BigInteger "==" &amp; "eq" Byte
    */
   @Test
   public void elBigIntegerEqualToTest() throws Exception {
@@ -876,15 +876,15 @@
   }
 
   /**
-   * @testName: elBigIntegerNotEqualToTest
-   * @assertion_ids: EL:SPEC:22.5.2
-   * @test_Strategy: Validate that if one of the operands in an EL "!=" or "ne"
+   * @testName  elBigIntegerNotEqualToTest
+   * @assertion_ids  EL:SPEC:22.5.2
+   * @test_Strategy  Validate that if one of the operands in an EL "!=" or "ne"
    *                 operation is a BigInteger, the result is coerced to
    *                 BigInteger and the correct boolean value is returned.
    *
-   *                 Equations tested: BigInteger "!=" & "ne" BigInteger
-   *                 BigInteger "!=" & "ne" Integer BigInteger "!=" & "ne" Long
-   *                 BigInteger "!=" & "ne" Short BigInteger "!=" & "ne" Byte
+   *                 Equations tested: BigInteger "!=" &amp; "ne" BigInteger
+   *                 BigInteger "!=" &amp; "ne" Integer BigInteger "!=" &amp; "ne" Long
+   *                 BigInteger "!=" &amp; "ne" Short BigInteger "!=" &amp; "ne" Byte
    */
   @Test
   public void elBigIntegerNotEqualToTest() throws Exception {
@@ -898,14 +898,14 @@
   }
 
   /**
-   * @testName: elLongLessThanTest
-   * @assertion_ids: EL:SPEC:21.6
-   * @test_Strategy: Validate that if one of the operands in an EL "<" or "lt"
+   * @testName  elLongLessThanTest
+   * @assertion_ids  EL:SPEC:21.6
+   * @test_Strategy  Validate that if one of the operands in an EL "&lt;" or "lt"
    *                 operation is a Long, the result is coerced to Long and the
    *                 correct boolean value is returned.
    *
-   *                 Equations tested: Long "<" & "lt" Integer Long "<" & "lt"
-   *                 Long Long "<" & "lt" Short Long "<" & "lt" Byte
+   *                 Equations tested: Long "&lt;" &amp; "lt" Integer Long "&lt;" &amp; "lt"
+   *                 Long Long "&lt;" &amp; "lt" Short Long "&lt;" &amp; "lt" Byte
    */
   @Test
   public void elLongLessThanTest() throws Exception {
@@ -922,14 +922,14 @@
   }
 
   /**
-   * @testName: elLongLessThanEqualTest
-   * @assertion_ids: EL:SPEC:21.1; EL:SPEC:21.6
-   * @test_Strategy: Validate that if one of the operands in an EL "<=" or "le"
+   * @testName  elLongLessThanEqualTest
+   * @assertion_ids  EL:SPEC:21.1; EL:SPEC:21.6
+   * @test_Strategy  Validate that if one of the operands in an EL "&lt;=" or "le"
    *                 operation is a Long, the result is coerced to Long and the
    *                 correct boolean value is returned.
    *
-   *                 Equations tested: Long "<=" & "le" Integer Long "<=" & "le"
-   *                 Long Long "<=" & "le" Short Long "<=" & "le" Byte
+   *                 Equations tested: Long "&lt;=" &amp; "le" Integer Long "&lt;=" &amp; "le"
+   *                 Long Long "&lt;=" &amp; "le" Short Long "&lt;=" &amp; "le" Byte
    */
   @Test
   public void elLongLessThanEqualTest() throws Exception {
@@ -945,14 +945,14 @@
   }
 
   /**
-   * @testName: elLongGreaterThanTest
-   * @assertion_ids: EL:SPEC:21.6
-   * @test_Strategy: Validate that if one of the operands in an EL ">" or "gt"
+   * @testName  elLongGreaterThanTest
+   * @assertion_ids  EL:SPEC:21.6
+   * @test_Strategy  Validate that if one of the operands in an EL ">" or "gt"
    *                 operation is a Long, the result is coerced to Long and the
    *                 correct boolean value is returned.
    *
-   *                 Equations tested: Long ">" & "gt" Integer Long ">" & "gt"
-   *                 Long Long ">" & "gt" Short Long ">" & "gt" Byte
+   *                 Equations tested: Long ">" &amp; "gt" Integer Long ">" &amp; "gt"
+   *                 Long Long ">" &amp; "gt" Short Long ">" &amp; "gt" Byte
    */
   @Test
   public void elLongGreaterThanTest() throws Exception {
@@ -969,14 +969,14 @@
   }
 
   /**
-   * @testName: elLongGreaterThanEqualTest
-   * @assertion_ids: EL:SPEC:21.1; EL:SPEC:21.6
-   * @test_Strategy: Validate that if one of the operands in an EL ">=" or "ge"
+   * @testName  elLongGreaterThanEqualTest
+   * @assertion_ids  EL:SPEC:21.1; EL:SPEC:21.6
+   * @test_Strategy  Validate that if one of the operands in an EL ">=" or "ge"
    *                 operation is a Long, the result is coerced to Long and the
    *                 correct boolean value is returned.
    *
-   *                 Equations tested: Long ">=" & "ge" Integer Long ">=" & "ge"
-   *                 Long Long ">=" & "ge" Short Long ">=" & "ge" Byte
+   *                 Equations tested: Long ">=" &amp; "ge" Integer Long ">=" &amp; "ge"
+   *                 Long Long ">=" &amp; "ge" Short Long ">=" &amp; "ge" Byte
    */
   @Test
   public void elLongGreaterThanEqualTest() throws Exception {
@@ -993,14 +993,14 @@
   }
 
   /**
-   * @testName: elLongEqualToTest
-   * @assertion_ids: EL:SPEC:22.1; EL:SPEC:22.6
-   * @test_Strategy: Validate that if one of the operands in an EL "==" or "eq"
+   * @testName  elLongEqualToTest
+   * @assertion_ids  EL:SPEC:22.1; EL:SPEC:22.6
+   * @test_Strategy  Validate that if one of the operands in an EL "==" or "eq"
    *                 operation is a Long, the result is coerced to Long and the
    *                 correct boolean value is returned.
    *
-   *                 Equations tested: Long "==" & "eq" Integer Long "==" & "eq"
-   *                 Long Long "==" & "eq" Short Long "==" & "eq" Byte
+   *                 Equations tested: Long "==" &amp; "eq" Integer Long "==" &amp; "eq"
+   *                 Long Long "==" &amp; "eq" Short Long "==" &amp; "eq" Byte
    */
   @Test
   public void elLongEqualToTest() throws Exception {
@@ -1014,14 +1014,14 @@
   }
 
   /**
-   * @testName: elLongNotEqualToTest
-   * @assertion_ids: EL:SPEC:22.6
-   * @test_Strategy: Validate that if one of the operands in an EL "!=" or "ne"
+   * @testName  elLongNotEqualToTest
+   * @assertion_ids  EL:SPEC:22.6
+   * @test_Strategy  Validate that if one of the operands in an EL "!=" or "ne"
    *                 operation is a Long, the result is coerced to Long and the
    *                 correct boolean value is returned.
    *
-   *                 Equations tested: Long "!=" & "ne" Integer Long "!=" & "ne"
-   *                 Long Long "!=" & "ne" Short Long "!=" & "ne" Byte
+   *                 Equations tested: Long "!=" &amp; "ne" Integer Long "!=" &amp; "ne"
+   *                 Long Long "!=" &amp; "ne" Short Long "!=" &amp; "ne" Byte
    */
   @Test
   public void elLongNotEqualToTest() throws Exception {
@@ -1035,14 +1035,14 @@
   }
 
   /**
-   * @testName: elIntegerLessThanTest
-   * @assertion_ids: EL:SPEC:21.6
-   * @test_Strategy: Validate that if one of the operands in an EL "<" or "lt"
+   * @testName  elIntegerLessThanTest
+   * @assertion_ids  EL:SPEC:21.6
+   * @test_Strategy  Validate that if one of the operands in an EL "&lt;" or "lt"
    *                 operation is an Integer, the result is coerced to Long and
    *                 the correct boolean value is returned.
    *
-   *                 Equations tested: Integer "<" & "lt" Integer Integer "<" &
-   *                 "lt" Short Integer "<" & "lt" Byte
+   *                 Equations tested: Integer "&lt;" &amp; "lt" Integer Integer "&lt;" &amp;
+   *                 "lt" Short Integer "&lt;" &amp; "lt" Byte
    */
   @Test
   public void elIntegerLessThanTest() throws Exception {
@@ -1059,14 +1059,14 @@
   }
 
   /**
-   * @testName: elIntegerLessThanEqualTest
-   * @assertion_ids: EL:SPEC:21.1; EL:SPEC:21.6
-   * @test_Strategy: Validate that if one of the operands in an EL "<=" or "le"
+   * @testName  elIntegerLessThanEqualTest
+   * @assertion_ids  EL:SPEC:21.1; EL:SPEC:21.6
+   * @test_Strategy  Validate that if one of the operands in an EL "&lt;=" or "le"
    *                 operation is an Integer, the result is coerced to Long and
    *                 the correct boolean value is returned.
    *
-   *                 Equations tested: Integer "<=" & "le" Integer Integer "<="
-   *                 & "le" Short Integer "<=" & "le" Byte
+   *                 Equations tested: Integer "&lt;=" &amp; "le" Integer Integer "&lt;="
+   *                 &amp; "le" Short Integer "&lt;=" &amp; "le" Byte
    */
   @Test
   public void elIntegerLessThanEqualTest() throws Exception {
@@ -1082,14 +1082,14 @@
   }
 
   /**
-   * @testName: elIntegerGreaterThanTest
-   * @assertion_ids: EL:SPEC:21.6
-   * @test_Strategy: Validate that if one of the operands in an EL ">" or "gt"
+   * @testName  elIntegerGreaterThanTest
+   * @assertion_ids  EL:SPEC:21.6
+   * @test_Strategy  Validate that if one of the operands in an EL ">" or "gt"
    *                 operation is an Integer, the result is coerced to Long and
    *                 the correct boolean value is returned.
    *
-   *                 Equations tested: Integer ">" & "gt" Integer Integer ">" &
-   *                 "gt" Short Integer ">" & "gt" Byte
+   *                 Equations tested: Integer ">" &amp; "gt" Integer Integer ">" &amp;
+   *                 "gt" Short Integer ">" &amp; "gt" Byte
    */
   @Test
   public void elIntegerGreaterThanTest() throws Exception {
@@ -1106,14 +1106,14 @@
   }
 
   /**
-   * @testName: elIntegerGreaterThanEqualTest
-   * @assertion_ids: EL:SPEC:21.1; EL:SPEC:21.6
-   * @test_Strategy: Validate that if one of the operands in an EL ">=" or "ge"
+   * @testName  elIntegerGreaterThanEqualTest
+   * @assertion_ids  EL:SPEC:21.1; EL:SPEC:21.6
+   * @test_Strategy  Validate that if one of the operands in an EL ">=" or "ge"
    *                 operation is an Integer, the result is coerced to Long and
    *                 the correct boolean value is returned.
    *
-   *                 Equations tested: Integer ">=" & "ge" Integer Integer ">="
-   *                 & "ge" Short Integer ">=" & "ge" Byte
+   *                 Equations tested: Integer ">=" &amp; "ge" Integer Integer ">="
+   *                 &amp; "ge" Short Integer ">=" &amp; "ge" Byte
    */
   @Test
   public void elIntegerGreaterThanEqualTest() throws Exception {
@@ -1130,14 +1130,14 @@
   }
 
   /**
-   * @testName: elIntegerEqualToTest
-   * @assertion_ids: EL:SPEC:22.1; EL:SPEC:22.6
-   * @test_Strategy: Validate that if one of the operands in an EL "==" or "eq"
+   * @testName  elIntegerEqualToTest
+   * @assertion_ids  EL:SPEC:22.1; EL:SPEC:22.6
+   * @test_Strategy  Validate that if one of the operands in an EL "==" or "eq"
    *                 operation is an Integer, the result is coerced to Long and
    *                 the correct boolean value is returned.
    *
-   *                 Equations tested: Integer "==" & "eq" Integer Integer "=="
-   *                 & "eq" Short Integer "==" & "eq" Byte
+   *                 Equations tested: Integer "==" &amp; "eq" Integer Integer "=="
+   *                 &amp; "eq" Short Integer "==" &amp; "eq" Byte
    */
   @Test
   public void elIntegerEqualToTest() throws Exception {
@@ -1151,14 +1151,14 @@
   }
 
   /**
-   * @testName: elIntegerNotEqualToTest
-   * @assertion_ids: EL:SPEC:22.6
-   * @test_Strategy: Validate that if one of the operands in an EL "!=" or "ne"
+   * @testName  elIntegerNotEqualToTest
+   * @assertion_ids  EL:SPEC:22.6
+   * @test_Strategy  Validate that if one of the operands in an EL "!=" or "ne"
    *                 operation is an Integer, the result is coerced to Long and
    *                 the correct boolean value is returned.
    *
-   *                 Equations tested: Integer "!=" & "ne" Integer Integer "!="
-   *                 & "ne" Short Integer "!=" & "ne" Byte
+   *                 Equations tested: Integer "!=" &amp; "ne" Integer Integer "!="
+   *                 &amp; "ne" Short Integer "!=" &amp; "ne" Byte
    */
   @Test
   public void elIntegerNotEqualToTest() throws Exception {
@@ -1172,13 +1172,13 @@
   }
 
   /**
-   * @testName: elShortLessThanTest
-   * @assertion_ids: EL:SPEC:21.6
-   * @test_Strategy: Validate that if one of the operands in an EL "<" or "lt"
+   * @testName  elShortLessThanTest
+   * @assertion_ids  EL:SPEC:21.6
+   * @test_Strategy  Validate that if one of the operands in an EL "&lt;" or "lt"
    *                 operation is an Short, the result is coerced to Long and
    *                 the correct boolean value is returned.
    *
-   *                 Equations tested: Short "<" & "lt" Short Short "<" & "lt"
+   *                 Equations tested: Short "&lt;" &amp; "lt" Short Short "&lt;" &amp; "lt"
    *                 Byte
    */
   @Test
@@ -1196,13 +1196,13 @@
   }
 
   /**
-   * @testName: elShortLessThanEqualTest
-   * @assertion_ids: EL:SPEC:21.1; EL:SPEC:21.6
-   * @test_Strategy: Validate that if one of the operands in an EL "<=" or "le"
+   * @testName  elShortLessThanEqualTest
+   * @assertion_ids  EL:SPEC:21.1; EL:SPEC:21.6
+   * @test_Strategy  Validate that if one of the operands in an EL "&lt;=" or "le"
    *                 operation is an Short, the result is coerced to Long and
    *                 the correct boolean value is returned.
    *
-   *                 Equations tested: Short "<=" & "le" Short Short "<=" & "le"
+   *                 Equations tested: Short "&lt;=" &amp; "le" Short Short "&lt;=" &amp; "le"
    *                 Byte
    */
   @Test
@@ -1219,13 +1219,13 @@
   }
 
   /**
-   * @testName: elShortGreaterThanTest
-   * @assertion_ids: EL:SPEC:21.6
-   * @test_Strategy: Validate that if one of the operands in an EL ">" or "gt"
+   * @testName  elShortGreaterThanTest
+   * @assertion_ids  EL:SPEC:21.6
+   * @test_Strategy  Validate that if one of the operands in an EL ">" or "gt"
    *                 operation is an Short, the result is coerced to Long and
    *                 the correct boolean value is returned.
    *
-   *                 Equations tested: Short ">" & "gt" Short Short ">" & "gt"
+   *                 Equations tested: Short ">" &amp; "gt" Short Short ">" &amp; "gt"
    *                 Byte
    */
   @Test
@@ -1243,13 +1243,13 @@
   }
 
   /**
-   * @testName: elShortGreaterThanEqualTest
-   * @assertion_ids: EL:SPEC:21.1; EL:SPEC:21.6
-   * @test_Strategy: Validate that if one of the operands in an EL ">=" or "ge"
+   * @testName  elShortGreaterThanEqualTest
+   * @assertion_ids  EL:SPEC:21.1; EL:SPEC:21.6
+   * @test_Strategy  Validate that if one of the operands in an EL ">=" or "ge"
    *                 operation is an Short, the result is coerced to Long and
    *                 the correct boolean value is returned.
    *
-   *                 Equations tested: Short ">=" & "ge" Short Short ">=" & "ge"
+   *                 Equations tested: Short ">=" &amp; "ge" Short Short ">=" &amp; "ge"
    *                 Byte
    */
   @Test
@@ -1267,13 +1267,13 @@
   }
 
   /**
-   * @testName: elShortEqualToTest
-   * @assertion_ids: EL:SPEC:22.1; EL:SPEC:22.6
-   * @test_Strategy: Validate that if one of the operands in an EL "==" or "eq"
+   * @testName  elShortEqualToTest
+   * @assertion_ids  EL:SPEC:22.1; EL:SPEC:22.6
+   * @test_Strategy  Validate that if one of the operands in an EL "==" or "eq"
    *                 operation is an Short, the result is coerced to Long and
    *                 the correct boolean value is returned.
    *
-   *                 Equations tested: Short "==" & "eq" Short Short "==" & "eq"
+   *                 Equations tested: Short "==" &amp; "eq" Short Short "==" &amp; "eq"
    *                 Byte
    */
   @Test
@@ -1288,13 +1288,13 @@
   }
 
   /**
-   * @testName: elShortNotEqualToTest
-   * @assertion_ids: EL:SPEC:22.6
-   * @test_Strategy: Validate that if one of the operands in an EL "!=" or "ne"
+   * @testName  elShortNotEqualToTest
+   * @assertion_ids  EL:SPEC:22.6
+   * @test_Strategy  Validate that if one of the operands in an EL "!=" or "ne"
    *                 operation is an Short, the result is coerced to Long and
    *                 the correct boolean value is returned.
    *
-   *                 Equations tested: Short "!=" & "ne" Short Short "!=" & "ne"
+   *                 Equations tested: Short "!=" &amp; "ne" Short Short "!=" &amp; "ne"
    *                 Byte
    */
   @Test
@@ -1309,13 +1309,13 @@
   }
 
   /**
-   * @testName: elByteLessThanTest
-   * @assertion_ids: EL:SPEC:21.6
-   * @test_Strategy: Validate that if one of the operands in an EL "<" or "lt"
+   * @testName  elByteLessThanTest
+   * @assertion_ids  EL:SPEC:21.6
+   * @test_Strategy  Validate that if one of the operands in an EL "&lt;" or "lt"
    *                 operation is an Byte, the result is coerced to Long and the
    *                 correct boolean value is returned.
    *
-   *                 Equations tested: Byte "<" & "lt" Byte
+   *                 Equations tested: Byte "&lt;" &amp; "lt" Byte
    */
   @Test
   public void elByteLessThanTest() throws Exception {
@@ -1332,13 +1332,13 @@
   }
 
   /**
-   * @testName: elByteLessThanEqualTest
-   * @assertion_ids: EL:SPEC:21.1; EL:SPEC:21.6
-   * @test_Strategy: Validate that if one of the operands in an EL "<=" or "le"
+   * @testName  elByteLessThanEqualTest
+   * @assertion_ids  EL:SPEC:21.1; EL:SPEC:21.6
+   * @test_Strategy  Validate that if one of the operands in an EL "&lt;=" or "le"
    *                 operation is an Byte, the result is coerced to Long and the
    *                 correct boolean value is returned.
    *
-   *                 Equations tested: Byte "<=" & "le" Byte
+   *                 Equations tested: Byte "&lt;=" &amp; "le" Byte
    */
   @Test
   public void elByteLessThanEqualTest() throws Exception {
@@ -1354,13 +1354,13 @@
   }
 
   /**
-   * @testName: elByteGreaterThanTest
-   * @assertion_ids: EL:SPEC:21.1
-   * @test_Strategy: Validate that if one of the operands in an EL ">" or "gt"
+   * @testName  elByteGreaterThanTest
+   * @assertion_ids  EL:SPEC:21.1
+   * @test_Strategy  Validate that if one of the operands in an EL ">" or "gt"
    *                 operation is an Byte, the result is coerced to Long and the
    *                 correct boolean value is returned.
    *
-   *                 Equations tested: Byte ">" & "gt" Byte
+   *                 Equations tested: Byte ">" &amp; "gt" Byte
    */
   @Test
   public void elByteGreaterThanTest() throws Exception {
@@ -1377,13 +1377,13 @@
   }
 
   /**
-   * @testName: elByteGreaterThanEqualTest
-   * @assertion_ids: EL:SPEC:21.1; EL:SPEC:21.6
-   * @test_Strategy: Validate that if one of the operands in an EL ">=" or "ge"
+   * @testName  elByteGreaterThanEqualTest
+   * @assertion_ids  EL:SPEC:21.1; EL:SPEC:21.6
+   * @test_Strategy  Validate that if one of the operands in an EL ">=" or "ge"
    *                 operation is an Byte, the result is coerced to Long and the
    *                 correct boolean value is returned.
    *
-   *                 Equations tested: Byte ">=" & "ge" Byte
+   *                 Equations tested: Byte ">=" &amp; "ge" Byte
    */
   @Test
   public void elByteGreaterThanEqualTest() throws Exception {
@@ -1400,13 +1400,13 @@
   }
 
   /**
-   * @testName: elByteEqualToTest
-   * @assertion_ids: EL:SPEC:22.1; EL:SPEC:22.6
-   * @test_Strategy: Validate that if one of the operands in an EL "==" or "eq"
+   * @testName  elByteEqualToTest
+   * @assertion_ids  EL:SPEC:22.1; EL:SPEC:22.6
+   * @test_Strategy  Validate that if one of the operands in an EL "==" or "eq"
    *                 operation is an Byte, the result is coerced to Long and the
    *                 correct boolean value is returned.
    *
-   *                 Equations tested: Byte "==" & "eq" Byte
+   *                 Equations tested: Byte "==" &amp; "eq" Byte
    */
   @Test
   public void elByteEqualToTest() throws Exception {
@@ -1420,13 +1420,13 @@
   }
 
   /**
-   * @testName: elByteNotEqualToTest
-   * @assertion_ids: EL:SPEC:22.6
-   * @test_Strategy: Validate that if one of the operands in an EL "!=" or "ne"
+   * @testName  elByteNotEqualToTest
+   * @assertion_ids  EL:SPEC:22.6
+   * @test_Strategy  Validate that if one of the operands in an EL "!=" or "ne"
    *                 operation is an Byte, the result is coerced to Long and the
    *                 correct boolean value is returned.
    *
-   *                 Equations tested: Byte "!=" & "ne" Byte
+   *                 Equations tested: Byte "!=" &amp; "ne" Byte
    */
   @Test
   public void elByteNotEqualToTest() throws Exception {
@@ -1440,13 +1440,13 @@
   }
 
   /**
-   * @testName: elStringLessThanTest
-   * @assertion_ids: EL:SPEC:21.7
-   * @test_Strategy: Validate that if one of the operands in an EL "<" or "lt"
+   * @testName  elStringLessThanTest
+   * @assertion_ids  EL:SPEC:21.7
+   * @test_Strategy  Validate that if one of the operands in an EL "&lt;" or "lt"
    *                 operation is an String, that both operands are coerced to
    *                 type String and the correct boolean value is returned.
    *
-   *                 Equations tested: String "<" & "lt" String
+   *                 Equations tested: String "&lt;" &amp; "lt" String
    */
   @Test
   public void elStringLessThanTest() throws Exception {
@@ -1463,13 +1463,13 @@
   }
 
   /**
-   * @testName: elStringLessThanEqualTest
-   * @assertion_ids: EL:SPEC:21.7
-   * @test_Strategy: Validate that if one of the operands in an EL "<=" or "le"
+   * @testName  elStringLessThanEqualTest
+   * @assertion_ids  EL:SPEC:21.7
+   * @test_Strategy  Validate that if one of the operands in an EL "&lt;=" or "le"
    *                 operation is a String, that both operands are coerced to
    *                 type String and the correct boolean value is returned.
    *
-   *                 Equations tested: String "<=" & "le" String
+   *                 Equations tested: String "&lt;=" &amp; "le" String
    */
   @Test
   public void elStringLessThanEqualTest() throws Exception {
@@ -1485,13 +1485,13 @@
   }
 
   /**
-   * @testName: elStringGreaterThanTest
-   * @assertion_ids: EL:SPEC:21.7
-   * @test_Strategy: Validate that if one of the operands in an EL ">" or "gt"
+   * @testName  elStringGreaterThanTest
+   * @assertion_ids  EL:SPEC:21.7
+   * @test_Strategy  Validate that if one of the operands in an EL ">" or "gt"
    *                 operation is an String, that both operands are coerced to
    *                 type String and the correct boolean value is returned.
    *
-   *                 Equations tested: String ">" & "gt" String
+   *                 Equations tested: String ">" &amp; "gt" String
    */
   @Test
   public void elStringGreaterThanTest() throws Exception {
@@ -1508,13 +1508,13 @@
   }
 
   /**
-   * @testName: elStringGreaterThanEqualTest
-   * @assertion_ids: EL:SPEC:21.7
-   * @test_Strategy: Validate that if one of the operands in an EL ">=" or "ge"
+   * @testName  elStringGreaterThanEqualTest
+   * @assertion_ids  EL:SPEC:21.7
+   * @test_Strategy  Validate that if one of the operands in an EL ">=" or "ge"
    *                 operation is an String, that both operands are coerced to
    *                 type String and the correct boolean value is returned.
    *
-   *                 Equations tested: String ">=" & "ge" String
+   *                 Equations tested: String ">=" &amp; "ge" String
    */
   @Test
   public void elStringGreaterThanEqualTest() throws Exception {
@@ -1531,13 +1531,13 @@
   }
 
   /**
-   * @testName: elStringEqualToTest
-   * @assertion_ids: EL:SPEC:22.9
-   * @test_Strategy: Validate that if one of the operands in an EL "==" or "eq"
+   * @testName  elStringEqualToTest
+   * @assertion_ids  EL:SPEC:22.9
+   * @test_Strategy  Validate that if one of the operands in an EL "==" or "eq"
    *                 operation is an String, that both operands are coerced to
    *                 type String and the correct boolean value is returned.
    *
-   *                 Equations tested: String "==" & "eq" String
+   *                 Equations tested: String "==" &amp; "eq" String
    */
   @Test
   public void elStringEqualToTest() throws Exception {
@@ -1551,13 +1551,13 @@
   }
 
   /**
-   * @testName: elStringNotEqualToTest
-   * @assertion_ids: EL:SPEC:22.9
-   * @test_Strategy: Validate that if one of the operands in an EL "!=" or "ne"
+   * @testName  elStringNotEqualToTest
+   * @assertion_ids  EL:SPEC:22.9
+   * @test_Strategy  Validate that if one of the operands in an EL "!=" or "ne"
    *                 operation is an String, that both operands are coerced to
    *                 type String and the correct boolean value is returned.
    *
-   *                 Equations tested: String "!=" & "ne" String
+   *                 Equations tested: String "!=" &amp; "ne" String
    */
   @Test
   public void elStringNotEqualToTest() throws Exception {
@@ -1571,12 +1571,12 @@
   }
 
   /**
-   * @testName: elOtherLessThanTest
-   * @assertion_ids: EL:SPEC:21.8.2
-   * @test_Strategy: Validate that if operand A in an EL "<" or "lt" operation
+   * @testName  elOtherLessThanTest
+   * @assertion_ids  EL:SPEC:21.8.2
+   * @test_Strategy  Validate that if operand A in an EL "&lt;" or "lt" operation
    *                 is comparable, the result A.compareTo(B) is returned.
    *
-   *                 Equation example: DougType "<" & "lt" NickType
+   *                 Equation example: DougType "&lt;" &amp; "lt" NickType
    */
   @Test
   public void elOtherLessThanTest() throws Exception {
@@ -1593,12 +1593,12 @@
   }
 
   /**
-   * @testName: elOtherLessThanEqualTest
-   * @assertion_ids: EL:SPEC:21.8.2
-   * @test_Strategy: Validate that if operand A in an EL "<=" or "le" operation
+   * @testName  elOtherLessThanEqualTest
+   * @assertion_ids  EL:SPEC:21.8.2
+   * @test_Strategy  Validate that if operand A in an EL "&lt;=" or "le" operation
    *                 is comparable, the result A.compareTo(B) is returned.
    *
-   *                 Equation example: DougType "<=" & "le" NickType
+   *                 Equation example: DougType "&lt;=" &amp; "le" NickType
    */
   @Test
   public void elOtherLessThanEqualTest() throws Exception {
@@ -1614,12 +1614,12 @@
   }
 
   /**
-   * @testName: elOtherGreaterThanTest
-   * @assertion_ids: EL:SPEC:21.8.2
-   * @test_Strategy: Validate that if operand A in an EL ">" or "gt" operation
+   * @testName  elOtherGreaterThanTest
+   * @assertion_ids  EL:SPEC:21.8.2
+   * @test_Strategy  Validate that if operand A in an EL ">" or "gt" operation
    *                 is comparable, the result A.compareTo(B) is returned.
    *
-   *                 Equation example: DougType "<" & "gt" NickType
+   *                 Equation example: DougType "&lt;" &amp; "gt" NickType
    */
   @Test
   public void elOtherGreaterThanTest() throws Exception {
@@ -1636,12 +1636,12 @@
   }
 
   /**
-   * @testName: elOtherGreaterThanEqualTest
-   * @assertion_ids: EL:SPEC:21.8.2
-   * @test_Strategy: Validate that if operand A in an EL ">=" or "ge" operation
+   * @testName  elOtherGreaterThanEqualTest
+   * @assertion_ids  EL:SPEC:21.8.2
+   * @test_Strategy  Validate that if operand A in an EL ">=" or "ge" operation
    *                 is comparable, the result A.compareTo(B) is returned.
    *
-   *                 Equations tested: DougType ">=" & "ge" NickType
+   *                 Equations tested: DougType ">=" &amp; "ge" NickType
    */
   @Test
   public void elOtherGreaterThanEqualTest() throws Exception {
@@ -1658,12 +1658,12 @@
   }
 
   /**
-   * @testName: elOtherEqualToTest
-   * @assertion_ids: EL:SPEC:22.11
-   * @test_Strategy: Validate that if operand A in an EL "==" or "eq" operation
+   * @testName  elOtherEqualToTest
+   * @assertion_ids  EL:SPEC:22.11
+   * @test_Strategy  Validate that if operand A in an EL "==" or "eq" operation
    *                 is comparable, the result A.equals(B) is returned.
    *
-   *                 Equations Example: DougType "==" & "eq" NickType
+   *                 Equations Example: DougType "==" &amp; "eq" NickType
    */
   @Test
   public void elOtherEqualToTest() throws Exception {
@@ -1677,12 +1677,12 @@
   }
 
   /**
-   * @testName: elOtherNotEqualToTest
-   * @assertion_ids: EL:SPEC:22.11
-   * @test_Strategy: Validate that if operand A in an EL "!=" or "ne" operation
+   * @testName  elOtherNotEqualToTest
+   * @assertion_ids  EL:SPEC:22.11
+   * @test_Strategy  Validate that if operand A in an EL "!=" or "ne" operation
    *                 is comparable, the result A.equals(B) is returned.
    *
-   *                 Equation Example: DougType "!=" & "ne" NickType
+   *                 Equation Example: DougType "!=" &amp; "ne" NickType
    */
   @Test
   public void elOtherNotEqualToTest() throws Exception {
@@ -1696,13 +1696,13 @@
   }
 
   /**
-   * @testName: elBooleanEqualToTest
-   * @assertion_ids: EL:SPEC:22.7
-   * @test_Strategy: Validate that if one of the operands in an EL "==" or "eq"
+   * @testName  elBooleanEqualToTest
+   * @assertion_ids  EL:SPEC:22.7
+   * @test_Strategy  Validate that if one of the operands in an EL "==" or "eq"
    *                 operation is an Boolean, that both operands are coerced to
    *                 type Boolean and the correct boolean value is returned.
    *
-   *                 Equations tested: Boolean "==" & "eq" String
+   *                 Equations tested: Boolean "==" &amp; "eq" String
    */
   @Test
   public void elBooleanEqualToTest() throws Exception {
@@ -1716,13 +1716,13 @@
   }
 
   /**
-   * @testName: elBooleanNotEqualToTest
-   * @assertion_ids: EL:SPEC:22.7
-   * @test_Strategy: Validate that if one of the operands in an EL "!=" or "ne"
+   * @testName  elBooleanNotEqualToTest
+   * @assertion_ids  EL:SPEC:22.7
+   * @test_Strategy  Validate that if one of the operands in an EL "!=" or "ne"
    *                 operation is an Boolean, that both operands are coerced to
    *                 type Boolean and the correct boolean value is returned.
    *
-   *                 Equations tested: String "!=" & "ne" String
+   *                 Equations tested: String "!=" &amp; "ne" String
    */
   @Test
   public void elBooleanNotEqualToTest() throws Exception {
@@ -1736,9 +1736,9 @@
   }
 
   /**
-   * @testName: elEnumEqualToTest
-   * @assertion_ids: EL:SPEC:22.8
-   * @test_Strategy: Validate that if one of the operands in an EL "==" or "eq"
+   * @testName  elEnumEqualToTest
+   * @assertion_ids  EL:SPEC:22.8
+   * @test_Strategy  Validate that if one of the operands in an EL "==" or "eq"
    *                 operation is an Enum, that both operands are coerced to
    *                 type Enum and the correct boolean value is returned.
    *
@@ -1757,13 +1757,13 @@
   }
 
   /**
-   * @testName: elEnumNotEqualToTest
-   * @assertion_ids: EL:SPEC:22.8
-   * @test_Strategy: Validate that if one of the operands in an EL "!=" or "ne"
+   * @testName  elEnumNotEqualToTest
+   * @assertion_ids  EL:SPEC:22.8
+   * @test_Strategy  Validate that if one of the operands in an EL "!=" or "ne"
    *                 operation is an Enum, that both operands are coerced to
    *                 type String and the correct boolean value is returned.
    *
-   *                 Example Equation: Enum "!=" & "ne" Enum
+   *                 Example Equation: Enum "!=" &amp; "ne" Enum
    */
   @Test
   public void elEnumNotEqualToTest() throws Exception {
@@ -1791,7 +1791,7 @@
    *          - expected result.
    * @param booleanOperator
    *          - The operator in which the operands are compared. (i.e. ">, >=,
-   *          <, <=, gt, ge, lt, le, ==, !=, eq, ne)
+   *          &lt;, &lt;=, gt, ge, lt, le, ==, !=, eq, ne)
    */
   private void testOperatorBoolean(BigDecimal testVal, Boolean expectedVal,
       String booleanOperator) throws Exception {
@@ -1850,8 +1850,8 @@
    * @param expectedVal
    *          - expected result.
    * @param booleanOperator
-   *          - The operator in which the operands are compared. (i.e. >, >=, <,
-   *          <=, gt, ge, lt, le, ==, !=, eq, ne)
+   *          - The operator in which the operands are compared. (i.e. >, >=, &lt;,
+   *          &lt;=, gt, ge, lt, le, ==, !=, eq, ne)
    */
   private void testOperatorBoolean(BigInteger testVal, Boolean expectedVal,
       String booleanOperator) throws Exception {
@@ -1919,7 +1919,7 @@
    *          - expected result.
    * @param booleanOperator
    *          - The operator in which the operands are compared. (i.e. ">, >=,
-   *          <, <=, gt, ge, lt, le, ==, !=, eq, ne)
+   *          &lt;, &lt;=, gt, ge, lt, le, ==, !=, eq, ne)
    */
   private void testOperatorBoolean(Float testVal, Boolean expectedVal,
       String booleanOperator) throws Exception {
@@ -1986,7 +1986,7 @@
    *          - expected result.
    * @param booleanOperator
    *          - The operator in which the operands are compared. (i.e. ">, >=,
-   *          <, <=, gt, ge, lt, le, ==, !=, eq, ne)
+   *          &lt;, &lt;=, gt, ge, lt, le, ==, !=, eq, ne)
    */
   private void testOperatorBoolean(Double testVal, Boolean expectedVal,
       String booleanOperator) throws Exception {
@@ -2053,7 +2053,7 @@
    *          - expected result.
    * @param booleanOperator
    *          - The operator in which the operands are compared. (i.e. ">, >=,
-   *          <, <=, gt, ge, lt, le, ==, !=, eq, ne)
+   *          &lt;, &lt;=, gt, ge, lt, le, ==, !=, eq, ne)
    */
   private void testOperatorBoolean(Long testVal, Boolean expectedVal,
       String booleanOperator) throws Exception {
@@ -2119,7 +2119,7 @@
    *          - expected result.
    * @param booleanOperator
    *          - The operator in which the operands are compared. (i.e. ">, >=,
-   *          <, <=, gt, ge, lt, le, ==, !=, eq, ne)
+   *          &lt;, &lt;=, gt, ge, lt, le, ==, !=, eq, ne)
    */
   private void testOperatorBoolean(Integer testVal, Boolean expectedVal,
       String booleanOperator) throws Exception {
@@ -2188,7 +2188,7 @@
    *          - expected result.
    * @param booleanOperator
    *          - The operator in which the operands are compared. (i.e. ">, >=,
-   *          <, <=, gt, ge, lt, le, ==, !=, eq, ne)
+   *          &lt;, &lt;=, gt, ge, lt, le, ==, !=, eq, ne)
    */
   private void testOperatorBoolean(Short testVal, Boolean expectedVal,
       String booleanOperator) throws Exception {
@@ -2250,8 +2250,8 @@
    * @param expectedVal
    *          - expected result.
    * @param booleanOperator
-   *          - The operator in which the operands are compared. (i.e. >, >=, <,
-   *          <=, gt, ge, lt, le, ==, !=, eq, ne)
+   *          - The operator in which the operands are compared. (i.e. >, >=, &lt;,
+   *          &lt;=, gt, ge, lt, le, ==, !=, eq, ne)
    */
   private void testOperatorBoolean(Byte testVal, Boolean expectedVal,
       String booleanOperator) throws Exception {
@@ -2312,7 +2312,7 @@
    *          - expected result.
    * @param booleanOperator
    *          - The operator in which the operands are compared. (i.e. ">, >=,
-   *          <, <=, gt, ge, lt, le, ==, !=, eq, ne)
+   *          &lt;, &lt;=, gt, ge, lt, le, ==, !=, eq, ne)
    */
   private void testOperatorBoolean(Object testValOne, Object testValTwo,
       Boolean expectedVal, String booleanOperator) throws Exception {
diff --git a/tck/src/main/java/ee/jakarta/tck/el/spec/semicolonoperator/ELClientIT.java b/tck/src/main/java/ee/jakarta/tck/el/spec/semicolonoperator/ELClientIT.java
index 751a844..2ab956e 100644
--- a/tck/src/main/java/ee/jakarta/tck/el/spec/semicolonoperator/ELClientIT.java
+++ b/tck/src/main/java/ee/jakarta/tck/el/spec/semicolonoperator/ELClientIT.java
@@ -59,11 +59,11 @@
   }
 
   /**
-   * @testName: elSemiColonOperatorBigDecimalTest
+   * @testName  elSemiColonOperatorBigDecimalTest
    *
-   * @assertion_ids: EL:SPEC:49.1
+   * @assertion_ids  EL:SPEC:49.1
    *
-   * @test_Strategy: To evaluate A;B, A is first evaluated, and its value is
+   * @test_Strategy  To evaluate A;B, A is first evaluated, and its value is
    *                 discarded. B is then evaluated and its value is returned.
    *
    *                 Operators: +, -, *, /, div, %, mod
@@ -78,7 +78,7 @@
    *
    *                 Excluded: none
    *
-   * @since: 3.0
+   * @since 3.0
    *
    */
   @Test
@@ -134,11 +134,11 @@
   } // End elSemiColonOperatorBigDecimalTest
 
   /**
-   * @testName: elSemiColonOperatorFloatTest
+   * @testName  elSemiColonOperatorFloatTest
    *
-   * @assertion_ids: EL:SPEC:49.1
+   * @assertion_ids  EL:SPEC:49.1
    *
-   * @test_Strategy: Validate that when we have variable A set to a specific
+   * @test_Strategy  Validate that when we have variable A set to a specific
    *                 data type that we coerce and receive back the correct value
    *                 and Class type.
    *
@@ -153,7 +153,7 @@
    *
    *                 Exclude: BigDecimal
    *
-   * @since: 3.0
+   * @since 3.0
    *
    */
   @Test
@@ -246,11 +246,11 @@
   } // End elSemiColonOperatorFloatTest
 
   /**
-   * @testName: elSemiColonOperatorDoubleTest
+   * @testName  elSemiColonOperatorDoubleTest
    *
-   * @assertion_ids: EL:SPEC:49.1
+   * @assertion_ids  EL:SPEC:49.1
    *
-   * @test_Strategy: Validate that when we have variable A set to a specific
+   * @test_Strategy  Validate that when we have variable A set to a specific
    *                 data type that we coerce and receive back the correct value
    *                 and Class type.
    *
@@ -265,7 +265,7 @@
    *
    *                 Exclude: BigDecimal, Float
    *
-   * @since: 3.0
+   * @since 3.0
    *
    */
   @Test
@@ -359,11 +359,11 @@
   } // End elSemiColonOperatorDoubleTest
 
   /**
-   * @testName: elSemiColonOperatorBigIntegerTest
+   * @testName  elSemiColonOperatorBigIntegerTest
    *
-   * @assertion_ids: EL:SPEC:49.1
+   * @assertion_ids  EL:SPEC:49.1
    *
-   * @test_Strategy: Validate that when we have variable A set to a specific
+   * @test_Strategy  Validate that when we have variable A set to a specific
    *                 data type that we coerce and receive back the correct value
    *                 and Class type.
    *
@@ -378,7 +378,7 @@
    *
    *                 Exclude: BigDecimal, Float, Double
    *
-   * @since: 3.0
+   * @since 3.0
    *
    */
   @Test
@@ -447,11 +447,11 @@
   } // End elSemiColonOperatorBigIntegerTest
 
   /**
-   * @testName: elSemiColonOperatorIntegerTest
+   * @testName  elSemiColonOperatorIntegerTest
    *
-   * @assertion_ids: EL:SPEC:49.1
+   * @assertion_ids  EL:SPEC:49.1
    *
-   * @test_Strategy: Validate that when we have variable A set to a specific
+   * @test_Strategy  Validate that when we have variable A set to a specific
    *                 data type that we coerce and receive back the correct value
    *                 and Class type.
    *
@@ -466,7 +466,7 @@
    *
    *                 Exclude: BigDecimal, BigInteger, Float, Double
    *
-   * @since: 3.0
+   * @since 3.0
    *
    */
   @Test
@@ -536,11 +536,11 @@
   } // End elSemiColonOperatorIntegerTest
 
   /**
-   * @testName: elSemiColonOperatorLongTest
+   * @testName  elSemiColonOperatorLongTest
    *
-   * @assertion_ids: EL:SPEC:49.1
+   * @assertion_ids  EL:SPEC:49.1
    *
-   * @test_Strategy: Validate that when we have variable A set to a specific
+   * @test_Strategy  Validate that when we have variable A set to a specific
    *                 data type that we coerce and receive back the correct value
    *                 and Class type.
    *
@@ -555,7 +555,7 @@
    *
    *                 Exclude: BigDecimal, BigInteger, Float, Double, Integer
    *
-   * @since: 3.0
+   * @since 3.0
    *
    */
   @Test
@@ -626,11 +626,11 @@
   } // End elSemiColonOperatorLongTest
 
   /**
-   * @testName: elSemiColonOperatorShortTest
+   * @testName  elSemiColonOperatorShortTest
    *
-   * @assertion_ids: EL:SPEC:49.1
+   * @assertion_ids  EL:SPEC:49.1
    *
-   * @test_Strategy: Validate that when we have variable A set to a specific
+   * @test_Strategy  Validate that when we have variable A set to a specific
    *                 data type that we coerce and receive back the correct value
    *                 and Class type.
    *
@@ -646,7 +646,7 @@
    *                 Exclude: BigDecimal, BigInteger, Float, Double, Integer,
    *                 Long
    *
-   * @since: 3.0
+   * @since 3.0
    *
    */
   @Test
@@ -718,11 +718,11 @@
   } // End elSemiColonOperatorShortTest
 
   /**
-   * @testName: elSemiColonOperatorByteTest
+   * @testName  elSemiColonOperatorByteTest
    *
-   * @assertion_ids: EL:SPEC:49.1
+   * @assertion_ids  EL:SPEC:49.1
    *
-   * @test_Strategy: Validate that when we have variable A set to a specific
+   * @test_Strategy  Validate that when we have variable A set to a specific
    *                 data type that we coerce and receive back the correct value
    *                 and Class type.
    *
@@ -738,7 +738,7 @@
    *                 Exclude: BigDecimal, BigInteger, Float, Double, Integer,
    *                 Long, Short
    *
-   * @since: 3.0
+   * @since 3.0
    *
    */
   @Test
@@ -811,11 +811,11 @@
   } // End elSemiColonOperatorByteTest
 
   /**
-   * @testName: elSemiColonOperatorNullTest
+   * @testName  elSemiColonOperatorNullTest
    *
-   * @assertion_ids: EL:SPEC:49.1
+   * @assertion_ids  EL:SPEC:49.1
    *
-   * @test_Strategy: Validate that when we have variable A set to a specific
+   * @test_Strategy  Validate that when we have variable A set to a specific
    *                 data type that we coerce and receive back the correct value
    *                 and Class type.
    *
@@ -827,7 +827,7 @@
    *
    *                 Variable B - null
    *
-   * @since: 3.0
+   * @since 3.0
    *
    */
   @Test
diff --git a/tck/src/main/java/ee/jakarta/tck/el/spec/unaryoperator/ELClientIT.java b/tck/src/main/java/ee/jakarta/tck/el/spec/unaryoperator/ELClientIT.java
index 8e1bc73..7afa318 100644
--- a/tck/src/main/java/ee/jakarta/tck/el/spec/unaryoperator/ELClientIT.java
+++ b/tck/src/main/java/ee/jakarta/tck/el/spec/unaryoperator/ELClientIT.java
@@ -56,11 +56,11 @@
   }
 
   /*
-   * @testName: elNullUnaryTest
+   * @testName  elNullUnaryTest
    *
-   * @assertion_ids: EL:SPEC:20.1
+   * @assertion_ids  EL:SPEC:20.1
    *
-   * @test_Strategy: Validate that if null is passed with the unary minus
+   * @test_Strategy  Validate that if null is passed with the unary minus
    * operator, the result is (Long) 0. Test both ${-null} & #{-null}
    */
   @Test
@@ -92,11 +92,11 @@
   }
 
   /*
-   * @testName: elBigDecimalUnaryTest
+   * @testName  elBigDecimalUnaryTest
    *
-   * @assertion_ids: EL:SPEC:20.2
+   * @assertion_ids  EL:SPEC:20.2
    *
-   * @test_Strategy: Validate that if a BigDecimal A is passed with the unary
+   * @test_Strategy  Validate that if a BigDecimal A is passed with the unary
    * minus operator (-), the result is A.negate(). Test both ${- value} & #{-
    * value}
    */
@@ -131,11 +131,11 @@
   }
 
   /*
-   * @testName: elBigIntegerUnaryTest
+   * @testName  elBigIntegerUnaryTest
    *
-   * @assertion_ids: EL:SPEC:20.2
+   * @assertion_ids  EL:SPEC:20.2
    *
-   * @test_Strategy: Validate that if a BigInteger A is passed with the unary
+   * @test_Strategy  Validate that if a BigInteger A is passed with the unary
    * minus operator (-), the result is A.negate(). Test both ${- value} & #{-
    * value}
    */
@@ -170,11 +170,11 @@
   }
 
   /*
-   * @testName: elDoubleStringUnaryTest
+   * @testName  elDoubleStringUnaryTest
    *
-   * @assertion_ids: EL:SPEC:20.3.1
+   * @assertion_ids  EL:SPEC:20.3.1
    *
-   * @test_Strategy: Validate that if a String is passed with the unary minus
+   * @test_Strategy  Validate that if a String is passed with the unary minus
    * operator (-), the result is as follows: - If the String contains ".", "e",
    * or "E" coerce to Double, apply operator.
    *
@@ -213,11 +213,11 @@
   }
 
   /*
-   * @testName: elLongStringUnaryTest
+   * @testName  elLongStringUnaryTest
    *
-   * @assertion_ids: EL:SPEC:20.3.2
+   * @assertion_ids  EL:SPEC:20.3.2
    *
-   * @test_Strategy: Validate that if a String is passed with the unary minus
+   * @test_Strategy  Validate that if a String is passed with the unary minus
    * operator (-), the result is as follows: - If the String does not contain
    * ".", "e", or "E" coerce to Long, apply operator.
    *
@@ -254,11 +254,11 @@
   }
 
   /*
-   * @testName: elByteUnaryTest
+   * @testName  elByteUnaryTest
    *
-   * @assertion_ids: EL:SPEC:20.4.1
+   * @assertion_ids  EL:SPEC:20.4.1
    *
-   * @test_Strategy: Validate that if a Byte is passed with the unary minus
+   * @test_Strategy  Validate that if a Byte is passed with the unary minus
    * operator (-), the type is retained and the operator is applied.
    *
    * Test both ${- value} & #{- value}
@@ -294,11 +294,11 @@
   }
 
   /*
-   * @testName: elShortUnaryTest
+   * @testName  elShortUnaryTest
    *
-   * @assertion_ids: EL:SPEC:20.4.1
+   * @assertion_ids  EL:SPEC:20.4.1
    *
-   * @test_Strategy: Validate that if a Short is passed with the unary minus
+   * @test_Strategy  Validate that if a Short is passed with the unary minus
    * operator (-), the type is retained and the operator is applied.
    *
    * Test both ${- value} & #{- value}
@@ -334,11 +334,11 @@
   }
 
   /*
-   * @testName: elIntegerUnaryTest
+   * @testName  elIntegerUnaryTest
    *
-   * @assertion_ids: EL:SPEC:20.4.1
+   * @assertion_ids  EL:SPEC:20.4.1
    *
-   * @test_Strategy: Validate that if an Integer is passed with the unary minus
+   * @test_Strategy  Validate that if an Integer is passed with the unary minus
    * operator (-), the type is retained and the operator is applied.
    *
    * Test both ${- value} & #{- value}
@@ -374,11 +374,11 @@
   }
 
   /*
-   * @testName: elLongUnaryTest
+   * @testName  elLongUnaryTest
    *
-   * @assertion_ids: EL:SPEC:20.4.1
+   * @assertion_ids  EL:SPEC:20.4.1
    *
-   * @test_Strategy: Validate that if a Long is passed with the unary minus
+   * @test_Strategy  Validate that if a Long is passed with the unary minus
    * operator (-), the type is retained and the operator is applied.
    *
    * Test both ${- value} & #{- value}
@@ -414,11 +414,11 @@
   }
 
   /*
-   * @testName: elFloatUnaryTest
+   * @testName  elFloatUnaryTest
    *
-   * @assertion_ids: EL:SPEC:20.4.1
+   * @assertion_ids  EL:SPEC:20.4.1
    *
-   * @test_Strategy: Validate that if a Float is passed with the unary minus
+   * @test_Strategy  Validate that if a Float is passed with the unary minus
    * operator (-), the type is retained and the operator is applied.
    *
    * Test both ${- value} & #{- value}
@@ -454,11 +454,11 @@
   }
 
   /*
-   * @testName: elDoubleUnaryTest
+   * @testName  elDoubleUnaryTest
    *
-   * @assertion_ids: EL:SPEC:20.4.1
+   * @assertion_ids  EL:SPEC:20.4.1
    *
-   * @test_Strategy: Validate that if a Double is passed with the unary minus
+   * @test_Strategy  Validate that if a Double is passed with the unary minus
    * operator (-), the type is retained and the operator is applied.
    *
    * Test both ${- value} & #{- value}
@@ -494,11 +494,11 @@
   }
 
   /*
-   * @testName: elBooleanUnaryFalseTest
+   * @testName  elBooleanUnaryFalseTest
    *
-   * @assertion_ids: EL:SPEC:24.1.1
+   * @assertion_ids  EL:SPEC:24.1.1
    *
-   * @test_Strategy: Validate that if a String("false") is passed with the unary
+   * @test_Strategy  Validate that if a String("false") is passed with the unary
    * "not" operator, the type is coerced to Boolean and the operator is applied.
    *
    * Equations Tested: ${not value} & #{not value} ${! value} & #{! value}
@@ -511,11 +511,11 @@
   }
 
   /*
-   * @testName: elBooleanUnaryTrueTest
+   * @testName  elBooleanUnaryTrueTest
    *
-   * @assertion_ids: EL:SPEC:24.1.1
+   * @assertion_ids  EL:SPEC:24.1.1
    *
-   * @test_Strategy: Validate that if a String("true") is passed with the unary
+   * @test_Strategy  Validate that if a String("true") is passed with the unary
    * "not" operator, the type is coerced to Boolean and the operator is applied.
    *
    * Equations Tested: ${not value} & #{not value} ${! value} & #{! value}