diff --git a/appserver/admingui/common/src/main/resources/resourceNode/resourceHandlers.inc b/appserver/admingui/common/src/main/resources/resourceNode/resourceHandlers.inc
index 0a8eff3..09c7eb0 100644
--- a/appserver/admingui/common/src/main/resources/resourceNode/resourceHandlers.inc
+++ b/appserver/admingui/common/src/main/resources/resourceNode/resourceHandlers.inc
@@ -1,6 +1,6 @@
 <!--
 
-    Copyright (c) 1997, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 1997, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -189,9 +189,9 @@
 <handler id="gfr.getJmsDestResources" >
         createMap(result="#{requestScope.resMap}");
         mapPut(map="#{requestScope.resMap}"  key="target" value="domain");
-        mapPut(map="#{requestScope.resMap}"  key="resType" value="javax.jms.Queue");
+        mapPut(map="#{requestScope.resMap}"  key="resType" value="jakarta.jms.Queue");
         gf.restRequest(endpoint="#{sessionScope.REST_URL}/resources/list-jms-resources" attrs="#{requestScope.resMap}" method="get" result="#{requestScope.queue}");
-        mapPut(map="#{requestScope.resMap}"  key="resType" value="javax.jms.Topic");
+        mapPut(map="#{requestScope.resMap}"  key="resType" value="jakarta.jms.Topic");
         gf.restRequest(endpoint="#{sessionScope.REST_URL}/resources/list-jms-resources" attrs="#{requestScope.resMap}" method="get" result="#{requestScope.topic}");
         gf.listCombine(list="#{requestScope.queue.data.extraProperties.jmsResources}" list2="#{requestScope.topic.data.extraProperties.jmsResources}" result="#{requestScope.children}");
 </handler>   
@@ -199,13 +199,13 @@
 <handler id="gfr.getJmsConnectionFactories" >
         createMap(result="#{requestScope.rMap}");
         mapPut(map="#{requestScope.rMap}"  key="target" value="domain");
-        mapPut(map="#{requestScope.rMap}"  key="resType" value="javax.jms.ConnectionFactory");
+        mapPut(map="#{requestScope.rMap}"  key="resType" value="jakarta.jms.ConnectionFactory");
         gf.restRequest(endpoint="#{sessionScope.REST_URL}/resources/list-jms-resources" attrs="#{requestScope.rMap}" method="get" result="#{requestScope.c1}");
 
-        mapPut(map="#{requestScope.rMap}"  key="resType" value="javax.jms.TopicConnectionFactory");
+        mapPut(map="#{requestScope.rMap}"  key="resType" value="jakarta.jms.TopicConnectionFactory");
         gf.restRequest(endpoint="#{sessionScope.REST_URL}/resources/list-jms-resources" attrs="#{requestScope.rMap}" method="get" result="#{requestScope.c2}");
 
-        mapPut(map="#{requestScope.rMap}"  key="resType" value="javax.jms.QueueConnectionFactory");
+        mapPut(map="#{requestScope.rMap}"  key="resType" value="jakarta.jms.QueueConnectionFactory");
         gf.restRequest(endpoint="#{sessionScope.REST_URL}/resources/list-jms-resources" attrs="#{requestScope.rMap}" method="get" result="#{requestScope.c3}");
 
         gf.listCombine(list="#{requestScope.c1.data.extraProperties.jmsResources}" list2="#{requestScope.c2.data.extraProperties.jmsResources}" result="#{requestScope.tmplist}");
diff --git a/appserver/admingui/devtests/src/test/java/org/glassfish/admingui/devtests/ConnectorsTest.java b/appserver/admingui/devtests/src/test/java/org/glassfish/admingui/devtests/ConnectorsTest.java
index 74ef311..d5b9143 100644
--- a/appserver/admingui/devtests/src/test/java/org/glassfish/admingui/devtests/ConnectorsTest.java
+++ b/appserver/admingui/devtests/src/test/java/org/glassfish/admingui/devtests/ConnectorsTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2010, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -55,7 +55,7 @@
         selectDropdownOption("propertyForm:propertySheet:generalPropertySheet:resAdapterProp:db", "jmsra");
         waitForCondition("document.getElementById('propertyForm:propertySheet:generalPropertySheet:connectionDefProp:db').value != ''", 10000);
 
-        selectDropdownOption("propertyForm:propertySheet:generalPropertySheet:connectionDefProp:db", "javax.jms.QueueConnectionFactory");
+        selectDropdownOption("propertyForm:propertySheet:generalPropertySheet:connectionDefProp:db", "jakarta.jms.QueueConnectionFactory");
         waitForButtonEnabled("propertyForm:title:topButtons:nextButton");
 
         clickAndWait("propertyForm:title:topButtons:nextButton", TRIGGER_NEW_CONNECTOR_CONNECTION_POOL_STEP_2);
@@ -120,7 +120,7 @@
         selectDropdownOption("propertyForm:propertySheet:generalPropertySheet:resAdapterProp:db", "jmsra");
         waitForCondition("document.getElementById('propertyForm:propertySheet:generalPropertySheet:connectionDefProp:db').value != ''", 10000);
 
-        selectDropdownOption("propertyForm:propertySheet:generalPropertySheet:connectionDefProp:db", "javax.jms.QueueConnectionFactory");
+        selectDropdownOption("propertyForm:propertySheet:generalPropertySheet:connectionDefProp:db", "jakarta.jms.QueueConnectionFactory");
         waitForButtonEnabled("propertyForm:title:topButtons:nextButton");
 
         clickAndWait("propertyForm:title:topButtons:nextButton", TRIGGER_NEW_CONNECTOR_CONNECTION_POOL_STEP_2);
@@ -218,7 +218,7 @@
         selectDropdownOption("propertyForm:propertySheet:generalPropertySheet:resAdapterProp:db", "jmsra");
         waitForCondition("document.getElementById('propertyForm:propertySheet:generalPropertySheet:connectionDefProp:db').value != ''", 10000);
 
-        selectDropdownOption("propertyForm:propertySheet:generalPropertySheet:connectionDefProp:db", "javax.jms.QueueConnectionFactory");
+        selectDropdownOption("propertyForm:propertySheet:generalPropertySheet:connectionDefProp:db", "jakarta.jms.QueueConnectionFactory");
         waitForButtonEnabled("propertyForm:title:topButtons:nextButton");
 
         clickAndWait("propertyForm:title:topButtons:nextButton", TRIGGER_NEW_CONNECTOR_CONNECTION_POOL_STEP_2);
diff --git a/appserver/admingui/devtests/src/test/java/org/glassfish/admingui/devtests/JmsResourcesTest.java b/appserver/admingui/devtests/src/test/java/org/glassfish/admingui/devtests/JmsResourcesTest.java
index 5af1cdb..ad34323 100644
--- a/appserver/admingui/devtests/src/test/java/org/glassfish/admingui/devtests/JmsResourcesTest.java
+++ b/appserver/admingui/devtests/src/test/java/org/glassfish/admingui/devtests/JmsResourcesTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2010, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -43,7 +43,7 @@
         clickAndWait("propertyForm:resourcesTable:topActionsGroup1:newButton", TRIGGER_NEW_JMS_CONN_FACT);
 
         setFieldValue("form:propertySheet:generalPropertySheet:jndiProp:jndiProp", poolName);
-        selectDropdownOption("form:propertySheet:generalPropertySheet:resTyped:resType", "javax.jms.TopicConnectionFactory");
+        selectDropdownOption("form:propertySheet:generalPropertySheet:resTyped:resType", "jakarta.jms.TopicConnectionFactory");
         setFieldValue("form:propertySheet:generalPropertySheet:descProp:descProp", description);
         selectDropdownOption("form:propertySheet:poolPropertySheet:transprop:trans", "LocalTransaction");
         clickAndWait("form:propertyContentPage:topButtons:newButton", TRIGGER_JMS_CONNECTION_FACTORIES);
@@ -77,7 +77,7 @@
         clickAndWait("propertyForm:resourcesTable:topActionsGroup1:newButton", TRIGGER_NEW_JMS_CONN_FACT);
 
         setFieldValue("form:propertySheet:generalPropertySheet:jndiProp:jndiProp", poolName);
-        selectDropdownOption("form:propertySheet:generalPropertySheet:resTyped:resType", "javax.jms.TopicConnectionFactory"); // i18n?
+        selectDropdownOption("form:propertySheet:generalPropertySheet:resTyped:resType", "jakarta.jms.TopicConnectionFactory"); // i18n?
         setFieldValue("form:propertySheet:generalPropertySheet:descProp:descProp", description);
         selectDropdownOption("form:propertySheet:poolPropertySheet:transprop:trans", "LocalTransaction"); //i18n
         
diff --git a/appserver/admingui/full/src/main/resources/org/glassfish/full/admingui/Strings.properties b/appserver/admingui/full/src/main/resources/org/glassfish/full/admingui/Strings.properties
index 06d8cfb..8801201 100644
--- a/appserver/admingui/full/src/main/resources/org/glassfish/full/admingui/Strings.properties
+++ b/appserver/admingui/full/src/main/resources/org/glassfish/full/admingui/Strings.properties
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2009, 2018 Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 2009, 2020 Oracle and/or its affiliates. All rights reserved.
 #
 # This program and the accompanying materials are made available under the
 # terms of the Eclipse Public License v. 2.0, which is available at
@@ -72,7 +72,7 @@
 jndiResource.newPageTitle=New External Resource
 jndiResource.newPageTitleHelp=Create an external JNDI resource so that applications can gain access to resources stored in an external repository.
 externalResource.targetPageTitle=External Resource Targets
-jndiResource.resTypeHelp=Enter a fully qualified type following the format xxx.xxx (for example, javax.jms.Topic)
+jndiResource.resTypeHelp=Enter a fully qualified type following the format xxx.xxx (for example, jakarta.jms.Topic)
 jndiResource.factoryClass= Factory Class:
 jndiResource.factoryClassHelp=Factory class for resource; implements javax.naming.spi.ObjectFactory
 jndiResource.jndiLookup=JNDI Lookup:
diff --git a/appserver/admingui/jca/src/main/help/en/help/ref-adminobjectedit.html b/appserver/admingui/jca/src/main/help/en/help/ref-adminobjectedit.html
index 86258d0..ef1cc18 100644
--- a/appserver/admingui/jca/src/main/help/en/help/ref-adminobjectedit.html
+++ b/appserver/admingui/jca/src/main/help/en/help/ref-adminobjectedit.html
@@ -1,6 +1,6 @@
 <!--
 
-    Copyright (c) 2005, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2005, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -37,7 +37,7 @@
 </dd>
 <dt>Resource Type</dt>
 <dd>
-<p>The Java type for the administered object resource (or example, <code>javax.jms.Topic</code>).</p>
+<p>The Java type for the administered object resource (or example, <code>jakarta.jms.Topic</code>).</p>
 </dd>
 <dt>Class Name</dt>
 <dd>
diff --git a/appserver/admingui/jca/src/main/help/en/help/ref-adminobjectnew.html b/appserver/admingui/jca/src/main/help/en/help/ref-adminobjectnew.html
index d43a614..246a62b 100644
--- a/appserver/admingui/jca/src/main/help/en/help/ref-adminobjectnew.html
+++ b/appserver/admingui/jca/src/main/help/en/help/ref-adminobjectnew.html
@@ -1,6 +1,6 @@
 <!--
 
-    Copyright (c) 2005, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2005, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -33,7 +33,7 @@
 </dd>
 <dt>Resource Type</dt>
 <dd>
-<p>The Java type for the administered object resource (or example, <code>javax.jms.Topic</code>).</p>
+<p>The Java type for the administered object resource (or example, <code>jakarta.jms.Topic</code>).</p>
 </dd>
 <dt>Class Name</dt>
 <dd>
diff --git a/appserver/admingui/jms-plugin/src/main/help/en/help/ref-jmsconnectionnew.html b/appserver/admingui/jms-plugin/src/main/help/en/help/ref-jmsconnectionnew.html
index d57c6aa..6fba49e 100644
--- a/appserver/admingui/jms-plugin/src/main/help/en/help/ref-jmsconnectionnew.html
+++ b/appserver/admingui/jms-plugin/src/main/help/en/help/ref-jmsconnectionnew.html
@@ -1,6 +1,6 @@
 <!--
 
-    Copyright (c) 2005, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2005, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -29,7 +29,7 @@
 </dd>
 <dt>Resource Type</dt>
 <dd>
-<p>The type of the connection factory. Available choices are <code>javax.jms.ConnectionFactory</code>, <code>javax.jms.QueueConnectionFactory</code>, and <code>javax.jms.TopicConnectionFactory</code>.</p>
+<p>The type of the connection factory. Available choices are <code>jakarta.jms.ConnectionFactory</code>, <code>jakarta.jms.QueueConnectionFactory</code>, and <code>jakarta.jms.TopicConnectionFactory</code>.</p>
 </dd>
 <dt>Description</dt>
 <dd>
diff --git a/appserver/admingui/jms-plugin/src/main/help/en/help/ref-jmsdestinationedit.html b/appserver/admingui/jms-plugin/src/main/help/en/help/ref-jmsdestinationedit.html
index bd889d2..11c69eb 100644
--- a/appserver/admingui/jms-plugin/src/main/help/en/help/ref-jmsdestinationedit.html
+++ b/appserver/admingui/jms-plugin/src/main/help/en/help/ref-jmsdestinationedit.html
@@ -1,6 +1,6 @@
 <!--
 
-    Copyright (c) 2005, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2005, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -38,7 +38,7 @@
 </dd>
 <dt>Resource Type</dt>
 <dd>
-<p>The type of the destination resource. Available choices are <code>javax.jms.Topic</code> and <code>javax.jms.Queue</code>.</p>
+<p>The type of the destination resource. Available choices are <code>jakarta.jms.Topic</code> and <code>jakarta.jms.Queue</code>.</p>
 </dd>
 <dt>Deployment Order</dt>
 <dd>
diff --git a/appserver/admingui/jms-plugin/src/main/help/en/help/ref-jmsdestinationnew.html b/appserver/admingui/jms-plugin/src/main/help/en/help/ref-jmsdestinationnew.html
index 6dcb564..9a4f052 100644
--- a/appserver/admingui/jms-plugin/src/main/help/en/help/ref-jmsdestinationnew.html
+++ b/appserver/admingui/jms-plugin/src/main/help/en/help/ref-jmsdestinationnew.html
@@ -1,6 +1,6 @@
 <!--
 
-    Copyright (c) 2005, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2005, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -35,7 +35,7 @@
 </dd>
 <dt>Resource Type</dt>
 <dd>
-<p>The type of the destination resource. Available choices are <code>javax.jms.Topic</code> and <code>javax.jms.Queue</code>.</p>
+<p>The type of the destination resource. Available choices are <code>jakarta.jms.Topic</code> and <code>jakarta.jms.Queue</code>.</p>
 </dd>
 <dt>Description</dt>
 <dd>
diff --git a/appserver/admingui/jms-plugin/src/main/help/en/help/ref-jmsphysicaldestnew.html b/appserver/admingui/jms-plugin/src/main/help/en/help/ref-jmsphysicaldestnew.html
index d6a89eb..af2d66d 100644
--- a/appserver/admingui/jms-plugin/src/main/help/en/help/ref-jmsphysicaldestnew.html
+++ b/appserver/admingui/jms-plugin/src/main/help/en/help/ref-jmsphysicaldestnew.html
@@ -1,6 +1,6 @@
 <!--
 
-    Copyright (c) 2005, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2005, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -30,7 +30,7 @@
 </dd>
 <dt>Type</dt>
 <dd>
-<p>The type of the physical destination. Available choices are <code>javax.jms.Topic</code> and <code>javax.jms.Queue</code>.</p>
+<p>The type of the physical destination. Available choices are <code>jakarta.jms.Topic</code> and <code>jakarta.jms.Queue</code>.</p>
 </dd>
 <dt>Maximum Number of Unconsumed Messages</dt>
 <dd>
diff --git a/appserver/admingui/jms-plugin/src/main/help/en/help/task-jmsconnectionnew.html b/appserver/admingui/jms-plugin/src/main/help/en/help/task-jmsconnectionnew.html
index f393aa4..bfcf157 100644
--- a/appserver/admingui/jms-plugin/src/main/help/en/help/task-jmsconnectionnew.html
+++ b/appserver/admingui/jms-plugin/src/main/help/en/help/task-jmsconnectionnew.html
@@ -1,6 +1,6 @@
 <!--
 
-    Copyright (c) 2005, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2005, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -41,7 +41,7 @@
 <p>GlassFish Server sets the JNDI name of the connection factory to this value..</p>
 </li>
 <li>
-<p>From the Resource Type drop-down list, select either <code>javax.jms.ConnectionFactory</code>, <code>javax.jms.QueueConnectionFactory</code>, or <code>javax.jms.TopicConnectionFactory</code>.</p>
+<p>From the Resource Type drop-down list, select either <code>jakarta.jms.ConnectionFactory</code>, <code>jakarta.jms.QueueConnectionFactory</code>, or <code>jakarta.jms.TopicConnectionFactory</code>.</p>
 </li>
 <li>
 <p>In the Description field, type a description of the connection factory.</p>
diff --git a/appserver/admingui/jms-plugin/src/main/help/en/help/task-jmsdestinationedit.html b/appserver/admingui/jms-plugin/src/main/help/en/help/task-jmsdestinationedit.html
index f3a3bdc..76297ef 100644
--- a/appserver/admingui/jms-plugin/src/main/help/en/help/task-jmsdestinationedit.html
+++ b/appserver/admingui/jms-plugin/src/main/help/en/help/task-jmsdestinationedit.html
@@ -1,6 +1,6 @@
 <!--
 
-    Copyright (c) 2005, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2005, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -40,7 +40,7 @@
 <p>GlassFish Server creates the physical destination automatically when it is needed and deletes it when you delete the destination resource.</p>
 </li>
 <li>
-<p>From the Resource Type drop-down list, select either <code>javax.jms.Topic</code> or <code>javax.jms.Queue</code>.</p>
+<p>From the Resource Type drop-down list, select either <code>jakarta.jms.Topic</code> or <code>jakarta.jms.Queue</code>.</p>
 </li>
 <li>
 <p>In the Description field, type a description of the destination resource.</p>
diff --git a/appserver/admingui/jms-plugin/src/main/help/en/help/task-jmsdestinationnew.html b/appserver/admingui/jms-plugin/src/main/help/en/help/task-jmsdestinationnew.html
index b2cad95..2bcde00 100644
--- a/appserver/admingui/jms-plugin/src/main/help/en/help/task-jmsdestinationnew.html
+++ b/appserver/admingui/jms-plugin/src/main/help/en/help/task-jmsdestinationnew.html
@@ -1,6 +1,6 @@
 <!--
 
-    Copyright (c) 2005, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2005, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -45,7 +45,7 @@
 <p>GlassFish Server creates the physical destination automatically when it is needed and deletes it when you delete the destination resource.</p>
 </li>
 <li>
-<p>From the Resource Type drop-down list, select either <code>javax.jms.Topic</code> or <code>javax.jms.Queue</code>.</p>
+<p>From the Resource Type drop-down list, select either <code>jakarta.jms.Topic</code> or <code>jakarta.jms.Queue</code>.</p>
 </li>
 <li>
 <p>In the Description field, type a description of the destination resource.</p>
diff --git a/appserver/admingui/jms-plugin/src/main/help/en/help/task-jmsphysicaldestnew.html b/appserver/admingui/jms-plugin/src/main/help/en/help/task-jmsphysicaldestnew.html
index 5a38754..754cbb7 100644
--- a/appserver/admingui/jms-plugin/src/main/help/en/help/task-jmsphysicaldestnew.html
+++ b/appserver/admingui/jms-plugin/src/main/help/en/help/task-jmsphysicaldestnew.html
@@ -1,6 +1,6 @@
 <!--
 
-    Copyright (c) 2005, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2005, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -51,7 +51,7 @@
 <p>In the Name field, type the name of the physical destination.</p>
 </li>
 <li>
-<p>From the Type drop-down list, select either <code>javax.jms.Topic</code> or <code>javax.jms.Queue</code>.</p>
+<p>From the Type drop-down list, select either <code>jakarta.jms.Topic</code> or <code>jakarta.jms.Queue</code>.</p>
 </li>
 <li>
 <p>In the Maximum Number of Unconsumed Messages field, type the maximum number of unconsumed messages permitted for the destination.</p>
diff --git a/appserver/admingui/jms-plugin/src/main/resources/jmsDestinationSheet.inc b/appserver/admingui/jms-plugin/src/main/resources/jmsDestinationSheet.inc
index 5904807..fc62291 100644
--- a/appserver/admingui/jms-plugin/src/main/resources/jmsDestinationSheet.inc
+++ b/appserver/admingui/jms-plugin/src/main/resources/jmsDestinationSheet.inc
@@ -1,6 +1,6 @@
 <!--
 
-    Copyright (c) 2009, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2009, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -42,7 +42,7 @@
         </sun:property>
 
         <sun:property id="resTypeProp" labelAlign="left" noWrap="#{true}" overlapLabel="#{false}" label="$resource{i18n.common.resType}"  >
-            <sun:dropDown id="resType" selected="#{pageSession.valueMap['resType']}" labels={"javax.jms.Topic"  "javax.jms.Queue"}  required="#{true}"/>
+            <sun:dropDown id="resType" selected="#{pageSession.valueMap['resType']}" labels={"jakarta.jms.Topic"  "jakarta.jms.Queue"}  required="#{true}"/>
         </sun:property>
 
         <sun:property id="deploymentOrder" labelAlign="left" noWrap="#{true}" overlapLabel="#{false}"  rendered="#{edit}" label="$resource{i18n.common.resource.deploymentOrder}" helpText="$resource{i18n.common.resource.deploymentOrderHelp}">
diff --git a/appserver/admingui/jms-plugin/src/main/resources/physdest/jmsPhysicalDestinationSheet.inc b/appserver/admingui/jms-plugin/src/main/resources/physdest/jmsPhysicalDestinationSheet.inc
index 585d1f5..e6da6d0 100644
--- a/appserver/admingui/jms-plugin/src/main/resources/physdest/jmsPhysicalDestinationSheet.inc
+++ b/appserver/admingui/jms-plugin/src/main/resources/physdest/jmsPhysicalDestinationSheet.inc
@@ -1,6 +1,6 @@
 <!--
 
-    Copyright (c) 2009, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2009, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -81,7 +81,7 @@
         <sun:property id="typeProp"  labelAlign="left" noWrap="#{true}" overlapLabel="#{false}" label="$resource{i18njms.jmsPhysDestinations.type}">
             <h:outputText id="TypeStatic" rendered="#{edit}" value="#{pageSession.destType}"/>
             <h:inputHidden rendered="#{edit}" value="#{pageSession.destType}" />
-            <sun:dropDown id="type" rendered="#{!edit}" labels={"javax.jms.Topic" "javax.jms.Queue"} values={"topic" "queue"} selected="#{type}"/>
+            <sun:dropDown id="type" rendered="#{!edit}" labels={"jakarta.jms.Topic" "jakarta.jms.Queue"} values={"topic" "queue"} selected="#{type}"/>
         </sun:property>
 
         <sun:property id="maxNumMsgsProp" labelAlign="left" noWrap="#{false}" overlapLabel="#{false}" label="$resource{i18njms.jmsPhysDestinations.MaxNumMsgs}" helpText="$resource{i18njms.jmsPhysDestinations.MaxNumMsgsHelp}" >
diff --git a/appserver/admingui/jms-plugin/src/main/resources/poolProperties.inc b/appserver/admingui/jms-plugin/src/main/resources/poolProperties.inc
index a5210a4..79a9867 100644
--- a/appserver/admingui/jms-plugin/src/main/resources/poolProperties.inc
+++ b/appserver/admingui/jms-plugin/src/main/resources/poolProperties.inc
@@ -1,6 +1,6 @@
 <!--
 
-    Copyright (c) 1997, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 1997, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -38,7 +38,7 @@
                 
         <sun:property id="resTyped"  labelAlign="left" noWrap="#{true}" overlapLabel="#{false}" label="$resource{i18n.common.resType}">
             <sun:dropDown id="resType" selected="#{pageSession.valueMap['connectionDefinitionName']}" rendered="#{!edit}"
-                labels={"javax.jms.TopicConnectionFactory","javax.jms.QueueConnectionFactory","javax.jms.ConnectionFactory"} />
+                labels={"jakarta.jms.TopicConnectionFactory","jakarta.jms.QueueConnectionFactory","jakarta.jms.ConnectionFactory"} />
             <sun:staticText text="#{pageSession.valueMap['connectionDefinitionName']}" rendered="#{edit}"/>
         </sun:property>
                 
diff --git a/appserver/connectors/admin/src/main/manpages/org/glassfish/connectors/admin/cli/create-admin-object.1 b/appserver/connectors/admin/src/main/manpages/org/glassfish/connectors/admin/cli/create-admin-object.1
index b08a877..be5517c 100644
--- a/appserver/connectors/admin/src/main/manpages/org/glassfish/connectors/admin/cli/create-admin-object.1
+++ b/appserver/connectors/admin/src/main/manpages/org/glassfish/connectors/admin/cli/create-admin-object.1
@@ -89,9 +89,9 @@
 EXAMPLES
        Example 1, Creating an Administered Object
            In this example, jmsra is a system resource adapter with the admin
-           object interfaces, javax.jms.Queue and javax.jms.Topic.
+           object interfaces, jakarta.jms.Queue and jakarta.jms.Topic.
 
-               asadmin> create-admin-object --restype javax.jms.Queue
+               asadmin> create-admin-object --restype jakarta.jms.Queue
                --raname jmsra --description "sample administered object"
                --property Name=sample_jmsqueue jms/samplequeue
                Command create-admin-object executed successfully
diff --git a/appserver/connectors/admin/src/main/manpages/org/glassfish/connectors/admin/cli/create-connector-connection-pool.1 b/appserver/connectors/admin/src/main/manpages/org/glassfish/connectors/admin/cli/create-connector-connection-pool.1
index 58e6a9a..9bb1c25 100644
--- a/appserver/connectors/admin/src/main/manpages/org/glassfish/connectors/admin/cli/create-connector-connection-pool.1
+++ b/appserver/connectors/admin/src/main/manpages/org/glassfish/connectors/admin/cli/create-connector-connection-pool.1
@@ -250,7 +250,7 @@
            jms/qConnPool.
 
                asadmin> create-connector-connection-pool --raname jmsra
-               --connectiondefinition javax.jms.QueueConnectionFactory --steadypoolsize 20
+               --connectiondefinition jakarta.jms.QueueConnectionFactory --steadypoolsize 20
                --maxpoolsize 100 --poolresize 2 --maxwait 60000 jms/qConnPool
                Command create-connector-connection-pool executed successfully
 
diff --git a/appserver/connectors/connectors-inbound-runtime/src/main/java/com/sun/enterprise/connectors/inbound/ConnectorMessageBeanClient.java b/appserver/connectors/connectors-inbound-runtime/src/main/java/com/sun/enterprise/connectors/inbound/ConnectorMessageBeanClient.java
index 6b616e5..f90f679 100755
--- a/appserver/connectors/connectors-inbound-runtime/src/main/java/com/sun/enterprise/connectors/inbound/ConnectorMessageBeanClient.java
+++ b/appserver/connectors/connectors-inbound-runtime/src/main/java/com/sun/enterprise/connectors/inbound/ConnectorMessageBeanClient.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -199,7 +199,7 @@
     /**
      * derive the resource-adapter-mid in the following order <br/>
      * a) specified in the glassfish-ejb-jar / sun-ejb-jar descriptor<br/>
-     * b) jms-ra message-listener of type javax.jms.MessageListener<br/>
+     * b) jms-ra message-listener of type jakarta.jms.MessageListener<br/>
      * c) Check the resource-adapters supporting the message-listener-type and
      * if there is only one use it, otherwise fail.<br/>
      * @param descriptor_ EJB Descriptor
@@ -214,7 +214,7 @@
 
         if (resourceAdapterMid == null) {
             String messageListener = descriptor_.getMessageListenerType();
-            //DOL of MDB descriptor has default value as "javax.jms.MessageListener" which
+            //DOL of MDB descriptor has default value as "jakarta.jms.MessageListener" which
             //will take care of the case when the message-listener-type is not specified in the DD
             if(ConnectorConstants.JMS_MESSAGE_LISTENER.equals(messageListener)){
                 resourceAdapterMid = ConnectorRuntime.DEFAULT_JMS_ADAPTER;
@@ -266,7 +266,7 @@
     private MessageListener getMessageListener(ConnectorDescriptor desc) {
         String msgListenerType = getDescriptor().getMessageListenerType();
         if (msgListenerType == null || "".equals(msgListenerType))
-            msgListenerType = "javax.jms.MessageListener";
+            msgListenerType = "jakarta.jms.MessageListener";
 
         Iterator i =
                 desc.getInboundResourceAdapter().getMessageListeners().iterator();
diff --git a/appserver/connectors/connectors-inbound-runtime/src/main/java/com/sun/enterprise/connectors/inbound/MessageEndpointInvocationHandler.java b/appserver/connectors/connectors-inbound-runtime/src/main/java/com/sun/enterprise/connectors/inbound/MessageEndpointInvocationHandler.java
index 568ba2f..d7d0830 100755
--- a/appserver/connectors/connectors-inbound-runtime/src/main/java/com/sun/enterprise/connectors/inbound/MessageEndpointInvocationHandler.java
+++ b/appserver/connectors/connectors-inbound-runtime/src/main/java/com/sun/enterprise/connectors/inbound/MessageEndpointInvocationHandler.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -33,7 +33,7 @@
 /**
  * This class handles the implementation of two interfaces:
  * 1) javax.resource.spi.endpoint.MessageEndpoint;
- * 2) any message listener type (e.g. javax.jms.MessageListener,
+ * 2) any message listener type (e.g. jakarta.jms.MessageListener,
  * OR javax.xml.messaging.OnewayListener)
  *
  * @author Qingqing Ouyang
diff --git a/appserver/connectors/connectors-runtime/src/main/java/com/sun/enterprise/resource/deployer/JMSConnectionFactoryDefinitionDeployer.java b/appserver/connectors/connectors-runtime/src/main/java/com/sun/enterprise/resource/deployer/JMSConnectionFactoryDefinitionDeployer.java
index f85b218..8d37635 100644
--- a/appserver/connectors/connectors-runtime/src/main/java/com/sun/enterprise/resource/deployer/JMSConnectionFactoryDefinitionDeployer.java
+++ b/appserver/connectors/connectors-runtime/src/main/java/com/sun/enterprise/resource/deployer/JMSConnectionFactoryDefinitionDeployer.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -454,7 +454,7 @@
             if (isValidProperty(interfaceName)) {
                 return interfaceName;
             } else {
-                return "javax.jms.ConnectionFactory";
+                return "jakarta.jms.ConnectionFactory";
             }
         }
 
diff --git a/appserver/core/api-exporter-fragment/pom.xml b/appserver/core/api-exporter-fragment/pom.xml
index f540319..c67a85f 100755
--- a/appserver/core/api-exporter-fragment/pom.xml
+++ b/appserver/core/api-exporter-fragment/pom.xml
@@ -139,8 +139,8 @@
 javax.imageio.spi; \
 javax.imageio.stream; \
 javax.interceptor; \
-javax.jms; \
 jakarta.json; \
+jakarta.jms; \
 javax.json.bind; \
 javax.json.bind.adapter; \
 javax.json.bind.annotation; \
diff --git a/appserver/deployment/dol/src/main/java/com/sun/enterprise/deployment/ResourceEnvReference.java b/appserver/deployment/dol/src/main/java/com/sun/enterprise/deployment/ResourceEnvReference.java
index cfb7701..2b95685 100644
--- a/appserver/deployment/dol/src/main/java/com/sun/enterprise/deployment/ResourceEnvReference.java
+++ b/appserver/deployment/dol/src/main/java/com/sun/enterprise/deployment/ResourceEnvReference.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -30,7 +30,7 @@
     public String getName();
     public void setName(String refName);
 
-    /* Gets the type(javax.jms.Queue, javax.jms.Topic) of the destination */
+    /* Gets the type(jakarta.jms.Queue, jakarta.jms.Topic) of the destination */
     public String getType();
     public void setType(String refType);
 
diff --git a/appserver/deployment/dol/src/main/java/com/sun/enterprise/deployment/ResourceReferenceDescriptor.java b/appserver/deployment/dol/src/main/java/com/sun/enterprise/deployment/ResourceReferenceDescriptor.java
index 9c90c4f..cfce765 100644
--- a/appserver/deployment/dol/src/main/java/com/sun/enterprise/deployment/ResourceReferenceDescriptor.java
+++ b/appserver/deployment/dol/src/main/java/com/sun/enterprise/deployment/ResourceReferenceDescriptor.java
@@ -302,8 +302,8 @@
     public boolean isJMSConnectionFactory() {
         String myType = this.getType();
         return 
-            ( myType.equals("javax.jms.QueueConnectionFactory") ||
-              myType.equals("javax.jms.TopicConnectionFactory") );
+            ( myType.equals("jakarta.jms.QueueConnectionFactory") ||
+              myType.equals("jakarta.jms.TopicConnectionFactory") );
     }
     
     /**
diff --git a/appserver/deployment/dol/src/main/java/com/sun/enterprise/deployment/annotation/handlers/ResourceHandler.java b/appserver/deployment/dol/src/main/java/com/sun/enterprise/deployment/annotation/handlers/ResourceHandler.java
index 2fd71eb..80d2f04 100644
--- a/appserver/deployment/dol/src/main/java/com/sun/enterprise/deployment/annotation/handlers/ResourceHandler.java
+++ b/appserver/deployment/dol/src/main/java/com/sun/enterprise/deployment/annotation/handlers/ResourceHandler.java
@@ -278,8 +278,8 @@
         }   catch(Exception e) {
             // we don't care, either we don't have the class, ot the bundled is not installed
         }
-        if (resourceType.getName().equals("javax.jms.Queue") ||
-                resourceType.getName().equals("javax.jms.Topic")) {
+        if (resourceType.getName().equals("jakarta.jms.Queue") ||
+                resourceType.getName().equals("jakarta.jms.Topic")) {
             return getMessageDestinationReferenceDescriptors(
                                                     logicalName, rcContexts);
         } else if (envEntryTypes.containsKey(resourceType) ||
@@ -287,18 +287,18 @@
             return getEnvironmentPropertyDescriptors(logicalName, rcContexts,
                                                     resourceAn);
         } else if (resourceType == javax.sql.DataSource.class ||
-                resourceType.getName().equals("javax.jms.ConnectionFactory") ||
-                resourceType.getName().equals("javax.jms.QueueConnectionFactory") ||
-                resourceType.getName().equals("javax.jms.TopicConnectionFactory") ||
+                resourceType.getName().equals("jakarta.jms.ConnectionFactory") ||
+                resourceType.getName().equals("jakarta.jms.QueueConnectionFactory") ||
+                resourceType.getName().equals("jakarta.jms.TopicConnectionFactory") ||
                 resourceType == webServiceContext ||
                 resourceType.getName().equals("jakarta.mail.Session") || 
                 resourceType.getName().equals("java.net.URL") ||
                 resourceType.getName().equals("javax.resource.cci.ConnectionFactory") ||
                 resourceType == org.omg.CORBA_2_3.ORB.class || 
                 resourceType == org.omg.CORBA.ORB.class || 
-                resourceType.getName().equals("javax.jms.XAConnectionFactory") ||
-                resourceType.getName().equals("javax.jms.XAQueueConnectionFactory") ||
-                resourceType.getName().equals("javax.jms.XATopicConnectionFactory") || 
+                resourceType.getName().equals("jakarta.jms.XAConnectionFactory") ||
+                resourceType.getName().equals("jakarta.jms.XAQueueConnectionFactory") ||
+                resourceType.getName().equals("jakarta.jms.XATopicConnectionFactory") || 
                 DOLUtils.isRAConnectionFactory(habitat, resourceType.getName(), ((ResourceContainerContextImpl)rcContexts[0]).getAppFromDescriptor()) ) {
             return getResourceReferenceDescriptors(logicalName, rcContexts);
         } else {
diff --git a/appserver/deployment/dol/src/main/java/com/sun/enterprise/deployment/util/ComponentValidator.java b/appserver/deployment/dol/src/main/java/com/sun/enterprise/deployment/util/ComponentValidator.java
index 68a49c6..9d4db1b 100644
--- a/appserver/deployment/dol/src/main/java/com/sun/enterprise/deployment/util/ComponentValidator.java
+++ b/appserver/deployment/dol/src/main/java/com/sun/enterprise/deployment/util/ComponentValidator.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -959,7 +959,7 @@
             if (resRef.getType() != null) {
                 if (resRef.getType().equals("javax.sql.DataSource"))
                     resRef.setLookupName("java:comp/DefaultDataSource");
-                else if (resRef.getType().equals("javax.jms.ConnectionFactory"))
+                else if (resRef.getType().equals("jakarta.jms.ConnectionFactory"))
                     resRef.setLookupName("java:comp/DefaultJMSConnectionFactory");
                 else
                     resRef.setJndiName(getDefaultResourceJndiName(resRef.getName()));
diff --git a/appserver/deployment/dol/src/main/java/com/sun/enterprise/deployment/xml/TagNames.java b/appserver/deployment/dol/src/main/java/com/sun/enterprise/deployment/xml/TagNames.java
index 0ed0c3c..ab387d4 100644
--- a/appserver/deployment/dol/src/main/java/com/sun/enterprise/deployment/xml/TagNames.java
+++ b/appserver/deployment/dol/src/main/java/com/sun/enterprise/deployment/xml/TagNames.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -150,8 +150,8 @@
     public static final String PERSISTENCE_UNIT_REF = "persistence-unit-ref";
     public static final String PERSISTENCE_UNIT_REF_NAME = "persistence-unit-ref-name";
 
-    public static final String JMS_QUEUE_DEST_TYPE = "javax.jms.Queue";
-    public static final String JMS_TOPIC_DEST_TYPE = "javax.jms.Topic";
+    public static final String JMS_QUEUE_DEST_TYPE = "jakarta.jms.Queue";
+    public static final String JMS_TOPIC_DEST_TYPE = "jakarta.jms.Topic";
 
     public static final String RESOURCE_TYPE = "res-type";
     public static final String RESOURCE_AUTHORIZATION = "res-auth";
diff --git a/appserver/ejb/ejb-container/src/main/java/org/glassfish/ejb/deployment/descriptor/EjbMessageBeanDescriptor.java b/appserver/ejb/ejb-container/src/main/java/org/glassfish/ejb/deployment/descriptor/EjbMessageBeanDescriptor.java
index 9208896..27fb98f 100644
--- a/appserver/ejb/ejb-container/src/main/java/org/glassfish/ejb/deployment/descriptor/EjbMessageBeanDescriptor.java
+++ b/appserver/ejb/ejb-container/src/main/java/org/glassfish/ejb/deployment/descriptor/EjbMessageBeanDescriptor.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -48,7 +48,7 @@
     private static LocalStringManagerImpl localStrings =
 	    new LocalStringManagerImpl(EjbMessageBeanDescriptor.class); 
 
-    private String messageListenerType = "javax.jms.MessageListener";
+    private String messageListenerType = "jakarta.jms.MessageListener";
 
     // These are the method objects from the 
     // *message-bean implementation class* that implement the
@@ -415,12 +415,12 @@
 
     public boolean hasQueueDest() {
         return ( (destinationType != null) && 
-                 (destinationType.equals("javax.jms.Queue")) );
+                 (destinationType.equals("jakarta.jms.Queue")) );
     }
 
     public boolean hasTopicDest() {
         return ( (destinationType != null) && 
-                 (destinationType.equals("javax.jms.Topic")) );
+                 (destinationType.equals("jakarta.jms.Topic")) );
     }
 
     public boolean hasDestinationType() {
@@ -454,12 +454,12 @@
 
 
     public void setHasQueueDest() {
-        destinationType = "javax.jms.Queue";
+        destinationType = "jakarta.jms.Queue";
         setHasDurableSubscription(false);
     }
 
     public void setHasTopicDest() {
-        destinationType = "javax.jms.Topic";
+        destinationType = "jakarta.jms.Topic";
 
     }
     
diff --git a/appserver/ejb/ejb-full-container/src/main/java/org/glassfish/ejb/mdb/MessageBeanContainer.java b/appserver/ejb/ejb-full-container/src/main/java/org/glassfish/ejb/mdb/MessageBeanContainer.java
index af646db..1d7fe55 100644
--- a/appserver/ejb/ejb-full-container/src/main/java/org/glassfish/ejb/mdb/MessageBeanContainer.java
+++ b/appserver/ejb/ejb-full-container/src/main/java/org/glassfish/ejb/mdb/MessageBeanContainer.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,7 +16,6 @@
 
 package org.glassfish.ejb.mdb;
 
-import java.lang.annotation.Annotation;
 import java.lang.reflect.InvocationHandler;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
@@ -689,7 +688,7 @@
     /**
      * @param method
      *            One of the methods used to deliver messages, e.g. onMessage
-     *            method for javax.jms.MessageListener. Note that if the
+     *            method for jakarta.jms.MessageListener. Note that if the
      *            <code>method</code> is not one of the methods for message
      *            delivery, the behavior of this method is not defined.
      */
@@ -1205,7 +1204,7 @@
                 // any restrictions on what kind of exceptions can be thrown.
                 // This was not the case in J2EE 1.3, since JMS message driven
                 // beans could only implement
-                // void javax.jms.MessageListener.onMessage() , which does
+                // void jakarta.jms.MessageListener.onMessage() , which does
                 // not declare any exceptions.
                 // 
                 // In the J2EE 1.3 implementation, exceptions were only
diff --git a/appserver/ejb/ejb-full-container/src/main/java/org/glassfish/ejb/mdb/deployment/annotation/handlers/MessageDrivenHandler.java b/appserver/ejb/ejb-full-container/src/main/java/org/glassfish/ejb/mdb/deployment/annotation/handlers/MessageDrivenHandler.java
index aaab739..4fd09fb 100644
--- a/appserver/ejb/ejb-full-container/src/main/java/org/glassfish/ejb/mdb/deployment/annotation/handlers/MessageDrivenHandler.java
+++ b/appserver/ejb/ejb-full-container/src/main/java/org/glassfish/ejb/mdb/deployment/annotation/handlers/MessageDrivenHandler.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -158,7 +158,7 @@
         // if it's still null, check whether it's defined through
         // deployment descriptor
         // note: the descriptor class has a default value 
-        // for the interface: javax.jms.MessageListener
+        // for the interface: jakarta.jms.MessageListener
         // so intfName after this set, will never be null
         if (intfName == null) {
             intfName = msgEjbDesc.getMessageListenerType();
diff --git a/appserver/ejb/ejb-internal-api/src/main/java/org/glassfish/ejb/api/MessageBeanProtocolManager.java b/appserver/ejb/ejb-internal-api/src/main/java/org/glassfish/ejb/api/MessageBeanProtocolManager.java
index 89b7a6d..1771a8e 100644
--- a/appserver/ejb/ejb-internal-api/src/main/java/org/glassfish/ejb/api/MessageBeanProtocolManager.java
+++ b/appserver/ejb/ejb-internal-api/src/main/java/org/glassfish/ejb/api/MessageBeanProtocolManager.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -64,7 +64,7 @@
      * on message delivery.
      *
      * @param method One of the methods used to deliver messages, e.g.
-     *               onMessage method for javax.jms.MessageListener.
+     *               onMessage method for jakarta.jms.MessageListener.
      *               Note that if the <code>method</code> is not one 
      *               of the methods for message delivery, the behavior 
      *               of this method is not defined.
diff --git a/appserver/jms/admin/src/main/java/org/glassfish/jms/admin/cli/CreateJMSResource.java b/appserver/jms/admin/src/main/java/org/glassfish/jms/admin/cli/CreateJMSResource.java
index dd30ebf..6e5038b 100644
--- a/appserver/jms/admin/src/main/java/org/glassfish/jms/admin/cli/CreateJMSResource.java
+++ b/appserver/jms/admin/src/main/java/org/glassfish/jms/admin/cli/CreateJMSResource.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -85,11 +85,11 @@
     Domain domain;
     //ConnectorConnectionPool[] connPools;
 
-    private static final String QUEUE = "javax.jms.Queue";
-    private static final String TOPIC = "javax.jms.Topic";
-    private static final String QUEUE_CF = "javax.jms.QueueConnectionFactory";
-    private static final String TOPIC_CF = "javax.jms.TopicConnectionFactory";
-    private static final String UNIFIED_CF = "javax.jms.ConnectionFactory";
+    private static final String QUEUE = "jakarta.jms.Queue";
+    private static final String TOPIC = "jakarta.jms.Topic";
+    private static final String QUEUE_CF = "jakarta.jms.QueueConnectionFactory";
+    private static final String TOPIC_CF = "jakarta.jms.TopicConnectionFactory";
+    private static final String UNIFIED_CF = "jakarta.jms.ConnectionFactory";
     private static final String DEFAULT_JMS_ADAPTER = "jmsra";
     private static final String DEFAULT_OPERAND="DEFAULT";
     private static final String JNDINAME_APPENDER="-Connection-Pool";
diff --git a/appserver/jms/admin/src/main/java/org/glassfish/jms/admin/cli/JMSPing.java b/appserver/jms/admin/src/main/java/org/glassfish/jms/admin/cli/JMSPing.java
index 409da9e..10baf6b 100644
--- a/appserver/jms/admin/src/main/java/org/glassfish/jms/admin/cli/JMSPing.java
+++ b/appserver/jms/admin/src/main/java/org/glassfish/jms/admin/cli/JMSPing.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -200,7 +200,7 @@
         }
         aoAttrList.set("property", propString);
 
-        aoAttrList.set("restype",  "javax.jms.QueueConnectionFactory");
+        aoAttrList.set("restype",  "jakarta.jms.QueueConnectionFactory");
         aoAttrList.set("DEFAULT",  tmpJMSResource);
         //aoAttrList.set("target", target);
         commandRunner.getCommandInvocation("create-jms-resource", subReport, subject).parameters(aoAttrList).execute();
diff --git a/appserver/jms/admin/src/main/java/org/glassfish/jms/admin/cli/ListJMSResources.java b/appserver/jms/admin/src/main/java/org/glassfish/jms/admin/cli/ListJMSResources.java
index 3c5a3a0..0e12a6f 100644
--- a/appserver/jms/admin/src/main/java/org/glassfish/jms/admin/cli/ListJMSResources.java
+++ b/appserver/jms/admin/src/main/java/org/glassfish/jms/admin/cli/ListJMSResources.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -60,11 +60,11 @@
 public class ListJMSResources implements AdminCommand {
 
     private static final String JMSRA = "jmsra";
-    private static final String QUEUE = "javax.jms.Queue";
-    private static final String TOPIC = "javax.jms.Topic";
-    private static final String QUEUE_CF = "javax.jms.QueueConnectionFactory";
-    private static final String TOPIC_CF = "javax.jms.TopicConnectionFactory";
-    private static final String UNIFIED_CF = "javax.jms.ConnectionFactory";
+    private static final String QUEUE = "jakarta.jms.Queue";
+    private static final String TOPIC = "jakarta.jms.Topic";
+    private static final String QUEUE_CF = "jakarta.jms.QueueConnectionFactory";
+    private static final String TOPIC_CF = "jakarta.jms.TopicConnectionFactory";
+    private static final String UNIFIED_CF = "jakarta.jms.ConnectionFactory";
     final private static LocalStringManagerImpl localStrings = new LocalStringManagerImpl(ListJMSResources.class);
 
     @Param(name="resType", optional=true)
diff --git a/appserver/jms/admin/src/main/manpages/org/glassfish/jms/admin/cli/create-jms-resource.1 b/appserver/jms/admin/src/main/manpages/org/glassfish/jms/admin/cli/create-jms-resource.1
index 550ba5b..4dc9664 100644
--- a/appserver/jms/admin/src/main/manpages/org/glassfish/jms/admin/cli/create-jms-resource.1
+++ b/appserver/jms/admin/src/main/manpages/org/glassfish/jms/admin/cli/create-jms-resource.1
@@ -25,10 +25,10 @@
            Displays the help text for the subcommand.
 
        --restype
-           The JMS resource type, which can be javax.jms.Topic,
-           javax.jms.Queue, javax.jms.ConnectionFactory,
-           javax.jms.TopicConnectionFactory, or
-           javax.jms.QueueConnectionFactory.
+           The JMS resource type, which can be jakarta.jms.Topic,
+           jakarta.jms.Queue, jakarta.jms.ConnectionFactory,
+           jakarta.jms.TopicConnectionFactory, or
+           jakarta.jms.QueueConnectionFactory.
 
        --target
            Creates the JMS resource only for the specified target. Valid
@@ -170,13 +170,13 @@
        Example 1, Creating a JMS connection factory resource for durable
        subscriptions
            The following subcommand creates a connection factory resource of
-           type javax.jms.ConnectionFactory whose JNDI name is
+           type jakarta.jms.ConnectionFactory whose JNDI name is
            jms/DurableConnectionFactory. The ClientId property sets a client
            ID on the connection factory so that it can be used for durable
            subscriptions. The JNDI name for a JMS resource customarily
            includes the jms/ naming subcontext.
 
-               asadmin> create-jms-resource --restype javax.jms.ConnectionFactory
+               asadmin> create-jms-resource --restype jakarta.jms.ConnectionFactory
                --description "connection factory for durable subscriptions"
                --property ClientId=MyID jms/DurableConnectionFactory
                Connector resource jms/DurableConnectionFactory created.
@@ -187,7 +187,7 @@
            name is jms/MyQueue. The Name property specifies the physical
            destination to which the resource refers.
 
-               asadmin> create-jms-resource --restype javax.jms.Queue
+               asadmin> create-jms-resource --restype jakarta.jms.Queue
                --property Name=PhysicalQueue jms/MyQueue
                Administered object jms/MyQueue created.
                Command create-jms-resource executed successfully.
diff --git a/appserver/jms/admin/src/main/manpages/org/glassfish/jms/admin/cli/list-jms-resources.1 b/appserver/jms/admin/src/main/manpages/org/glassfish/jms/admin/cli/list-jms-resources.1
index 3f9ce06..65ac6de 100644
--- a/appserver/jms/admin/src/main/manpages/org/glassfish/jms/admin/cli/list-jms-resources.1
+++ b/appserver/jms/admin/src/main/manpages/org/glassfish/jms/admin/cli/list-jms-resources.1
@@ -20,9 +20,9 @@
            Displays the help text for the subcommand.
 
        --restype
-           The JMS resource type can be javax.jms.Topic, javax.jms.Queue,
-           javax.jms.ConnectionFactory, javax.jms.TopicConnectionFactory, or
-           javax.jms.QueueConnectionFactory.
+           The JMS resource type can be jakarta.jms.Topic, jakarta.jms.Queue,
+           jakarta.jms.ConnectionFactory, jakarta.jms.TopicConnectionFactory, or
+           jakarta.jms.QueueConnectionFactory.
 
 OPERANDS
        target
@@ -55,10 +55,10 @@
                Command list-jms-resources executed successfully.
 
        Example 2, Listing JMS resources of a specified type
-           The following subcommand lists all javax.jms.ConnectionFactory
+           The following subcommand lists all jakarta.jms.ConnectionFactory
            resources.
 
-               asadmin> list-jms-resources --restype javax.jms.ConnectionFactory
+               asadmin> list-jms-resources --restype jakarta.jms.ConnectionFactory
                jms/ConnectionFactory
                jms/DurableConnectionFactory
                Command list-jms-resources executed successfully.
diff --git a/appserver/jms/gf-jms-connector/src/main/resources/META-INF/configuration/jms-module-conf.xml b/appserver/jms/gf-jms-connector/src/main/resources/META-INF/configuration/jms-module-conf.xml
index 5b48f9c..5b6b723 100644
--- a/appserver/jms/gf-jms-connector/src/main/resources/META-INF/configuration/jms-module-conf.xml
+++ b/appserver/jms/gf-jms-connector/src/main/resources/META-INF/configuration/jms-module-conf.xml
@@ -1,6 +1,6 @@
 <!--
 
-    Copyright (c) 2012, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2012, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -38,7 +38,7 @@
     <config-bundle location="domain/resources" replace-if-exist="false">
         <configuration-element config-bean-class-name="org.glassfish.connectors.config.ConnectorConnectionPool">
 <![CDATA[
-    <connector-connection-pool name="jms/__defaultConnectionFactory-Connection-Pool" max-pool-size="250" steady-pool-size="1" resource-adapter-name="jmsra" connection-definition-name="javax.jms.ConnectionFactory">
+    <connector-connection-pool name="jms/__defaultConnectionFactory-Connection-Pool" max-pool-size="250" steady-pool-size="1" resource-adapter-name="jmsra" connection-definition-name="jakarta.jms.ConnectionFactory">
     </connector-connection-pool>
 ]]>
         </configuration-element>
diff --git a/appserver/jms/gf-jms-injection/pom.xml b/appserver/jms/gf-jms-injection/pom.xml
index 080f7f9..b500f46 100644
--- a/appserver/jms/gf-jms-injection/pom.xml
+++ b/appserver/jms/gf-jms-injection/pom.xml
@@ -66,7 +66,6 @@
         <dependency>
             <groupId>jakarta.jms</groupId>
             <artifactId>jakarta.jms-api</artifactId>
-            <version>${jms-api.version}</version>
         </dependency>
 
          <dependency>
diff --git a/appserver/jms/gf-jms-injection/src/main/java/org/glassfish/jms/injection/AbstractJMSContextManager.java b/appserver/jms/gf-jms-injection/src/main/java/org/glassfish/jms/injection/AbstractJMSContextManager.java
index 4f6ff5b..f75d4b2 100644
--- a/appserver/jms/gf-jms-injection/src/main/java/org/glassfish/jms/injection/AbstractJMSContextManager.java
+++ b/appserver/jms/gf-jms-injection/src/main/java/org/glassfish/jms/injection/AbstractJMSContextManager.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -24,8 +24,8 @@
 import java.util.logging.Logger;
 import javax.annotation.PostConstruct;
 import javax.annotation.PreDestroy;
-import javax.jms.ConnectionFactory;
-import javax.jms.JMSContext;
+import jakarta.jms.ConnectionFactory;
+import jakarta.jms.JMSContext;
 import com.sun.enterprise.util.LocalStringManagerImpl;
 import org.glassfish.api.invocation.InvocationManager;
 import org.glassfish.api.invocation.ComponentInvocation;
diff --git a/appserver/jms/gf-jms-injection/src/main/java/org/glassfish/jms/injection/ForwardingJMSContext.java b/appserver/jms/gf-jms-injection/src/main/java/org/glassfish/jms/injection/ForwardingJMSContext.java
index 0290f5a..c652eba 100644
--- a/appserver/jms/gf-jms-injection/src/main/java/org/glassfish/jms/injection/ForwardingJMSContext.java
+++ b/appserver/jms/gf-jms-injection/src/main/java/org/glassfish/jms/injection/ForwardingJMSContext.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -18,7 +18,7 @@
 
 import java.io.Serializable;
 import java.util.Map;
-import javax.jms.*;
+import jakarta.jms.*;
 import com.sun.enterprise.util.LocalStringManagerImpl;
 
 // Delegate all business methods to JMSContext API
diff --git a/appserver/jms/gf-jms-injection/src/main/java/org/glassfish/jms/injection/InjectableJMSContext.java b/appserver/jms/gf-jms-injection/src/main/java/org/glassfish/jms/injection/InjectableJMSContext.java
index 36950ea..cf3d899 100644
--- a/appserver/jms/gf-jms-injection/src/main/java/org/glassfish/jms/injection/InjectableJMSContext.java
+++ b/appserver/jms/gf-jms-injection/src/main/java/org/glassfish/jms/injection/InjectableJMSContext.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -24,11 +24,11 @@
 import javax.enterprise.inject.Instance;
 import javax.enterprise.inject.spi.InjectionPoint;
 import javax.inject.Inject;
-import javax.jms.ConnectionFactory;
-import javax.jms.JMSConnectionFactory;
-import javax.jms.JMSContext;
-import javax.jms.JMSPasswordCredential;
-import javax.jms.JMSSessionMode;
+import jakarta.jms.ConnectionFactory;
+import jakarta.jms.JMSConnectionFactory;
+import jakarta.jms.JMSContext;
+import jakarta.jms.JMSPasswordCredential;
+import jakarta.jms.JMSSessionMode;
 import javax.naming.InitialContext;
 import javax.naming.NamingException;
 import javax.transaction.Transaction;
diff --git a/appserver/jms/gf-jms-injection/src/main/java/org/glassfish/jms/injection/JMSContextEntry.java b/appserver/jms/gf-jms-injection/src/main/java/org/glassfish/jms/injection/JMSContextEntry.java
index db680a7..d7ee710 100644
--- a/appserver/jms/gf-jms-injection/src/main/java/org/glassfish/jms/injection/JMSContextEntry.java
+++ b/appserver/jms/gf-jms-injection/src/main/java/org/glassfish/jms/injection/JMSContextEntry.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.jms.injection;
 
 import java.io.Serializable;
-import javax.jms.JMSContext;
+import jakarta.jms.JMSContext;
 import org.glassfish.api.invocation.ComponentInvocation;
 
 public class JMSContextEntry implements Serializable {
diff --git a/appserver/jms/gf-jms-injection/src/main/java/org/glassfish/jms/injection/JMSContextMetadata.java b/appserver/jms/gf-jms-injection/src/main/java/org/glassfish/jms/injection/JMSContextMetadata.java
index 78f3253..3955fca 100644
--- a/appserver/jms/gf-jms-injection/src/main/java/org/glassfish/jms/injection/JMSContextMetadata.java
+++ b/appserver/jms/gf-jms-injection/src/main/java/org/glassfish/jms/injection/JMSContextMetadata.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,10 +20,10 @@
 import java.security.MessageDigest;
 import java.util.logging.Level;
 import java.util.logging.Logger;
-import javax.jms.JMSConnectionFactory;
-import javax.jms.JMSContext;
-import javax.jms.JMSPasswordCredential;
-import javax.jms.JMSSessionMode;
+import jakarta.jms.JMSConnectionFactory;
+import jakarta.jms.JMSContext;
+import jakarta.jms.JMSPasswordCredential;
+import jakarta.jms.JMSSessionMode;
 import org.glassfish.internal.api.RelativePathResolver;
 import com.sun.enterprise.util.LocalStringManagerImpl;
 
diff --git a/appserver/jms/jms-core/src/main/java/com/sun/enterprise/connectors/jms/deployment/annotation/handlers/JMSConnectionFactoryDefinitionHandler.java b/appserver/jms/jms-core/src/main/java/com/sun/enterprise/connectors/jms/deployment/annotation/handlers/JMSConnectionFactoryDefinitionHandler.java
index 0e87042..8845a19 100644
--- a/appserver/jms/jms-core/src/main/java/com/sun/enterprise/connectors/jms/deployment/annotation/handlers/JMSConnectionFactoryDefinitionHandler.java
+++ b/appserver/jms/jms-core/src/main/java/com/sun/enterprise/connectors/jms/deployment/annotation/handlers/JMSConnectionFactoryDefinitionHandler.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -30,7 +30,7 @@
 import javax.interceptor.AroundInvoke;
 import javax.interceptor.AroundTimeout;
 import javax.interceptor.Interceptors;
-import javax.jms.JMSConnectionFactoryDefinition;
+import jakarta.jms.JMSConnectionFactoryDefinition;
 import java.lang.annotation.Annotation;
 import java.lang.reflect.Method;
 import java.util.Collection;
diff --git a/appserver/jms/jms-core/src/main/java/com/sun/enterprise/connectors/jms/deployment/annotation/handlers/JMSConnectionFactoryDefinitionsHandler.java b/appserver/jms/jms-core/src/main/java/com/sun/enterprise/connectors/jms/deployment/annotation/handlers/JMSConnectionFactoryDefinitionsHandler.java
index aacc73c..7a76559 100644
--- a/appserver/jms/jms-core/src/main/java/com/sun/enterprise/connectors/jms/deployment/annotation/handlers/JMSConnectionFactoryDefinitionsHandler.java
+++ b/appserver/jms/jms-core/src/main/java/com/sun/enterprise/connectors/jms/deployment/annotation/handlers/JMSConnectionFactoryDefinitionsHandler.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -25,8 +25,8 @@
 import java.util.HashSet;
 import java.util.Set;
 
-import javax.jms.JMSConnectionFactoryDefinition;
-import javax.jms.JMSConnectionFactoryDefinitions;
+import jakarta.jms.JMSConnectionFactoryDefinition;
+import jakarta.jms.JMSConnectionFactoryDefinitions;
 
 import org.glassfish.apf.AnnotationHandlerFor;
 import org.glassfish.apf.AnnotationInfo;
diff --git a/appserver/jms/jms-core/src/main/java/com/sun/enterprise/connectors/jms/deployment/annotation/handlers/JMSDestinationDefinitionHandler.java b/appserver/jms/jms-core/src/main/java/com/sun/enterprise/connectors/jms/deployment/annotation/handlers/JMSDestinationDefinitionHandler.java
index 83308c8..0586afc 100644
--- a/appserver/jms/jms-core/src/main/java/com/sun/enterprise/connectors/jms/deployment/annotation/handlers/JMSDestinationDefinitionHandler.java
+++ b/appserver/jms/jms-core/src/main/java/com/sun/enterprise/connectors/jms/deployment/annotation/handlers/JMSDestinationDefinitionHandler.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -30,7 +30,7 @@
 import javax.interceptor.AroundInvoke;
 import javax.interceptor.AroundTimeout;
 import javax.interceptor.Interceptors;
-import javax.jms.JMSDestinationDefinition;
+import jakarta.jms.JMSDestinationDefinition;
 import java.lang.annotation.Annotation;
 import java.lang.reflect.Method;
 import java.util.Collection;
diff --git a/appserver/jms/jms-core/src/main/java/com/sun/enterprise/connectors/jms/deployment/annotation/handlers/JMSDestinationDefinitionsHandler.java b/appserver/jms/jms-core/src/main/java/com/sun/enterprise/connectors/jms/deployment/annotation/handlers/JMSDestinationDefinitionsHandler.java
index d062e52..71b2600 100644
--- a/appserver/jms/jms-core/src/main/java/com/sun/enterprise/connectors/jms/deployment/annotation/handlers/JMSDestinationDefinitionsHandler.java
+++ b/appserver/jms/jms-core/src/main/java/com/sun/enterprise/connectors/jms/deployment/annotation/handlers/JMSDestinationDefinitionsHandler.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -25,8 +25,8 @@
 import java.util.HashSet;
 import java.util.Set;
 
-import javax.jms.JMSDestinationDefinition;
-import javax.jms.JMSDestinationDefinitions;
+import jakarta.jms.JMSDestinationDefinition;
+import jakarta.jms.JMSDestinationDefinitions;
 
 import org.glassfish.apf.AnnotationHandlerFor;
 import org.glassfish.apf.AnnotationInfo;
diff --git a/appserver/jms/jms-core/src/main/java/com/sun/enterprise/connectors/jms/system/DefaultJMSConnectionFactory.java b/appserver/jms/jms-core/src/main/java/com/sun/enterprise/connectors/jms/system/DefaultJMSConnectionFactory.java
index 7d58631..d7b89fc 100644
--- a/appserver/jms/jms-core/src/main/java/com/sun/enterprise/connectors/jms/system/DefaultJMSConnectionFactory.java
+++ b/appserver/jms/jms-core/src/main/java/com/sun/enterprise/connectors/jms/system/DefaultJMSConnectionFactory.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2013, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,7 +16,7 @@
 
 package com.sun.enterprise.connectors.jms.system;
 
-import javax.jms.ConnectionFactory;
+import jakarta.jms.ConnectionFactory;
 import javax.naming.NamingException;
 import org.glassfish.api.naming.DefaultResourceProxy;
 import org.glassfish.api.naming.NamedNamingObjectProxy;
diff --git a/appserver/jms/jms-core/src/main/java/com/sun/enterprise/connectors/jms/system/LegacyJmsRecoveryResourceHandler.java b/appserver/jms/jms-core/src/main/java/com/sun/enterprise/connectors/jms/system/LegacyJmsRecoveryResourceHandler.java
index f4a7a55..20aadd6 100644
--- a/appserver/jms/jms-core/src/main/java/com/sun/enterprise/connectors/jms/system/LegacyJmsRecoveryResourceHandler.java
+++ b/appserver/jms/jms-core/src/main/java/com/sun/enterprise/connectors/jms/system/LegacyJmsRecoveryResourceHandler.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -27,8 +27,6 @@
 import javax.naming.NamingException;
 import javax.naming.InitialContext;
 import javax.transaction.xa.XAResource;
-//import javax.jms.Session;
-//import javax.jms.JMSException;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 import java.util.*;
@@ -53,8 +51,8 @@
     @Inject
     private Resources resources;
 
-    static final String JMS_QUEUE_CONNECTION_FACTORY = "javax.jms.QueueConnectionFactory";
-    static final String JMS_TOPIC_CONNECTION_FACTORY = "javax.jms.TopicConnectionFactory";
+    static final String JMS_QUEUE_CONNECTION_FACTORY = "jakarta.jms.QueueConnectionFactory";
+    static final String JMS_TOPIC_CONNECTION_FACTORY = "jakarta.jms.TopicConnectionFactory";
 
     private static final Logger _logger = JMSLoggerInfo.getLogger();
     final private static LocalStringManagerImpl localStrings = new LocalStringManagerImpl(LegacyJmsRecoveryResourceHandler.class);
@@ -159,13 +157,13 @@
                 boolean isQueue;
                 if (next instanceof ExternalJndiResource) {
                     Object objext = ic.lookup(jndiName);
-                    if (!(objext instanceof javax.jms.ConnectionFactory)) {
+                    if (!(objext instanceof jakarta.jms.ConnectionFactory)) {
                         throw new NamingException(localStrings.getLocalString("recovery.unexpected_objtype",
                         "Unexpected object type "+objext.getClass().getName()+" for "+ jndiName,
                         new Object[]{objext.getClass().getName(), jndiName}));
                     }
                     jmsXAConnectionFactory = wrapJMSConnectionFactoryObject(objext);
-                    isQueue = (objext instanceof javax.jms.QueueConnectionFactory);
+                    isQueue = (objext instanceof jakarta.jms.QueueConnectionFactory);
                 }
                 else {
                     jmsXAConnectionFactory = ic.lookup(getXAConnectionFactoryName(jndiName));
diff --git a/appserver/pom.xml b/appserver/pom.xml
index cdefd80..31ee3cf 100644
--- a/appserver/pom.xml
+++ b/appserver/pom.xml
@@ -39,7 +39,7 @@
     </scm>
 
     <properties>
-        <jms-api.version>2.0.3</jms-api.version>
+        <jms-api.version>3.0.0-RC1</jms-api.version>
         <jsp-api.version>2.3.5</jsp-api.version>
         <jsp-impl.version>2.3.5</jsp-impl.version>
         <jstl-impl.version>1.2.6</jstl-impl.version>
@@ -290,7 +290,7 @@
                             <jarType>api</jarType>
                             <specVersion>${jms-api.version}</specVersion>
                             <specImplVersion>${jms-api.version}</specImplVersion>
-                            <apiPackage>javax.jms</apiPackage>
+                            <apiPackage>jakarta.jms</apiPackage>
                         </spec>
                         <spec>
                             <artifact>
diff --git a/appserver/resources/resources-connector/src/main/java/org/glassfish/resources/api/ResourceConstants.java b/appserver/resources/resources-connector/src/main/java/org/glassfish/resources/api/ResourceConstants.java
index be11942..7ac1f6d 100644
--- a/appserver/resources/resources-connector/src/main/java/org/glassfish/resources/api/ResourceConstants.java
+++ b/appserver/resources/resources-connector/src/main/java/org/glassfish/resources/api/ResourceConstants.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -86,15 +86,15 @@
     /** resource type residing in an external JNDI repository */
     public static final String EXT_JNDI_RES_TYPE = "external-jndi-resource";
 
-    public static final String JMS_QUEUE = "javax.jms.Queue";
-    public static final String JMS_TOPIC = "javax.jms.Topic";
-    public static final String JMS_QUEUE_CONNECTION_FACTORY = "javax.jms.QueueConnectionFactory";
-    public static final String JMS_TOPIC_CONNECTION_FACTORY = "javax.jms.TopicConnectionFactory";
-    public static final String JMS_MESSAGE_LISTENER = "javax.jms.MessageListener";
+    public static final String JMS_QUEUE = "jakarta.jms.Queue";
+    public static final String JMS_TOPIC = "jakarta.jms.Topic";
+    public static final String JMS_QUEUE_CONNECTION_FACTORY = "jakarta.jms.QueueConnectionFactory";
+    public static final String JMS_TOPIC_CONNECTION_FACTORY = "jakarta.jms.TopicConnectionFactory";
+    public static final String JMS_MESSAGE_LISTENER = "jakarta.jms.MessageListener";
 
     //TODO should be refactored to non-resources module
     /**
-     *  Reserved sub-context where datasource-definition objets (resource and pool) are bound with generated names.
+     *  Reserved sub-context where datasource-definition objects (resource and pool) are bound with generated names.
      */
     public static String DATASOURCE_DEFINITION_JNDINAME_PREFIX="__datasource_definition/";
     public static String MAILSESSION_DEFINITION_JNDINAME_PREFIX="__mailsession_definition/";
diff --git a/appserver/tests/admingui/auto-test/src/test/java/org/glassfish/admingui/devtests/ConnectorsTest.java b/appserver/tests/admingui/auto-test/src/test/java/org/glassfish/admingui/devtests/ConnectorsTest.java
index f7721f6..c99c92d 100644
--- a/appserver/tests/admingui/auto-test/src/test/java/org/glassfish/admingui/devtests/ConnectorsTest.java
+++ b/appserver/tests/admingui/auto-test/src/test/java/org/glassfish/admingui/devtests/ConnectorsTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2013, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -49,7 +49,7 @@
         sleep(1000);
         
         Select select1 = new Select(driver.findElement(By.id("propertyForm:propertySheet:generalPropertySheet:connectionDefProp:db")));
-        select1.selectByVisibleText("javax.jms.QueueConnectionFactory");
+        select1.selectByVisibleText("jakarta.jms.QueueConnectionFactory");
         waitForButtonEnabled("propertyForm:title:topButtons:nextButton");
 
         clickAndWait("propertyForm:title:topButtons:nextButton");
@@ -114,7 +114,7 @@
         sleep(1000);
         
         Select select1 = new Select(driver.findElement(By.id("propertyForm:propertySheet:generalPropertySheet:connectionDefProp:db")));
-        select1.selectByVisibleText("javax.jms.QueueConnectionFactory");
+        select1.selectByVisibleText("jakarta.jms.QueueConnectionFactory");
         waitForButtonEnabled("propertyForm:title:topButtons:nextButton");
 
         clickAndWait("propertyForm:title:topButtons:nextButton");
@@ -217,7 +217,7 @@
 //        sleep(1000);
 //        
 //        Select select1 = new Select(driver.findElement(By.id("propertyForm:propertySheet:generalPropertySheet:connectionDefProp:db")));
-//        select1.selectByVisibleText("javax.jms.QueueConnectionFactory");
+//        select1.selectByVisibleText("jakarta.jms.QueueConnectionFactory");
 //        waitForButtonEnabled("propertyForm:title:topButtons:nextButton");
 //
 //        clickAndWait("propertyForm:title:topButtons:nextButton");
diff --git a/appserver/tests/admingui/auto-test/src/test/java/org/glassfish/admingui/devtests/JavaMessageServiceTest.java b/appserver/tests/admingui/auto-test/src/test/java/org/glassfish/admingui/devtests/JavaMessageServiceTest.java
index a2444fb..c269068 100644
--- a/appserver/tests/admingui/auto-test/src/test/java/org/glassfish/admingui/devtests/JavaMessageServiceTest.java
+++ b/appserver/tests/admingui/auto-test/src/test/java/org/glassfish/admingui/devtests/JavaMessageServiceTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2013, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -163,7 +163,7 @@
 //        setFieldValue("jmsPhysDestForm:propertySheet:propertSectionTextField:maxBytesPerMsgProp:maxBytesPerMsg", maxMessageSize);
 //        setFieldValue("jmsPhysDestForm:propertySheet:propertSectionTextField:maxTotalMsgBytesProp:maxTotalMsgBytes", maxTotalMemory);
 //        Select select = new Select(driver.findElement(By.id("jmsPhysDestForm:propertySheet:propertSectionTextField:typeProp:type")));
-//        select.selectByVisibleText("javax.jms.Queue");
+//        select.selectByVisibleText("jakarta.jms.Queue");
 //        setFieldValue("jmsPhysDestForm:propertySheet:propertSectionTextField:maxNumProducersProp:maxNumProducers", maxProducers);
 //        setFieldValue("jmsPhysDestForm:propertySheet:propertSectionTextField:consumerFlowLimitProp:consumerFlowLimit", consumerFlowLimit);
 //        Select select1 = new Select(driver.findElement(By.id("jmsPhysDestForm:propertySheet:propertSectionTextField:useDmqProp:useDmq")));
diff --git a/appserver/tests/admingui/auto-test/src/test/java/org/glassfish/admingui/devtests/JmsResourcesTest.java b/appserver/tests/admingui/auto-test/src/test/java/org/glassfish/admingui/devtests/JmsResourcesTest.java
index 424af87..f55bff0 100644
--- a/appserver/tests/admingui/auto-test/src/test/java/org/glassfish/admingui/devtests/JmsResourcesTest.java
+++ b/appserver/tests/admingui/auto-test/src/test/java/org/glassfish/admingui/devtests/JmsResourcesTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2013, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -43,7 +43,7 @@
 
         setFieldValue("form:propertySheet:generalPropertySheet:jndiProp:jndiProp", poolName);
         Select select = new Select(driver.findElement(By.id("form:propertySheet:generalPropertySheet:resTyped:resType")));
-        select.selectByVisibleText("javax.jms.TopicConnectionFactory");
+        select.selectByVisibleText("jakarta.jms.TopicConnectionFactory");
         setFieldValue("form:propertySheet:generalPropertySheet:descProp:descProp", description);
         Select select1 = new Select(driver.findElement(By.id("form:propertySheet:poolPropertySheet:transprop:trans")));
         select1.selectByVisibleText("LocalTransaction");
@@ -83,7 +83,7 @@
 
         setFieldValue("form:propertySheet:generalPropertySheet:jndiProp:jndiProp", poolName);
         Select select = new Select(driver.findElement(By.id("form:propertySheet:generalPropertySheet:resTyped:resType")));
-        select.selectByVisibleText("javax.jms.TopicConnectionFactory");
+        select.selectByVisibleText("jakarta.jms.TopicConnectionFactory");
         setFieldValue("form:propertySheet:generalPropertySheet:descProp:descProp", description);
         Select select1 = new Select(driver.findElement(By.id("form:propertySheet:poolPropertySheet:transprop:trans")));
         select1.selectByVisibleText("LocalTransaction");
diff --git a/appserver/tests/appserv-tests/config/properties.xml b/appserver/tests/appserv-tests/config/properties.xml
index 5f8d44b..1d42b0f 100644
--- a/appserver/tests/appserv-tests/config/properties.xml
+++ b/appserver/tests/appserv-tests/config/properties.xml
@@ -1,6 +1,6 @@
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -52,9 +52,9 @@
     <property name="dest.type" value="queue"/>
     <property name="dest.name" value="Queue"/>
     <property name="jms.factory.name" value="jms/QCFactory"/>
-    <property name="jms.factory.type" value="javax.jms.QueueConnectionFactory"/>
+    <property name="jms.factory.type" value="jakarta.jms.QueueConnectionFactory"/>
     <property name="jms.resource.name" value="jms/SampleQueue"/>
-    <property name="jms.resource.type" value="javax.jms.Queue"/>
+    <property name="jms.resource.type" value="jakarta.jms.Queue"/>
 
     <property name="jdbc.conpool.name" value="ql-jdbc-pool"/>
     <property name="jdbc.resource.name" value="jdbc/s1qeDB"/>
diff --git a/appserver/tests/appserv-tests/devtests/admin/cli/src/admin/AdminObjectTest.java b/appserver/tests/appserv-tests/devtests/admin/cli/src/admin/AdminObjectTest.java
index aa46429..236ee4e 100644
--- a/appserver/tests/appserv-tests/devtests/admin/cli/src/admin/AdminObjectTest.java
+++ b/appserver/tests/appserv-tests/devtests/admin/cli/src/admin/AdminObjectTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2010, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -43,7 +43,7 @@
     private static final String TARGET_OPTION = "--target";
 
     private static final String RESTYPE_OPTION = "--restype";
-    private static final String RESTYPE_VALUE ="javax.jms.Queue";
+    private static final String RESTYPE_VALUE ="jakarta.jms.Queue";
 
     private static final String RA_NAME_OPTION = "--raname";
     private static final String RA_NAME_VALUE ="jmsra";
diff --git a/appserver/tests/appserv-tests/devtests/admin/cli/src/admin/ClusterTest.java b/appserver/tests/appserv-tests/devtests/admin/cli/src/admin/ClusterTest.java
index 09e4346..eee3233 100644
--- a/appserver/tests/appserv-tests/devtests/admin/cli/src/admin/ClusterTest.java
+++ b/appserver/tests/appserv-tests/devtests/admin/cli/src/admin/ClusterTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -414,7 +414,7 @@
         report(tn + "create-connector-connection-pool", asadmin("create-connector-connection-pool",
                 "--target", cname,
                 "--raname", "jmsra",
-                "--connectiondefinition", "javax.jms.QueueConnectionFactory",
+                "--connectiondefinition", "jakarta.jms.QueueConnectionFactory",
                 "jms/qConnPool"));
 
         // delete the resources
diff --git a/appserver/tests/appserv-tests/devtests/admin/cli/src/admin/ConnectorResourceTest.java b/appserver/tests/appserv-tests/devtests/admin/cli/src/admin/ConnectorResourceTest.java
index e13ffbf..c4a6d8c 100644
--- a/appserver/tests/appserv-tests/devtests/admin/cli/src/admin/ConnectorResourceTest.java
+++ b/appserver/tests/appserv-tests/devtests/admin/cli/src/admin/ConnectorResourceTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2010, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -321,7 +321,7 @@
         String testName = "testCreateConnectorConnectionPool";
         AsadminReturn result = asadminWithOutput(CREATE_CONNECTOR_CONNECTION_POOL,
                 "--raname", "jmsra",
-                "--connectiondefinition", "javax.jms.QueueConnectionFactory",
+                "--connectiondefinition", "jakarta.jms.QueueConnectionFactory",
                  POOL_NAME);
         reportResultStatus(testName, result);
         reportExpectedResult(testName, result, "Connector connection pool pool-1 created.");
diff --git a/appserver/tests/appserv-tests/devtests/admin/cli/src/admin/CreateJmsResourceTest.java b/appserver/tests/appserv-tests/devtests/admin/cli/src/admin/CreateJmsResourceTest.java
index 68b523b..7a1b00c 100644
--- a/appserver/tests/appserv-tests/devtests/admin/cli/src/admin/CreateJmsResourceTest.java
+++ b/appserver/tests/appserv-tests/devtests/admin/cli/src/admin/CreateJmsResourceTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -61,28 +61,28 @@
     }
 
     private void createJmsResourceWithoutForce() {
-        report("createJmsResourceWithoutForce-0", asadmin("create-jms-resource", "--restype", "javax.jms.Queue", "--property", "imqDestinationName=myQueue", QUEUE1));
+        report("createJmsResourceWithoutForce-0", asadmin("create-jms-resource", "--restype", "jakarta.jms.Queue", "--property", "imqDestinationName=myQueue", QUEUE1));
         checkResource("checkJmsResourceWithoutForce-0", QUEUE1);
-        report("createJmsResourceWithoutForce-1", asadmin("create-jms-resource", "--restype", "javax.jms.QueueConnectionFactory", FACTORY1));
+        report("createJmsResourceWithoutForce-1", asadmin("create-jms-resource", "--restype", "jakarta.jms.QueueConnectionFactory", FACTORY1));
         checkResource("checkJmsResourceWithoutForce-0", FACTORY1);
     }
 
     private void createJmsResourceWithForce() {
-        report("createJmsResourceWithForce-0", asadmin("create-jms-resource", "--restype", "javax.jms.Queue", "--property", "imqDestinationName=myQueue", "--force", QUEUE1));
+        report("createJmsResourceWithForce-0", asadmin("create-jms-resource", "--restype", "jakarta.jms.Queue", "--property", "imqDestinationName=myQueue", "--force", QUEUE1));
         checkResource("checkJmsResourceWithForce-0", QUEUE1);
-        report("createJmsResourceWithForce-1", asadmin("create-jms-resource", "--restype", "javax.jms.QueueConnectionFactory", "--force", FACTORY1));
+        report("createJmsResourceWithForce-1", asadmin("create-jms-resource", "--restype", "jakarta.jms.QueueConnectionFactory", "--force", FACTORY1));
         checkResource("checkJmsResourceWithForce-1", FACTORY1);
-        report("createJmsResourceWithForce-2", !asadmin("create-jms-resource", "--restype", "javax.jms.QueueConnectionFactory", "--force=xyz", FACTORY2));
-        report("createJmsResourceWithForce-3", asadmin("create-jms-resource", "--restype", "javax.jms.Queue", "--property", "imqDestinationName=myQueue", "--force", QUEUE2));
+        report("createJmsResourceWithForce-2", !asadmin("create-jms-resource", "--restype", "jakarta.jms.QueueConnectionFactory", "--force=xyz", FACTORY2));
+        report("createJmsResourceWithForce-3", asadmin("create-jms-resource", "--restype", "jakarta.jms.Queue", "--property", "imqDestinationName=myQueue", "--force", QUEUE2));
         checkResource("checkJmsResourceWithForce-3", QUEUE1);
-        report("createJmsResourceWithForce-4", asadmin("create-jms-resource", "--restype", "javax.jms.QueueConnectionFactory", "--force", FACTORY2));
+        report("createJmsResourceWithForce-4", asadmin("create-jms-resource", "--restype", "jakarta.jms.QueueConnectionFactory", "--force", FACTORY2));
         checkResource("checkJmsResourceWithForce-4", FACTORY2);
     }
 
     // GLASSFISH-21655: When a CF is created with same JNDI name as that of an existing resource, there should not be a CF or a connection pool created
     private void createJmsCFWithDupName() {
-        asadmin("create-jms-resource", "--restype", "javax.jms.Topic", FACTORY3);
-        report("createJmsCFWithDupName-0", !asadmin("create-jms-resource", "--restype", "javax.jms.ConnectionFactory", FACTORY3));
+        asadmin("create-jms-resource", "--restype", "jakarta.jms.Topic", FACTORY3);
+        report("createJmsCFWithDupName-0", !asadmin("create-jms-resource", "--restype", "jakarta.jms.ConnectionFactory", FACTORY3));
         AsadminReturn result = asadminWithOutput("list-connector-connection-pools");
         report("createJmsCFWithDupName-1", !result.out.contains(POOL1));
     }
diff --git a/appserver/tests/appserv-tests/devtests/cdi/javaee-component-resources/jms-resource-producer-field-in-library-jar/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/cdi/javaee-component-resources/jms-resource-producer-field-in-library-jar/create_resources.asadmin
index 940c1b9..b843ae6 100644
--- a/appserver/tests/appserv-tests/devtests/cdi/javaee-component-resources/jms-resource-producer-field-in-library-jar/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/cdi/javaee-component-resources/jms-resource-producer-field-in-library-jar/create_resources.asadmin
@@ -1,3 +1,3 @@
-create-jms-resource --restype javax.jms.ConnectionFactory jms/ConnectionFactory
+create-jms-resource --restype jakarta.jms.ConnectionFactory jms/ConnectionFactory
 create-jmsdest --desttype queue Q1 
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=Q1 jms/Queue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=Q1 jms/Queue
diff --git a/appserver/tests/appserv-tests/devtests/cdi/javaee-component-resources/jms-resource-producer-field-in-library-jar/producer-library-jar/test/servlet/JMSResourcesProducer.java b/appserver/tests/appserv-tests/devtests/cdi/javaee-component-resources/jms-resource-producer-field-in-library-jar/producer-library-jar/test/servlet/JMSResourcesProducer.java
index 31f4a60..713a082 100644
--- a/appserver/tests/appserv-tests/devtests/cdi/javaee-component-resources/jms-resource-producer-field-in-library-jar/producer-library-jar/test/servlet/JMSResourcesProducer.java
+++ b/appserver/tests/appserv-tests/devtests/cdi/javaee-component-resources/jms-resource-producer-field-in-library-jar/producer-library-jar/test/servlet/JMSResourcesProducer.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2010, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,10 +19,10 @@
 import javax.annotation.Resource;
 import javax.enterprise.context.ApplicationScoped;
 import javax.enterprise.inject.Produces;
-import javax.jms.ConnectionFactory;
-import javax.jms.JMSException;
-import javax.jms.Queue;
-import javax.jms.Session;
+import jakarta.jms.ConnectionFactory;
+import jakarta.jms.JMSException;
+import jakarta.jms.Queue;
+import jakarta.jms.Session;
 
 
 @ApplicationScoped
diff --git a/appserver/tests/appserv-tests/devtests/cdi/javaee-component-resources/jms-resource-producer-field-in-library-jar/servlet/test/beans/nonmock/TestBean.java b/appserver/tests/appserv-tests/devtests/cdi/javaee-component-resources/jms-resource-producer-field-in-library-jar/servlet/test/beans/nonmock/TestBean.java
index db83a56..c187bf6 100644
--- a/appserver/tests/appserv-tests/devtests/cdi/javaee-component-resources/jms-resource-producer-field-in-library-jar/servlet/test/beans/nonmock/TestBean.java
+++ b/appserver/tests/appserv-tests/devtests/cdi/javaee-component-resources/jms-resource-producer-field-in-library-jar/servlet/test/beans/nonmock/TestBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2010, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -18,7 +18,7 @@
 
 import javax.enterprise.context.RequestScoped;
 import javax.inject.Inject;
-import javax.jms.Queue;
+import jakarta.jms.Queue;
 
 import test.beans.TestBeanInterface;
 import test.beans.artifacts.Preferred;
diff --git a/appserver/tests/appserv-tests/devtests/cdi/javaee-component-resources/jms-resource-producer-field-in-library-jar/servlet/test/servlet/JMSResourceInjectionInLibraryBeanArchiveTestServlet.java b/appserver/tests/appserv-tests/devtests/cdi/javaee-component-resources/jms-resource-producer-field-in-library-jar/servlet/test/servlet/JMSResourceInjectionInLibraryBeanArchiveTestServlet.java
index 5075703..5ca76ca 100644
--- a/appserver/tests/appserv-tests/devtests/cdi/javaee-component-resources/jms-resource-producer-field-in-library-jar/servlet/test/servlet/JMSResourceInjectionInLibraryBeanArchiveTestServlet.java
+++ b/appserver/tests/appserv-tests/devtests/cdi/javaee-component-resources/jms-resource-producer-field-in-library-jar/servlet/test/servlet/JMSResourceInjectionInLibraryBeanArchiveTestServlet.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2010, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,8 +20,8 @@
 import java.io.PrintWriter;
 
 import javax.inject.Inject;
-import javax.jms.Queue;
-import javax.jms.Session;
+import jakarta.jms.Queue;
+import jakarta.jms.Session;
 import javax.servlet.ServletException;
 import javax.servlet.annotation.WebServlet;
 import javax.servlet.http.HttpServlet;
diff --git a/appserver/tests/appserv-tests/devtests/cdi/javaee-component-resources/jms-resource-producer-field/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/cdi/javaee-component-resources/jms-resource-producer-field/create_resources.asadmin
index 940c1b9..b843ae6 100644
--- a/appserver/tests/appserv-tests/devtests/cdi/javaee-component-resources/jms-resource-producer-field/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/cdi/javaee-component-resources/jms-resource-producer-field/create_resources.asadmin
@@ -1,3 +1,3 @@
-create-jms-resource --restype javax.jms.ConnectionFactory jms/ConnectionFactory
+create-jms-resource --restype jakarta.jms.ConnectionFactory jms/ConnectionFactory
 create-jmsdest --desttype queue Q1 
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=Q1 jms/Queue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=Q1 jms/Queue
diff --git a/appserver/tests/appserv-tests/devtests/cdi/javaee-component-resources/jms-resource-producer-field/servlet/test/beans/nonmock/TestBean.java b/appserver/tests/appserv-tests/devtests/cdi/javaee-component-resources/jms-resource-producer-field/servlet/test/beans/nonmock/TestBean.java
index db83a56..c187bf6 100644
--- a/appserver/tests/appserv-tests/devtests/cdi/javaee-component-resources/jms-resource-producer-field/servlet/test/beans/nonmock/TestBean.java
+++ b/appserver/tests/appserv-tests/devtests/cdi/javaee-component-resources/jms-resource-producer-field/servlet/test/beans/nonmock/TestBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2010, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -18,7 +18,7 @@
 
 import javax.enterprise.context.RequestScoped;
 import javax.inject.Inject;
-import javax.jms.Queue;
+import jakarta.jms.Queue;
 
 import test.beans.TestBeanInterface;
 import test.beans.artifacts.Preferred;
diff --git a/appserver/tests/appserv-tests/devtests/cdi/javaee-component-resources/jms-resource-producer-field/servlet/test/servlet/JMSResourceInjectionInLibraryBeanArchiveTestServlet.java b/appserver/tests/appserv-tests/devtests/cdi/javaee-component-resources/jms-resource-producer-field/servlet/test/servlet/JMSResourceInjectionInLibraryBeanArchiveTestServlet.java
index 5075703..5ca76ca 100644
--- a/appserver/tests/appserv-tests/devtests/cdi/javaee-component-resources/jms-resource-producer-field/servlet/test/servlet/JMSResourceInjectionInLibraryBeanArchiveTestServlet.java
+++ b/appserver/tests/appserv-tests/devtests/cdi/javaee-component-resources/jms-resource-producer-field/servlet/test/servlet/JMSResourceInjectionInLibraryBeanArchiveTestServlet.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2010, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,8 +20,8 @@
 import java.io.PrintWriter;
 
 import javax.inject.Inject;
-import javax.jms.Queue;
-import javax.jms.Session;
+import jakarta.jms.Queue;
+import jakarta.jms.Session;
 import javax.servlet.ServletException;
 import javax.servlet.annotation.WebServlet;
 import javax.servlet.http.HttpServlet;
diff --git a/appserver/tests/appserv-tests/devtests/cdi/javaee-component-resources/jms-resource-producer-field/servlet/test/servlet/JMSResourcesProducer.java b/appserver/tests/appserv-tests/devtests/cdi/javaee-component-resources/jms-resource-producer-field/servlet/test/servlet/JMSResourcesProducer.java
index 31f4a60..713a082 100644
--- a/appserver/tests/appserv-tests/devtests/cdi/javaee-component-resources/jms-resource-producer-field/servlet/test/servlet/JMSResourcesProducer.java
+++ b/appserver/tests/appserv-tests/devtests/cdi/javaee-component-resources/jms-resource-producer-field/servlet/test/servlet/JMSResourcesProducer.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2010, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,10 +19,10 @@
 import javax.annotation.Resource;
 import javax.enterprise.context.ApplicationScoped;
 import javax.enterprise.inject.Produces;
-import javax.jms.ConnectionFactory;
-import javax.jms.JMSException;
-import javax.jms.Queue;
-import javax.jms.Session;
+import jakarta.jms.ConnectionFactory;
+import jakarta.jms.JMSException;
+import jakarta.jms.Queue;
+import jakarta.jms.Session;
 
 
 @ApplicationScoped
diff --git a/appserver/tests/appserv-tests/devtests/cdi/javaee-integration/embedded-resource-adapter-as-bean-archive/app/src/mdb/MyMessageBean.java b/appserver/tests/appserv-tests/devtests/cdi/javaee-integration/embedded-resource-adapter-as-bean-archive/app/src/mdb/MyMessageBean.java
index caf41e9..0d17b43 100644
--- a/appserver/tests/appserv-tests/devtests/cdi/javaee-integration/embedded-resource-adapter-as-bean-archive/app/src/mdb/MyMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/cdi/javaee-integration/embedded-resource-adapter-as-bean-archive/app/src/mdb/MyMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2010, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -63,7 +63,7 @@
 
     /**
      * onMessage method, declared as public (but not final or static), with a
-     * return type of void, and with one argument of type javax.jms.Message.
+     * return type of void, and with one argument of type jakarta.jms.Message.
      * 
      * Casts the incoming Message to a TextMessage and displays the text.
      * 
diff --git a/appserver/tests/appserv-tests/devtests/cdi/javaee-integration/standalone-resource-adapter-as-bean-archive/app/src/mdb/MyMessageBean.java b/appserver/tests/appserv-tests/devtests/cdi/javaee-integration/standalone-resource-adapter-as-bean-archive/app/src/mdb/MyMessageBean.java
index 3af505b..9f53213 100644
--- a/appserver/tests/appserv-tests/devtests/cdi/javaee-integration/standalone-resource-adapter-as-bean-archive/app/src/mdb/MyMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/cdi/javaee-integration/standalone-resource-adapter-as-bean-archive/app/src/mdb/MyMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2010, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -33,7 +33,7 @@
 import javax.servlet.http.*;
 import java.sql.*;
 import javax.sql.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.transaction.*;
 
 
@@ -74,7 +74,7 @@
     /**
      * onMessage method, declared as public (but not final or 
      * static), with a return type of void, and with one argument
-     * of type javax.jms.Message.
+     * of type jakarta.jms.Message.
      *
      * Casts the incoming Message to a TextMessage and displays 
      * the text.
diff --git a/appserver/tests/appserv-tests/devtests/cdi/scopes/request-and-application-scope-ejb-mdb/build.xml b/appserver/tests/appserv-tests/devtests/cdi/scopes/request-and-application-scope-ejb-mdb/build.xml
index 9f1d49a..0d7504b 100644
--- a/appserver/tests/appserv-tests/devtests/cdi/scopes/request-and-application-scope-ejb-mdb/build.xml
+++ b/appserver/tests/appserv-tests/devtests/cdi/scopes/request-and-application-scope-ejb-mdb/build.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="ISO-8859-1"?>
 <!--
 
-    Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2010, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -79,7 +79,7 @@
     <target name="run_standaloneclient" depends="init-common">
        <java  fork="on" 
               failonerror="true"
-              classpath="${env.S1AS_HOME}/lib/javaee.jar:${env.S1AS_HOME}/modules/javax.jms.jar:${env.S1AS_HOME}/lib/gf-client.jar:${build.classes.dir}:${env.APS_HOME}/lib/reporter.jar"
+              classpath="${env.S1AS_HOME}/lib/javaee.jar:${env.S1AS_HOME}/modules/jakarta.jms-api.jar:${env.S1AS_HOME}/lib/gf-client.jar:${build.classes.dir}:${env.APS_HOME}/lib/reporter.jar"
               classname="${simple.client}">
         </java>
     </target>
diff --git a/appserver/tests/appserv-tests/devtests/cdi/scopes/request-and-application-scope-ejb-mdb/client/Client.java b/appserver/tests/appserv-tests/devtests/cdi/scopes/request-and-application-scope-ejb-mdb/client/Client.java
index 085a41f..7613e72 100644
--- a/appserver/tests/appserv-tests/devtests/cdi/scopes/request-and-application-scope-ejb-mdb/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/cdi/scopes/request-and-application-scope-ejb-mdb/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2010, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -18,16 +18,16 @@
 
 import javax.annotation.Resource;
 import javax.ejb.EJB;
-import javax.jms.Destination;
-import javax.jms.JMSException;
-import javax.jms.Message;
-import javax.jms.QueueConnection;
-import javax.jms.QueueConnectionFactory;
-import javax.jms.QueueReceiver;
-import javax.jms.QueueSender;
-import javax.jms.QueueSession;
-import javax.jms.Session;
-import javax.jms.TextMessage;
+import jakarta.jms.Destination;
+import jakarta.jms.JMSException;
+import jakarta.jms.Message;
+import jakarta.jms.QueueConnection;
+import jakarta.jms.QueueConnectionFactory;
+import jakarta.jms.QueueReceiver;
+import jakarta.jms.QueueSender;
+import jakarta.jms.QueueSession;
+import jakarta.jms.Session;
+import jakarta.jms.TextMessage;
 import javax.naming.InitialContext;
 
 import test.ejb.session.HelloSless;
@@ -56,10 +56,10 @@
     private static QueueConnectionFactory queueConFactory;
 
     @Resource(name = "MsgBeanQueue", mappedName = "jms/cdi_hello_mdb_InQueue")
-    private static javax.jms.Queue msgBeanQueue;
+    private static jakarta.jms.Queue msgBeanQueue;
 
     @Resource(name = "ClientQueue", mappedName = "foo")
-    private static javax.jms.Queue clientQueue;
+    private static jakarta.jms.Queue clientQueue;
 
     private QueueConnection queueCon;
     private QueueSession queueSession;
@@ -87,11 +87,11 @@
 
                 System.out.println("Java SE mode...");
                 InitialContext ic = new InitialContext();
-                queueConFactory = (javax.jms.QueueConnectionFactory) ic
+                queueConFactory = (jakarta.jms.QueueConnectionFactory) ic
                         .lookup("jms/cdi_hello_mdb_QCF");
-                msgBeanQueue = (javax.jms.Queue) ic
+                msgBeanQueue = (jakarta.jms.Queue) ic
                         .lookup("jms/cdi_hello_mdb_InQueue");
-                clientQueue = (javax.jms.Queue) ic
+                clientQueue = (jakarta.jms.Queue) ic
                         .lookup("jms/cdi_hello_mdb_OutQueue");
 
             }
@@ -127,7 +127,7 @@
         }
     }
 
-    private void sendMsgs(javax.jms.Queue queue, Message msg, int num)
+    private void sendMsgs(jakarta.jms.Queue queue, Message msg, int num)
             throws JMSException {
         for (int i = 0; i < num; i++) {
             System.out.println("Sending message " + i + " to " + queue
@@ -146,7 +146,7 @@
 
         message.setBooleanProperty("flag", true);
         message.setIntProperty("num", 2);
-        sendMsgs((javax.jms.Queue) dest, message, num);
+        sendMsgs((jakarta.jms.Queue) dest, message, num);
         
         System.out.println("remote bean:" + helloStatelessRemoteBean);
         String response = helloStatelessRemoteBean.hello();
diff --git a/appserver/tests/appserv-tests/devtests/cdi/scopes/request-and-application-scope-ejb-mdb/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/cdi/scopes/request-and-application-scope-ejb-mdb/create_resources.asadmin
index 78a6f43..435b369 100644
--- a/appserver/tests/appserv-tests/devtests/cdi/scopes/request-and-application-scope-ejb-mdb/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/cdi/scopes/request-and-application-scope-ejb-mdb/create_resources.asadmin
@@ -1,5 +1,5 @@
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/cdi_hello_mdb_QCF
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/cdi_hello_mdb_QCF
 create-jmsdest --desttype queue cdi_hello_mdb_InQueue 
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=cdi_hello_mdb_InQueue jms/cdi_hello_mdb_InQueue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=cdi_hello_mdb_InQueue jms/cdi_hello_mdb_InQueue
 create-jmsdest --desttype queue cdi_hello_mdb_OutQueue 
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=cdi_hello_mdb_OutQueue jms/cdi_hello_mdb_OutQueue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=cdi_hello_mdb_OutQueue jms/cdi_hello_mdb_OutQueue
diff --git a/appserver/tests/appserv-tests/devtests/cdi/scopes/request-and-application-scope-ejb-mdb/src/test/ejb/mdb/MessageBean.java b/appserver/tests/appserv-tests/devtests/cdi/scopes/request-and-application-scope-ejb-mdb/src/test/ejb/mdb/MessageBean.java
index 665278f..880fd34 100644
--- a/appserver/tests/appserv-tests/devtests/cdi/scopes/request-and-application-scope-ejb-mdb/src/test/ejb/mdb/MessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/cdi/scopes/request-and-application-scope-ejb-mdb/src/test/ejb/mdb/MessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2010, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -24,15 +24,15 @@
 import javax.ejb.TransactionManagementType;
 import javax.enterprise.inject.spi.BeanManager;
 import javax.inject.Inject;
-import javax.jms.Message;
-import javax.jms.MessageListener;
-import javax.jms.Queue;
-import javax.jms.QueueConnection;
-import javax.jms.QueueConnectionFactory;
-import javax.jms.QueueSender;
-import javax.jms.QueueSession;
-import javax.jms.Session;
-import javax.jms.TextMessage;
+import jakarta.jms.Message;
+import jakarta.jms.MessageListener;
+import jakarta.jms.Queue;
+import jakarta.jms.QueueConnection;
+import jakarta.jms.QueueConnectionFactory;
+import jakarta.jms.QueueSender;
+import jakarta.jms.QueueSession;
+import jakarta.jms.Session;
+import jakarta.jms.TextMessage;
 
 import test.beans.TestApplicationScopedBean;
 import test.beans.TestRequestScopedBean;
diff --git a/appserver/tests/appserv-tests/devtests/cdi/smoke-tests/simple-mdb/build.xml b/appserver/tests/appserv-tests/devtests/cdi/smoke-tests/simple-mdb/build.xml
index e71984d..2dd253c 100644
--- a/appserver/tests/appserv-tests/devtests/cdi/smoke-tests/simple-mdb/build.xml
+++ b/appserver/tests/appserv-tests/devtests/cdi/smoke-tests/simple-mdb/build.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="ISO-8859-1"?>
 <!--
 
-    Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2010, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -79,7 +79,7 @@
     <target name="run_standaloneclient" depends="init-common">
        <java  fork="on" 
               failonerror="true"
-              classpath="${env.S1AS_HOME}/lib/javaee.jar:${env.S1AS_HOME}/modules/javax.jms.jar:${env.S1AS_HOME}/lib/gf-client.jar:${build.classes.dir}:${env.APS_HOME}/lib/reporter.jar"
+              classpath="${env.S1AS_HOME}/lib/javaee.jar:${env.S1AS_HOME}/modules/jakarta.jms-api.jar:${env.S1AS_HOME}/lib/gf-client.jar:${build.classes.dir}:${env.APS_HOME}/lib/reporter.jar"
               classname="${simple.client}">
         </java>
     </target>
diff --git a/appserver/tests/appserv-tests/devtests/cdi/smoke-tests/simple-mdb/client/Client.java b/appserver/tests/appserv-tests/devtests/cdi/smoke-tests/simple-mdb/client/Client.java
index a9ba3f0..3de50b1 100644
--- a/appserver/tests/appserv-tests/devtests/cdi/smoke-tests/simple-mdb/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/cdi/smoke-tests/simple-mdb/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2010, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -18,7 +18,7 @@
 import java.io.*;
 import java.util.*;
 import javax.ejb.EJBHome;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.annotation.Resource;
 import javax.naming.InitialContext;
 
@@ -46,10 +46,10 @@
     private static QueueConnectionFactory queueConFactory;
 
     @Resource(name="MsgBeanQueue", mappedName="jms/cdi_hello_mdb_InQueue")
-    private static javax.jms.Queue msgBeanQueue;
+    private static jakarta.jms.Queue msgBeanQueue;
 
     @Resource(name="ClientQueue", mappedName="foo")
-    private static javax.jms.Queue clientQueue;
+    private static jakarta.jms.Queue clientQueue;
 
     private QueueConnection queueCon;
     private QueueSession queueSession;
@@ -72,9 +72,9 @@
 
 		System.out.println("Java SE mode...");
 		InitialContext ic = new InitialContext();
-		queueConFactory = (javax.jms.QueueConnectionFactory) ic.lookup("jms/cdi_hello_mdb_QCF");
-		msgBeanQueue = (javax.jms.Queue) ic.lookup("jms/cdi_hello_mdb_InQueue");
-		clientQueue = (javax.jms.Queue) ic.lookup("jms/cdi_hello_mdb_OutQueue");
+		queueConFactory = (jakarta.jms.QueueConnectionFactory) ic.lookup("jms/cdi_hello_mdb_QCF");
+		msgBeanQueue = (jakarta.jms.Queue) ic.lookup("jms/cdi_hello_mdb_InQueue");
+		clientQueue = (jakarta.jms.Queue) ic.lookup("jms/cdi_hello_mdb_OutQueue");
 		
 	    }
 
@@ -115,7 +115,7 @@
         }
     }
 
-    public void sendMsgs(javax.jms.Queue queue, Message msg, int num) 
+    public void sendMsgs(jakarta.jms.Queue queue, Message msg, int num) 
         throws JMSException {
         for(int i = 0; i < num; i++) {
             System.out.println("Sending message " + i + " to " + queue + 
@@ -135,7 +135,7 @@
 
         message.setBooleanProperty("flag", true);
         message.setIntProperty("num", 2);
-        sendMsgs((javax.jms.Queue) dest, message, num);
+        sendMsgs((jakarta.jms.Queue) dest, message, num);
 
         System.out.println("Waiting for queue message");
         Message recvdmessage = queueReceiver.receive(TIMEOUT);
diff --git a/appserver/tests/appserv-tests/devtests/cdi/smoke-tests/simple-mdb/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/cdi/smoke-tests/simple-mdb/create_resources.asadmin
index 78a6f43..435b369 100644
--- a/appserver/tests/appserv-tests/devtests/cdi/smoke-tests/simple-mdb/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/cdi/smoke-tests/simple-mdb/create_resources.asadmin
@@ -1,5 +1,5 @@
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/cdi_hello_mdb_QCF
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/cdi_hello_mdb_QCF
 create-jmsdest --desttype queue cdi_hello_mdb_InQueue 
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=cdi_hello_mdb_InQueue jms/cdi_hello_mdb_InQueue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=cdi_hello_mdb_InQueue jms/cdi_hello_mdb_InQueue
 create-jmsdest --desttype queue cdi_hello_mdb_OutQueue 
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=cdi_hello_mdb_OutQueue jms/cdi_hello_mdb_OutQueue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=cdi_hello_mdb_OutQueue jms/cdi_hello_mdb_OutQueue
diff --git a/appserver/tests/appserv-tests/devtests/cdi/smoke-tests/simple-mdb/ejb/MessageBean.java b/appserver/tests/appserv-tests/devtests/cdi/smoke-tests/simple-mdb/ejb/MessageBean.java
index cdc7786..8be5eba 100644
--- a/appserver/tests/appserv-tests/devtests/cdi/smoke-tests/simple-mdb/ejb/MessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/cdi/smoke-tests/simple-mdb/ejb/MessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2010, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -24,15 +24,15 @@
 import javax.ejb.TransactionManagementType;
 import javax.ejb.ActivationConfigProperty;
 
-import javax.jms.MessageListener;
-import javax.jms.Message;
-import javax.jms.Queue;
-import javax.jms.QueueConnectionFactory;
-import javax.jms.QueueConnection;
-import javax.jms.QueueSession;
-import javax.jms.QueueSender;
-import javax.jms.TextMessage;
-import javax.jms.Session;
+import jakarta.jms.MessageListener;
+import jakarta.jms.Message;
+import jakarta.jms.Queue;
+import jakarta.jms.QueueConnectionFactory;
+import jakarta.jms.QueueConnection;
+import jakarta.jms.QueueSession;
+import jakarta.jms.QueueSender;
+import jakarta.jms.TextMessage;
+import jakarta.jms.Session;
 
 import javax.annotation.Resource;
 
diff --git a/appserver/tests/appserv-tests/devtests/connector/connector1.5-resourcesxml-module-scope/app/src/mdb/MyMessageBean.java b/appserver/tests/appserv-tests/devtests/connector/connector1.5-resourcesxml-module-scope/app/src/mdb/MyMessageBean.java
index 680251b..a1c633e 100755
--- a/appserver/tests/appserv-tests/devtests/connector/connector1.5-resourcesxml-module-scope/app/src/mdb/MyMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/connector/connector1.5-resourcesxml-module-scope/app/src/mdb/MyMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2001, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,12 +20,11 @@
 import javax.ejb.*;
 import javax.naming.*;
 import java.io.*;
-import java.rmi.RemoteException;
 import javax.servlet.*;
 import javax.servlet.http.*;
 import java.sql.*;
 import javax.sql.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.transaction.*;
 
 
@@ -63,7 +62,7 @@
     /**
      * onMessage method, declared as public (but not final or 
      * static), with a return type of void, and with one argument
-     * of type javax.jms.Message.
+     * of type jakarta.jms.Message.
      *
      * Casts the incoming Message to a TextMessage and displays 
      * the text.
diff --git a/appserver/tests/appserv-tests/devtests/connector/connector1.5-resourcesxml/app/src/mdb/MyMessageBean.java b/appserver/tests/appserv-tests/devtests/connector/connector1.5-resourcesxml/app/src/mdb/MyMessageBean.java
index 680251b..4aaab3d 100644
--- a/appserver/tests/appserv-tests/devtests/connector/connector1.5-resourcesxml/app/src/mdb/MyMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/connector/connector1.5-resourcesxml/app/src/mdb/MyMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2001, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,13 +19,11 @@
 import connector.MyMessageListener;
 import javax.ejb.*;
 import javax.naming.*;
-import java.io.*;
-import java.rmi.RemoteException;
 import javax.servlet.*;
 import javax.servlet.http.*;
 import java.sql.*;
 import javax.sql.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.transaction.*;
 
 
@@ -63,7 +61,7 @@
     /**
      * onMessage method, declared as public (but not final or 
      * static), with a return type of void, and with one argument
-     * of type javax.jms.Message.
+     * of type jakarta.jms.Message.
      *
      * Casts the incoming Message to a TextMessage and displays 
      * the text.
diff --git a/appserver/tests/appserv-tests/devtests/connector/connector1.5/app/src/mdb/MyMessageBean.java b/appserver/tests/appserv-tests/devtests/connector/connector1.5/app/src/mdb/MyMessageBean.java
index 8c0ba6b..844a6e3 100644
--- a/appserver/tests/appserv-tests/devtests/connector/connector1.5/app/src/mdb/MyMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/connector/connector1.5/app/src/mdb/MyMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2001, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,13 +19,11 @@
 import connector.MyMessageListener;
 import javax.ejb.*;
 import javax.naming.*;
-import java.io.*;
-import java.rmi.RemoteException;
 import javax.servlet.*;
 import javax.servlet.http.*;
 import java.sql.*;
 import javax.sql.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.transaction.*;
 
 
@@ -63,7 +61,7 @@
     /**
      * onMessage method, declared as public (but not final or 
      * static), with a return type of void, and with one argument
-     * of type javax.jms.Message.
+     * of type jakarta.jms.Message.
      *
      * Casts the incoming Message to a TextMessage and displays 
      * the text.
diff --git a/appserver/tests/appserv-tests/devtests/connector/embeddedConnector1.5-resourcesxml/app/src/mdb/MyMessageBean.java b/appserver/tests/appserv-tests/devtests/connector/embeddedConnector1.5-resourcesxml/app/src/mdb/MyMessageBean.java
index 8c0ba6b..287e037 100644
--- a/appserver/tests/appserv-tests/devtests/connector/embeddedConnector1.5-resourcesxml/app/src/mdb/MyMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/connector/embeddedConnector1.5-resourcesxml/app/src/mdb/MyMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2001, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,12 +20,11 @@
 import javax.ejb.*;
 import javax.naming.*;
 import java.io.*;
-import java.rmi.RemoteException;
 import javax.servlet.*;
 import javax.servlet.http.*;
 import java.sql.*;
 import javax.sql.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.transaction.*;
 
 
@@ -63,7 +62,7 @@
     /**
      * onMessage method, declared as public (but not final or 
      * static), with a return type of void, and with one argument
-     * of type javax.jms.Message.
+     * of type jakarta.jms.Message.
      *
      * Casts the incoming Message to a TextMessage and displays 
      * the text.
diff --git a/appserver/tests/appserv-tests/devtests/connector/embeddedConnector1.5/app/src/mdb/MyMessageBean.java b/appserver/tests/appserv-tests/devtests/connector/embeddedConnector1.5/app/src/mdb/MyMessageBean.java
index 8c0ba6b..844a6e3 100644
--- a/appserver/tests/appserv-tests/devtests/connector/embeddedConnector1.5/app/src/mdb/MyMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/connector/embeddedConnector1.5/app/src/mdb/MyMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2001, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,13 +19,11 @@
 import connector.MyMessageListener;
 import javax.ejb.*;
 import javax.naming.*;
-import java.io.*;
-import java.rmi.RemoteException;
 import javax.servlet.*;
 import javax.servlet.http.*;
 import java.sql.*;
 import javax.sql.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.transaction.*;
 
 
@@ -63,7 +61,7 @@
     /**
      * onMessage method, declared as public (but not final or 
      * static), with a return type of void, and with one argument
-     * of type javax.jms.Message.
+     * of type jakarta.jms.Message.
      *
      * Casts the incoming Message to a TextMessage and displays 
      * the text.
diff --git a/appserver/tests/appserv-tests/devtests/connector/mq/cmt/client/SimpleMessageClient.java b/appserver/tests/appserv-tests/devtests/connector/mq/cmt/client/SimpleMessageClient.java
index 9962c23..7c6a084 100644
--- a/appserver/tests/appserv-tests/devtests/connector/mq/cmt/client/SimpleMessageClient.java
+++ b/appserver/tests/appserv-tests/devtests/connector/mq/cmt/client/SimpleMessageClient.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,7 +16,7 @@
 
 package com.sun.s1peqe.mq.cmt.excpt.client;
 
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.naming.*;
 import java.sql.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
diff --git a/appserver/tests/appserv-tests/devtests/connector/mq/cmt/descriptor/application-client.xml b/appserver/tests/appserv-tests/devtests/connector/mq/cmt/descriptor/application-client.xml
index 7ede645..4d8930f 100644
--- a/appserver/tests/appserv-tests/devtests/connector/mq/cmt/descriptor/application-client.xml
+++ b/appserver/tests/appserv-tests/devtests/connector/mq/cmt/descriptor/application-client.xml
@@ -2,7 +2,7 @@
 <!DOCTYPE application-client PUBLIC '-//Sun Microsystems, Inc.//DTD J2EE Application Client 1.3//EN' 'http://java.sun.com/dtd/application-client_1_3.dtd'>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -22,13 +22,13 @@
   <display-name>mq-cmt-excptClient</display-name>
   <resource-ref>
     <res-ref-name>jms/QCFactory</res-ref-name>
-    <res-type>javax.jms.QueueConnectionFactory</res-type>
+    <res-type>jakarta.jms.QueueConnectionFactory</res-type>
     <res-auth>Container</res-auth>
     <res-sharing-scope>Shareable</res-sharing-scope>
   </resource-ref>
   <resource-env-ref>
     <resource-env-ref-name>jms/SampleQueue</resource-env-ref-name>
-    <resource-env-ref-type>javax.jms.Queue</resource-env-ref-type>
+    <resource-env-ref-type>jakarta.jms.Queue</resource-env-ref-type>
   </resource-env-ref>
 </application-client>
 
diff --git a/appserver/tests/appserv-tests/devtests/connector/mq/cmt/descriptor/ejb-jar.xml b/appserver/tests/appserv-tests/devtests/connector/mq/cmt/descriptor/ejb-jar.xml
index 834fc74..5c0ac13 100644
--- a/appserver/tests/appserv-tests/devtests/connector/mq/cmt/descriptor/ejb-jar.xml
+++ b/appserver/tests/appserv-tests/devtests/connector/mq/cmt/descriptor/ejb-jar.xml
@@ -2,7 +2,7 @@
 <!DOCTYPE ejb-jar PUBLIC '-//Sun Microsystems, Inc.//DTD Enterprise JavaBeans 2.0//EN' 'http://java.sun.com/dtd/ejb-jar_2_0.dtd'>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -27,7 +27,7 @@
       <ejb-class>com.sun.s1peqe.mq.cmt.excpt.ejb.SimpleMessageBean</ejb-class>
       <transaction-type>Container</transaction-type>
       <message-driven-destination>
-        <destination-type>javax.jms.Queue</destination-type>
+        <destination-type>jakarta.jms.Queue</destination-type>
       </message-driven-destination>
     </message-driven>
   </enterprise-beans>
@@ -37,7 +37,7 @@
         <ejb-name>SimpleMessageEJB</ejb-name>
         <method-name>onMessage</method-name>
         <method-params>
-          <method-param>javax.jms.Message</method-param>
+          <method-param>jakarta.jms.Message</method-param>
         </method-params>
       </method>
       <trans-attribute>Required</trans-attribute>
diff --git a/appserver/tests/appserv-tests/devtests/connector/mq/cmt/ejb/SimpleMessageBean.java b/appserver/tests/appserv-tests/devtests/connector/mq/cmt/ejb/SimpleMessageBean.java
index 49d0f6d..0d7180a 100644
--- a/appserver/tests/appserv-tests/devtests/connector/mq/cmt/ejb/SimpleMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/connector/mq/cmt/ejb/SimpleMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,14 +16,10 @@
 
 package com.sun.s1peqe.mq.cmt.excpt.ejb;
 
-import java.io.Serializable;
-import java.rmi.RemoteException;
-import javax.ejb.EJBException;
 import javax.ejb.MessageDrivenBean;
 import javax.ejb.MessageDrivenContext;
-import javax.ejb.CreateException;
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import java.sql.*;
 
 public class SimpleMessageBean implements MessageDrivenBean,
diff --git a/appserver/tests/appserv-tests/devtests/connector/mq/ejb30mdb-resources-xml/client/Client.java b/appserver/tests/appserv-tests/devtests/connector/mq/ejb30mdb-resources-xml/client/Client.java
index 8999787..bb173f6 100755
--- a/appserver/tests/appserv-tests/devtests/connector/mq/ejb30mdb-resources-xml/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/connector/mq/ejb30mdb-resources-xml/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2002, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2002, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,7 +19,7 @@
 import java.io.*;
 import java.util.*;
 import javax.ejb.EJBHome;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.annotation.Resource;
 
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
@@ -46,11 +46,11 @@
  
     //Target Queue
     @Resource(mappedName="java:app/jms/ejb_ejb30_hello_mdb_InQueue")
-    private static javax.jms.Queue msgBeanQueue;
+    private static jakarta.jms.Queue msgBeanQueue;
 
     //Reply Queue
     @Resource(mappedName="java:app/jms/ejb_ejb30_hello_mdb_OutQueue")
-    private static javax.jms.Queue clientQueue;
+    private static jakarta.jms.Queue clientQueue;
 
     private QueueConnection queueCon;
     private QueueSession queueSession;
@@ -98,7 +98,7 @@
         }
     }
 
-    public void sendMsgs(javax.jms.Queue queue, int num) 
+    public void sendMsgs(jakarta.jms.Queue queue, int num) 
         throws JMSException {
         for(int i = 0; i < num; i++) {
             Message message = queueSession.createTextMessage("foo #" + (i + 1));
@@ -113,7 +113,7 @@
 
     public void doTest(int num) 
         throws Exception {
-        sendMsgs((javax.jms.Queue) msgBeanQueue, num);
+        sendMsgs((jakarta.jms.Queue) msgBeanQueue, num);
         
 	//Now attempt to receive responses to our message
         System.out.println("Waiting for queue message");
diff --git a/appserver/tests/appserv-tests/devtests/connector/mq/ejb30mdb-resources-xml/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/connector/mq/ejb30mdb-resources-xml/create_resources.asadmin
index 086f9b3..6db82e8 100755
--- a/appserver/tests/appserv-tests/devtests/connector/mq/ejb30mdb-resources-xml/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/connector/mq/ejb30mdb-resources-xml/create_resources.asadmin
@@ -1,8 +1,8 @@
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/ejb_ejb30_hello_mdb_QCF
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/ejb_ejb30_hello_mdb_QCF
 
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=ejb_ejb30_hello_mdb_InQueue jms/ejb_ejb30_hello_mdb_InQueue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=ejb_ejb30_hello_mdb_InQueue jms/ejb_ejb30_hello_mdb_InQueue
 
 
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=ejb_ejb30_hello_mdb_OutQueue jms/ejb_ejb30_hello_mdb_OutQueue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=ejb_ejb30_hello_mdb_OutQueue jms/ejb_ejb30_hello_mdb_OutQueue
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/connector/mq/ejb30mdb-resources-xml/descriptor/glassfish-resources.xml b/appserver/tests/appserv-tests/devtests/connector/mq/ejb30mdb-resources-xml/descriptor/glassfish-resources.xml
index 1b4e8f5..680adf7 100755
--- a/appserver/tests/appserv-tests/devtests/connector/mq/ejb30mdb-resources-xml/descriptor/glassfish-resources.xml
+++ b/appserver/tests/appserv-tests/devtests/connector/mq/ejb30mdb-resources-xml/descriptor/glassfish-resources.xml
@@ -2,7 +2,7 @@
 <!DOCTYPE resources PUBLIC "-//GlassFish.org//DTD GlassFish Application Server 3.1 Resource Definitions //EN" "http://glassfish.org/dtds/glassfish-resources_1_5.dtd">
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,12 +19,12 @@
 -->
 
 <resources>
-<connector-connection-pool max-pool-size="250" steady-pool-size="1" name="jms/ejb_ejb30_hello_mdb_QCF" resource-adapter-name="jmsra" connection-definition-name="javax.jms.QueueConnectionFactory"></connector-connection-pool>
+<connector-connection-pool max-pool-size="250" steady-pool-size="1" name="jms/ejb_ejb30_hello_mdb_QCF" resource-adapter-name="jmsra" connection-definition-name="jakarta.jms.QueueConnectionFactory"></connector-connection-pool>
     <connector-resource pool-name="jms/ejb_ejb30_hello_mdb_QCF" jndi-name="jms/ejb_ejb30_hello_mdb_QCF"></connector-resource>
-    <admin-object-resource res-adapter="jmsra" res-type="javax.jms.Queue" jndi-name="jms/ejb_ejb30_hello_mdb_InQueue">
+    <admin-object-resource res-adapter="jmsra" res-type="jakarta.jms.Queue" jndi-name="jms/ejb_ejb30_hello_mdb_InQueue">
       <property name="Name" value="ejb_ejb30_hello_mdb_InQueue"></property>
     </admin-object-resource>
-    <admin-object-resource res-adapter="jmsra" res-type="javax.jms.Queue" jndi-name="jms/ejb_ejb30_hello_mdb_OutQueue">
+    <admin-object-resource res-adapter="jmsra" res-type="jakarta.jms.Queue" jndi-name="jms/ejb_ejb30_hello_mdb_OutQueue">
       <property name="Name" value="ejb_ejb30_hello_mdb_OutQueue"></property>
     </admin-object-resource>
 </resources>
diff --git a/appserver/tests/appserv-tests/devtests/connector/mq/ejb30mdb-resources-xml/ejb/MessageBean.java b/appserver/tests/appserv-tests/devtests/connector/mq/ejb30mdb-resources-xml/ejb/MessageBean.java
index f22219c..b62bb02 100755
--- a/appserver/tests/appserv-tests/devtests/connector/mq/ejb30mdb-resources-xml/ejb/MessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/connector/mq/ejb30mdb-resources-xml/ejb/MessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -18,7 +18,7 @@
 
 import javax.annotation.Resource;
 import javax.ejb.*;
-import javax.jms.*;
+import jakarta.jms.*;
 
 //Messages received from InQueue
 @MessageDriven(mappedName="java:app/jms/ejb_ejb30_hello_mdb_InQueue")
diff --git a/appserver/tests/appserv-tests/devtests/connector/mq/ejb30mdb/client/Client.java b/appserver/tests/appserv-tests/devtests/connector/mq/ejb30mdb/client/Client.java
index fb3f3ae..a7ca15c 100644
--- a/appserver/tests/appserv-tests/devtests/connector/mq/ejb30mdb/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/connector/mq/ejb30mdb/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2002, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2002, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,7 +19,7 @@
 import java.io.*;
 import java.util.*;
 import javax.ejb.EJBHome;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.annotation.Resource;
 
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
@@ -46,11 +46,11 @@
  
     //Target Queue
     @Resource(mappedName="jms/ejb_ejb30_hello_mdb_InQueue")
-    private static javax.jms.Queue msgBeanQueue;
+    private static jakarta.jms.Queue msgBeanQueue;
 
     //Reply Queue
     @Resource(mappedName="jms/ejb_ejb30_hello_mdb_OutQueue")
-    private static javax.jms.Queue clientQueue;
+    private static jakarta.jms.Queue clientQueue;
 
     private QueueConnection queueCon;
     private QueueSession queueSession;
@@ -98,7 +98,7 @@
         }
     }
 
-    public void sendMsgs(javax.jms.Queue queue, int num) 
+    public void sendMsgs(jakarta.jms.Queue queue, int num) 
         throws JMSException {
         for(int i = 0; i < num; i++) {
             Message message = queueSession.createTextMessage("foo #" + (i + 1));
@@ -113,7 +113,7 @@
 
     public void doTest(int num) 
         throws Exception {
-        sendMsgs((javax.jms.Queue) msgBeanQueue, num);
+        sendMsgs((jakarta.jms.Queue) msgBeanQueue, num);
         
 	//Now attempt to receive responses to our message
         System.out.println("Waiting for queue message");
diff --git a/appserver/tests/appserv-tests/devtests/connector/mq/ejb30mdb/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/connector/mq/ejb30mdb/create_resources.asadmin
index 086f9b3..6db82e8 100644
--- a/appserver/tests/appserv-tests/devtests/connector/mq/ejb30mdb/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/connector/mq/ejb30mdb/create_resources.asadmin
@@ -1,8 +1,8 @@
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/ejb_ejb30_hello_mdb_QCF
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/ejb_ejb30_hello_mdb_QCF
 
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=ejb_ejb30_hello_mdb_InQueue jms/ejb_ejb30_hello_mdb_InQueue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=ejb_ejb30_hello_mdb_InQueue jms/ejb_ejb30_hello_mdb_InQueue
 
 
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=ejb_ejb30_hello_mdb_OutQueue jms/ejb_ejb30_hello_mdb_OutQueue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=ejb_ejb30_hello_mdb_OutQueue jms/ejb_ejb30_hello_mdb_OutQueue
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/connector/mq/ejb30mdb/ejb/MessageBean.java b/appserver/tests/appserv-tests/devtests/connector/mq/ejb30mdb/ejb/MessageBean.java
index d7400b3..d3ad825 100644
--- a/appserver/tests/appserv-tests/devtests/connector/mq/ejb30mdb/ejb/MessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/connector/mq/ejb30mdb/ejb/MessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -18,7 +18,7 @@
 
 import javax.annotation.Resource;
 import javax.ejb.*;
-import javax.jms.*;
+import jakarta.jms.*;
 
 //Messages received from InQueue
 @MessageDriven(mappedName="jms/ejb_ejb30_hello_mdb_InQueue")
diff --git a/appserver/tests/appserv-tests/devtests/connector/mq/lifecycle/client/SimpleMessageClient.java b/appserver/tests/appserv-tests/devtests/connector/mq/lifecycle/client/SimpleMessageClient.java
index e246b98..b3b7d30 100644
--- a/appserver/tests/appserv-tests/devtests/connector/mq/lifecycle/client/SimpleMessageClient.java
+++ b/appserver/tests/appserv-tests/devtests/connector/mq/lifecycle/client/SimpleMessageClient.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,7 +16,7 @@
 
 package com.sun.s1peqe.mq.cmt.excpt.client;
 
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.naming.*;
 import java.sql.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
diff --git a/appserver/tests/appserv-tests/devtests/connector/mq/lifecycle/descriptor/application-client.xml b/appserver/tests/appserv-tests/devtests/connector/mq/lifecycle/descriptor/application-client.xml
index 7ede645..4d8930f 100644
--- a/appserver/tests/appserv-tests/devtests/connector/mq/lifecycle/descriptor/application-client.xml
+++ b/appserver/tests/appserv-tests/devtests/connector/mq/lifecycle/descriptor/application-client.xml
@@ -2,7 +2,7 @@
 <!DOCTYPE application-client PUBLIC '-//Sun Microsystems, Inc.//DTD J2EE Application Client 1.3//EN' 'http://java.sun.com/dtd/application-client_1_3.dtd'>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -22,13 +22,13 @@
   <display-name>mq-cmt-excptClient</display-name>
   <resource-ref>
     <res-ref-name>jms/QCFactory</res-ref-name>
-    <res-type>javax.jms.QueueConnectionFactory</res-type>
+    <res-type>jakarta.jms.QueueConnectionFactory</res-type>
     <res-auth>Container</res-auth>
     <res-sharing-scope>Shareable</res-sharing-scope>
   </resource-ref>
   <resource-env-ref>
     <resource-env-ref-name>jms/SampleQueue</resource-env-ref-name>
-    <resource-env-ref-type>javax.jms.Queue</resource-env-ref-type>
+    <resource-env-ref-type>jakarta.jms.Queue</resource-env-ref-type>
   </resource-env-ref>
 </application-client>
 
diff --git a/appserver/tests/appserv-tests/devtests/connector/mq/lifecycle/descriptor/ejb-jar.xml b/appserver/tests/appserv-tests/devtests/connector/mq/lifecycle/descriptor/ejb-jar.xml
index 06db304..c9d52b2 100644
--- a/appserver/tests/appserv-tests/devtests/connector/mq/lifecycle/descriptor/ejb-jar.xml
+++ b/appserver/tests/appserv-tests/devtests/connector/mq/lifecycle/descriptor/ejb-jar.xml
@@ -2,7 +2,7 @@
 <!DOCTYPE ejb-jar PUBLIC '-//Sun Microsystems, Inc.//DTD Enterprise JavaBeans 2.0//EN' 'http://java.sun.com/dtd/ejb-jar_2_0.dtd'>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -27,7 +27,7 @@
       <ejb-class>com.sun.s1peqe.mq.cmt.excpt.ejb.SimpleMessageBean</ejb-class>
       <transaction-type>Bean</transaction-type>
       <message-driven-destination>
-        <destination-type>javax.jms.Queue</destination-type>
+        <destination-type>jakarta.jms.Queue</destination-type>
       </message-driven-destination>
     </message-driven>
   </enterprise-beans>
diff --git a/appserver/tests/appserv-tests/devtests/connector/mq/lifecycle/ejb/SimpleMessageBean.java b/appserver/tests/appserv-tests/devtests/connector/mq/lifecycle/ejb/SimpleMessageBean.java
index f47ba27..6974b78 100644
--- a/appserver/tests/appserv-tests/devtests/connector/mq/lifecycle/ejb/SimpleMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/connector/mq/lifecycle/ejb/SimpleMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,14 +16,12 @@
 
 package com.sun.s1peqe.mq.cmt.excpt.ejb;
 
-import java.io.Serializable;
-import java.rmi.RemoteException;
 import javax.ejb.EJBException;
 import javax.ejb.MessageDrivenBean;
 import javax.ejb.MessageDrivenContext;
 import javax.ejb.CreateException;
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import java.sql.*;
 
 public class SimpleMessageBean implements MessageDrivenBean,
diff --git a/appserver/tests/appserv-tests/devtests/connector/mq/lifecycle/src/LifecycleListenerImpl.java b/appserver/tests/appserv-tests/devtests/connector/mq/lifecycle/src/LifecycleListenerImpl.java
index a216bc6..c0668eb 100644
--- a/appserver/tests/appserv-tests/devtests/connector/mq/lifecycle/src/LifecycleListenerImpl.java
+++ b/appserver/tests/appserv-tests/devtests/connector/mq/lifecycle/src/LifecycleListenerImpl.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2002, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2002, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -15,9 +15,7 @@
  */
 
 package samples.lifecycle.simple;
-import java.util.Properties;
-import java.util.Date;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.naming.*;
 import java.sql.*;
 
diff --git a/appserver/tests/appserv-tests/devtests/connector/mq/simplestress/build.xml b/appserver/tests/appserv-tests/devtests/connector/mq/simplestress/build.xml
index 28e00d0..82378b1 100644
--- a/appserver/tests/appserv-tests/devtests/connector/mq/simplestress/build.xml
+++ b/appserver/tests/appserv-tests/devtests/connector/mq/simplestress/build.xml
@@ -2,7 +2,7 @@
 <!DOCTYPE project [
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -59,7 +59,7 @@
             <param name="jms.factory.name"
                  value="jms/CFactory"/>
             <param name="jms.factory.type"
-                 value="javax.jms.ConnectionFactory"/>
+                 value="jakarta.jms.ConnectionFactory"/>
         </antcall>
         <antcall target="create-jms-resource-common">
             <param name="dest.name"
@@ -69,7 +69,7 @@
             <param name="jms.resource.name"
                  value="jms/clientQueue"/>
             <param name="jms.resource.type"
-                 value="javax.jms.Queue"/>
+                 value="jakarta.jms.Queue"/>
         </antcall>
     </target>
 
@@ -98,7 +98,7 @@
             <param name="jms.factory.name"
                  value="jms/CFactory"/>
             <param name="jms.factory.type"
-                 value="javax.jms.ConnectionFactory"/>
+                 value="jakarta.jms.ConnectionFactory"/>
         </antcall>
     </target>
 
diff --git a/appserver/tests/appserv-tests/devtests/connector/mq/simplestress/client/SimpleMessageClient.java b/appserver/tests/appserv-tests/devtests/connector/mq/simplestress/client/SimpleMessageClient.java
index 5297e57..057c998 100644
--- a/appserver/tests/appserv-tests/devtests/connector/mq/simplestress/client/SimpleMessageClient.java
+++ b/appserver/tests/appserv-tests/devtests/connector/mq/simplestress/client/SimpleMessageClient.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,7 +16,7 @@
 
 package com.sun.s1peqe.connector.mq.simplestress.client;
 
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.naming.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/connector/mq/simplestress/descriptor/application-client.xml b/appserver/tests/appserv-tests/devtests/connector/mq/simplestress/descriptor/application-client.xml
index 5e7fccc..c8120ce 100644
--- a/appserver/tests/appserv-tests/devtests/connector/mq/simplestress/descriptor/application-client.xml
+++ b/appserver/tests/appserv-tests/devtests/connector/mq/simplestress/descriptor/application-client.xml
@@ -2,7 +2,7 @@
 <!DOCTYPE application-client PUBLIC '-//Sun Microsystems, Inc.//DTD J2EE Application Client 1.3//EN' 'http://java.sun.com/dtd/application-client_1_3.dtd'>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -22,17 +22,17 @@
   <display-name>connector-mq-simplestressClient</display-name>
   <resource-ref>
     <res-ref-name>jms/CFactory</res-ref-name>
-    <res-type>javax.jms.ConnectionFactory</res-type>
+    <res-type>jakarta.jms.ConnectionFactory</res-type>
     <res-auth>Container</res-auth>
     <res-sharing-scope>Shareable</res-sharing-scope>
   </resource-ref>
   <resource-env-ref>
     <resource-env-ref-name>jms/SampleQueue</resource-env-ref-name>
-    <resource-env-ref-type>javax.jms.Queue</resource-env-ref-type>
+    <resource-env-ref-type>jakarta.jms.Queue</resource-env-ref-type>
   </resource-env-ref>
   <resource-env-ref>
     <resource-env-ref-name>jms/clientQueue</resource-env-ref-name>
-    <resource-env-ref-type>javax.jms.Queue</resource-env-ref-type>
+    <resource-env-ref-type>jakarta.jms.Queue</resource-env-ref-type>
   </resource-env-ref>
 </application-client>
 
diff --git a/appserver/tests/appserv-tests/devtests/connector/mq/simplestress/descriptor/ejb-jar.xml b/appserver/tests/appserv-tests/devtests/connector/mq/simplestress/descriptor/ejb-jar.xml
index 4e1a179..a47bc90 100644
--- a/appserver/tests/appserv-tests/devtests/connector/mq/simplestress/descriptor/ejb-jar.xml
+++ b/appserver/tests/appserv-tests/devtests/connector/mq/simplestress/descriptor/ejb-jar.xml
@@ -2,7 +2,7 @@
 <!DOCTYPE ejb-jar PUBLIC '-//Sun Microsystems, Inc.//DTD Enterprise JavaBeans 2.0//EN' 'http://java.sun.com/dtd/ejb-jar_2_0.dtd'>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -27,17 +27,17 @@
       <ejb-class>com.sun.s1peqe.connector.mq.simplestress.ejb.SimpleMessageBean</ejb-class>
       <transaction-type>Bean</transaction-type>
       <message-driven-destination>
-        <destination-type>javax.jms.Queue</destination-type>
+        <destination-type>jakarta.jms.Queue</destination-type>
       </message-driven-destination>
       <resource-ref>
         <res-ref-name>jms/CFactory</res-ref-name>
-        <res-type>javax.jms.ConnectionFactory</res-type>
+        <res-type>jakarta.jms.ConnectionFactory</res-type>
         <res-auth>Container</res-auth>
         <res-sharing-scope>Shareable</res-sharing-scope>
       </resource-ref>
       <resource-env-ref>
         <resource-env-ref-name>jms/clientQueue</resource-env-ref-name>
-	<resource-env-ref-type>javax.jms.Queue</resource-env-ref-type>
+	<resource-env-ref-type>jakarta.jms.Queue</resource-env-ref-type>
       </resource-env-ref>
     </message-driven>
   </enterprise-beans>
diff --git a/appserver/tests/appserv-tests/devtests/connector/mq/simplestress/ejb/SimpleMessageBean.java b/appserver/tests/appserv-tests/devtests/connector/mq/simplestress/ejb/SimpleMessageBean.java
index 0c81270..507dcd1 100644
--- a/appserver/tests/appserv-tests/devtests/connector/mq/simplestress/ejb/SimpleMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/connector/mq/simplestress/ejb/SimpleMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,14 +16,10 @@
 
 package com.sun.s1peqe.connector.mq.simplestress.ejb;
 
-import java.io.Serializable;
-import java.rmi.RemoteException;
-import javax.ejb.EJBException;
 import javax.ejb.MessageDrivenBean;
 import javax.ejb.MessageDrivenContext;
-import javax.ejb.CreateException;
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 
 public class SimpleMessageBean implements MessageDrivenBean,
     MessageListener {
diff --git a/appserver/tests/appserv-tests/devtests/connector/mq/stress/build.xml b/appserver/tests/appserv-tests/devtests/connector/mq/stress/build.xml
index b339168..fa76f10 100644
--- a/appserver/tests/appserv-tests/devtests/connector/mq/stress/build.xml
+++ b/appserver/tests/appserv-tests/devtests/connector/mq/stress/build.xml
@@ -2,7 +2,7 @@
 <!DOCTYPE project [
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -64,7 +64,7 @@
             <param name="jms.resource.name"
                  value="jms/clientQueue"/>
             <param name="jms.resource.type"
-                 value="javax.jms.Queue"/>
+                 value="jakarta.jms.Queue"/>
         </antcall>
     </target>
 
diff --git a/appserver/tests/appserv-tests/devtests/connector/mq/stress/client/SimpleMessageClient.java b/appserver/tests/appserv-tests/devtests/connector/mq/stress/client/SimpleMessageClient.java
index 22517aa..942a0e9 100644
--- a/appserver/tests/appserv-tests/devtests/connector/mq/stress/client/SimpleMessageClient.java
+++ b/appserver/tests/appserv-tests/devtests/connector/mq/stress/client/SimpleMessageClient.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,7 +16,7 @@
 
 package com.sun.s1peqe.connector.mq.simplestress.client;
 
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.naming.*;
 import java.util.ArrayList;
 import java.util.HashMap;
diff --git a/appserver/tests/appserv-tests/devtests/connector/mq/stress/descriptor/application-client.xml b/appserver/tests/appserv-tests/devtests/connector/mq/stress/descriptor/application-client.xml
index 3046e19..e4a3b74 100644
--- a/appserver/tests/appserv-tests/devtests/connector/mq/stress/descriptor/application-client.xml
+++ b/appserver/tests/appserv-tests/devtests/connector/mq/stress/descriptor/application-client.xml
@@ -2,7 +2,7 @@
 <!DOCTYPE application-client PUBLIC '-//Sun Microsystems, Inc.//DTD J2EE Application Client 1.3//EN' 'http://java.sun.com/dtd/application-client_1_3.dtd'>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -22,17 +22,17 @@
   <display-name>connector-mq-simplestressClient</display-name>
   <resource-ref>
     <res-ref-name>jms/QCFactory</res-ref-name>
-    <res-type>javax.jms.QueueConnectionFactory</res-type>
+    <res-type>jakarta.jms.QueueConnectionFactory</res-type>
     <res-auth>Container</res-auth>
     <res-sharing-scope>Shareable</res-sharing-scope>
   </resource-ref>
   <resource-env-ref>
     <resource-env-ref-name>jms/SampleQueue</resource-env-ref-name>
-    <resource-env-ref-type>javax.jms.Queue</resource-env-ref-type>
+    <resource-env-ref-type>jakarta.jms.Queue</resource-env-ref-type>
   </resource-env-ref>
   <resource-env-ref>
     <resource-env-ref-name>jms/clientQueue</resource-env-ref-name>
-    <resource-env-ref-type>javax.jms.Queue</resource-env-ref-type>
+    <resource-env-ref-type>jakarta.jms.Queue</resource-env-ref-type>
   </resource-env-ref>
 </application-client>
 
diff --git a/appserver/tests/appserv-tests/devtests/connector/mq/stress/descriptor/ejb-jar.xml b/appserver/tests/appserv-tests/devtests/connector/mq/stress/descriptor/ejb-jar.xml
index e222b5e..3811a29 100644
--- a/appserver/tests/appserv-tests/devtests/connector/mq/stress/descriptor/ejb-jar.xml
+++ b/appserver/tests/appserv-tests/devtests/connector/mq/stress/descriptor/ejb-jar.xml
@@ -2,7 +2,7 @@
 <!DOCTYPE ejb-jar PUBLIC '-//Sun Microsystems, Inc.//DTD Enterprise JavaBeans 2.0//EN' 'http://java.sun.com/dtd/ejb-jar_2_0.dtd'>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -27,17 +27,17 @@
       <ejb-class>com.sun.s1peqe.connector.mq.simplestress.ejb.SimpleMessageBean</ejb-class>
       <transaction-type>Bean</transaction-type>
       <message-driven-destination>
-        <destination-type>javax.jms.Queue</destination-type>
+        <destination-type>jakarta.jms.Queue</destination-type>
       </message-driven-destination>
       <resource-ref>
         <res-ref-name>jms/QCFactory</res-ref-name>
-        <res-type>javax.jms.QueueConnectionFactory</res-type>
+        <res-type>jakarta.jms.QueueConnectionFactory</res-type>
         <res-auth>Container</res-auth>
         <res-sharing-scope>Shareable</res-sharing-scope>
       </resource-ref>
       <resource-env-ref>
         <resource-env-ref-name>jms/clientQueue</resource-env-ref-name>
-	<resource-env-ref-type>javax.jms.Queue</resource-env-ref-type>
+	<resource-env-ref-type>jakarta.jms.Queue</resource-env-ref-type>
       </resource-env-ref>
     </message-driven>
   </enterprise-beans>
diff --git a/appserver/tests/appserv-tests/devtests/connector/mq/stress/ejb/SimpleMessageBean.java b/appserver/tests/appserv-tests/devtests/connector/mq/stress/ejb/SimpleMessageBean.java
index 5724461..3f0a64f 100644
--- a/appserver/tests/appserv-tests/devtests/connector/mq/stress/ejb/SimpleMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/connector/mq/stress/ejb/SimpleMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,14 +16,10 @@
 
 package com.sun.s1peqe.connector.mq.simplestress.ejb;
 
-import java.io.Serializable;
-import java.rmi.RemoteException;
-import javax.ejb.EJBException;
 import javax.ejb.MessageDrivenBean;
 import javax.ejb.MessageDrivenContext;
-import javax.ejb.CreateException;
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 
 public class SimpleMessageBean implements MessageDrivenBean,
     MessageListener {
diff --git a/appserver/tests/appserv-tests/devtests/connector/mq/varhome/build.xml b/appserver/tests/appserv-tests/devtests/connector/mq/varhome/build.xml
index 172205e..8fd4b6f 100644
--- a/appserver/tests/appserv-tests/devtests/connector/mq/varhome/build.xml
+++ b/appserver/tests/appserv-tests/devtests/connector/mq/varhome/build.xml
@@ -2,7 +2,7 @@
 <!DOCTYPE project [
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -66,7 +66,7 @@
             <param name="jms.resource.name"
                  value="jms/clientQueue"/>
             <param name="jms.resource.type"
-                 value="javax.jms.Queue"/>
+                 value="jakarta.jms.Queue"/>
         </antcall>
     </target>
 
diff --git a/appserver/tests/appserv-tests/devtests/connector/mq/varhome/client/SimpleMessageClient.java b/appserver/tests/appserv-tests/devtests/connector/mq/varhome/client/SimpleMessageClient.java
index 21f99a9..967c8d3 100644
--- a/appserver/tests/appserv-tests/devtests/connector/mq/varhome/client/SimpleMessageClient.java
+++ b/appserver/tests/appserv-tests/devtests/connector/mq/varhome/client/SimpleMessageClient.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,7 +16,7 @@
 
 package com.sun.s1peqe.connector.mq.simplestress.client;
 
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.naming.*;
 import java.util.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
diff --git a/appserver/tests/appserv-tests/devtests/connector/mq/varhome/descriptor/application-client.xml b/appserver/tests/appserv-tests/devtests/connector/mq/varhome/descriptor/application-client.xml
index 3046e19..e4a3b74 100644
--- a/appserver/tests/appserv-tests/devtests/connector/mq/varhome/descriptor/application-client.xml
+++ b/appserver/tests/appserv-tests/devtests/connector/mq/varhome/descriptor/application-client.xml
@@ -2,7 +2,7 @@
 <!DOCTYPE application-client PUBLIC '-//Sun Microsystems, Inc.//DTD J2EE Application Client 1.3//EN' 'http://java.sun.com/dtd/application-client_1_3.dtd'>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -22,17 +22,17 @@
   <display-name>connector-mq-simplestressClient</display-name>
   <resource-ref>
     <res-ref-name>jms/QCFactory</res-ref-name>
-    <res-type>javax.jms.QueueConnectionFactory</res-type>
+    <res-type>jakarta.jms.QueueConnectionFactory</res-type>
     <res-auth>Container</res-auth>
     <res-sharing-scope>Shareable</res-sharing-scope>
   </resource-ref>
   <resource-env-ref>
     <resource-env-ref-name>jms/SampleQueue</resource-env-ref-name>
-    <resource-env-ref-type>javax.jms.Queue</resource-env-ref-type>
+    <resource-env-ref-type>jakarta.jms.Queue</resource-env-ref-type>
   </resource-env-ref>
   <resource-env-ref>
     <resource-env-ref-name>jms/clientQueue</resource-env-ref-name>
-    <resource-env-ref-type>javax.jms.Queue</resource-env-ref-type>
+    <resource-env-ref-type>jakarta.jms.Queue</resource-env-ref-type>
   </resource-env-ref>
 </application-client>
 
diff --git a/appserver/tests/appserv-tests/devtests/connector/mq/varhome/descriptor/ejb-jar.xml b/appserver/tests/appserv-tests/devtests/connector/mq/varhome/descriptor/ejb-jar.xml
index e222b5e..3811a29 100644
--- a/appserver/tests/appserv-tests/devtests/connector/mq/varhome/descriptor/ejb-jar.xml
+++ b/appserver/tests/appserv-tests/devtests/connector/mq/varhome/descriptor/ejb-jar.xml
@@ -2,7 +2,7 @@
 <!DOCTYPE ejb-jar PUBLIC '-//Sun Microsystems, Inc.//DTD Enterprise JavaBeans 2.0//EN' 'http://java.sun.com/dtd/ejb-jar_2_0.dtd'>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -27,17 +27,17 @@
       <ejb-class>com.sun.s1peqe.connector.mq.simplestress.ejb.SimpleMessageBean</ejb-class>
       <transaction-type>Bean</transaction-type>
       <message-driven-destination>
-        <destination-type>javax.jms.Queue</destination-type>
+        <destination-type>jakarta.jms.Queue</destination-type>
       </message-driven-destination>
       <resource-ref>
         <res-ref-name>jms/QCFactory</res-ref-name>
-        <res-type>javax.jms.QueueConnectionFactory</res-type>
+        <res-type>jakarta.jms.QueueConnectionFactory</res-type>
         <res-auth>Container</res-auth>
         <res-sharing-scope>Shareable</res-sharing-scope>
       </resource-ref>
       <resource-env-ref>
         <resource-env-ref-name>jms/clientQueue</resource-env-ref-name>
-	<resource-env-ref-type>javax.jms.Queue</resource-env-ref-type>
+	<resource-env-ref-type>jakarta.jms.Queue</resource-env-ref-type>
       </resource-env-ref>
     </message-driven>
   </enterprise-beans>
diff --git a/appserver/tests/appserv-tests/devtests/connector/mq/varhome/ejb/SimpleMessageBean.java b/appserver/tests/appserv-tests/devtests/connector/mq/varhome/ejb/SimpleMessageBean.java
index 1585501..61e1bf3 100644
--- a/appserver/tests/appserv-tests/devtests/connector/mq/varhome/ejb/SimpleMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/connector/mq/varhome/ejb/SimpleMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,14 +16,10 @@
 
 package com.sun.s1peqe.connector.mq.simplestress.ejb;
 
-import java.io.Serializable;
-import java.rmi.RemoteException;
-import javax.ejb.EJBException;
 import javax.ejb.MessageDrivenBean;
 import javax.ejb.MessageDrivenContext;
-import javax.ejb.CreateException;
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 
 public class SimpleMessageBean implements MessageDrivenBean,
     MessageListener {
diff --git a/appserver/tests/appserv-tests/devtests/connector/nonacc/client/SimpleMessageClient.java b/appserver/tests/appserv-tests/devtests/connector/nonacc/client/SimpleMessageClient.java
index bfd01f2..a6f7695 100644
--- a/appserver/tests/appserv-tests/devtests/connector/nonacc/client/SimpleMessageClient.java
+++ b/appserver/tests/appserv-tests/devtests/connector/nonacc/client/SimpleMessageClient.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,7 +16,7 @@
 
 package com.sun.s1peqe.nonacc.simple.client;
 
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.naming.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/connector/nonacc/descriptor/ejb-jar.xml b/appserver/tests/appserv-tests/devtests/connector/nonacc/descriptor/ejb-jar.xml
index 511a14f..ad6f16c 100644
--- a/appserver/tests/appserv-tests/devtests/connector/nonacc/descriptor/ejb-jar.xml
+++ b/appserver/tests/appserv-tests/devtests/connector/nonacc/descriptor/ejb-jar.xml
@@ -2,7 +2,7 @@
 <!DOCTYPE ejb-jar PUBLIC '-//Sun Microsystems, Inc.//DTD Enterprise JavaBeans 2.0//EN' 'http://java.sun.com/dtd/ejb-jar_2_0.dtd'>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -27,7 +27,7 @@
       <ejb-class>com.sun.s1peqe.nonacc.simple.ejb.SimpleMessageBean</ejb-class>
       <transaction-type>Bean</transaction-type>
       <message-driven-destination>
-        <destination-type>javax.jms.Queue</destination-type>
+        <destination-type>jakarta.jms.Queue</destination-type>
       </message-driven-destination>
     </message-driven>
   </enterprise-beans>
diff --git a/appserver/tests/appserv-tests/devtests/connector/nonacc/ejb/SimpleMessageBean.java b/appserver/tests/appserv-tests/devtests/connector/nonacc/ejb/SimpleMessageBean.java
index 632112c..d4ae25c 100644
--- a/appserver/tests/appserv-tests/devtests/connector/nonacc/ejb/SimpleMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/connector/nonacc/ejb/SimpleMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,14 +16,10 @@
 
 package com.sun.s1peqe.nonacc.simple.ejb;
 
-import java.io.Serializable;
-import java.rmi.RemoteException;
-import javax.ejb.EJBException;
 import javax.ejb.MessageDrivenBean;
 import javax.ejb.MessageDrivenContext;
-import javax.ejb.CreateException;
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 
 public class SimpleMessageBean implements MessageDrivenBean,
     MessageListener {
diff --git a/appserver/tests/appserv-tests/devtests/connector/txlevelswitch/build.xml b/appserver/tests/appserv-tests/devtests/connector/txlevelswitch/build.xml
index 737ad27..b476022 100644
--- a/appserver/tests/appserv-tests/devtests/connector/txlevelswitch/build.xml
+++ b/appserver/tests/appserv-tests/devtests/connector/txlevelswitch/build.xml
@@ -2,7 +2,7 @@
 <!DOCTYPE project [
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -229,7 +229,7 @@
       -->
       <antcall target="create-connector-connpool-common">
         <param name="ra.name" value="jmsra"/>
-	<param name="connection.defname" value="javax.jms.QueueConnectionFactory"/>
+	<param name="connection.defname" value="jakarta.jms.QueueConnectionFactory"/>
 	<param name="extra-params" value="--matchconnections=false"/>
 	<param name="connector.conpool.name" value="jms-jdbc-res-1"/>
 	<param name="operand.props" value="--transactionsupport LocalTransaction"/>
@@ -241,7 +241,7 @@
       <exec executable="${ASADMIN}" failonerror="false">
         <arg line="create-admin-object"/>
 	<arg line="--target ${appserver.instance.name}"/>
-        <arg line="--restype javax.jms.Queue"/>
+        <arg line="--restype jakarta.jms.Queue"/>
 	<arg line="--raname jmsra"/>
         <arg line="${as.props}"/>
         <arg line="--property maxNumActiveConsumers=${activeconsumer.maxnum}"/>
diff --git a/appserver/tests/appserv-tests/devtests/connector/txlevelswitch/client/Client.java b/appserver/tests/appserv-tests/devtests/connector/txlevelswitch/client/Client.java
index 70a4a54..f577f57 100644
--- a/appserver/tests/appserv-tests/devtests/connector/txlevelswitch/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/connector/txlevelswitch/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -23,7 +23,7 @@
 import com.sun.s1asdev.connector.txlevelswitch.test1.ejb.SimpleSessionHome;
 import com.sun.s1asdev.connector.txlevelswitch.test1.ejb.SimpleSession;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
-import javax.jms.*;
+import jakarta.jms.*;
 
 public class Client {
     
@@ -71,7 +71,7 @@
 		System.out.println(" After Lookup of QCF");
 	        
 		System.out.println(" Before lookup of Q");
-		javax.jms.Queue queue = (javax.jms.Queue) ic.lookup("jms/SampleQueue");
+		jakarta.jms.Queue queue = (jakarta.jms.Queue) ic.lookup("jms/SampleQueue");
 		System.out.println(" After lookup of Q");
 		System.out.println(" Before createQueueConnection");
 		QueueConnection qConn = qcf.createQueueConnection("guest", "guest");
@@ -113,7 +113,7 @@
 		System.out.println(" After Lookup of QCF");
 	        
 		System.out.println(" Before lookup of Q");
-		javax.jms.Queue queue = (javax.jms.Queue) ic.lookup("jms/SampleQueue");
+		jakarta.jms.Queue queue = (jakarta.jms.Queue) ic.lookup("jms/SampleQueue");
 		System.out.println(" After lookup of Q");
 		System.out.println(" Before createQueueConnection");
 		QueueConnection qConn = qcf.createQueueConnection("guest", "guest");
diff --git a/appserver/tests/appserv-tests/devtests/connector/txlevelswitch/descriptor/ejb-jar.xml b/appserver/tests/appserv-tests/devtests/connector/txlevelswitch/descriptor/ejb-jar.xml
index f0bbb95..f915011 100755
--- a/appserver/tests/appserv-tests/devtests/connector/txlevelswitch/descriptor/ejb-jar.xml
+++ b/appserver/tests/appserv-tests/devtests/connector/txlevelswitch/descriptor/ejb-jar.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -46,13 +46,13 @@
       </resource-ref>
       <resource-ref>
         <res-ref-name>jms/SampleQueue</res-ref-name>
-        <res-type>javax.jms.Queue</res-type>
+        <res-type>jakarta.jms.Queue</res-type>
         <res-auth>Container</res-auth>
         <res-sharing-scope>Shareable</res-sharing-scope>
       </resource-ref>
       <resource-ref>
         <res-ref-name>jms/jms-jdbc-res-1</res-ref-name>
-        <res-type>javax.jms.QueueConnectionFactory</res-type>
+        <res-type>jakarta.jms.QueueConnectionFactory</res-type>
         <res-auth>Container</res-auth>
         <res-sharing-scope>Shareable</res-sharing-scope>
       </resource-ref>
diff --git a/appserver/tests/appserv-tests/devtests/connector/txlevelswitch/ejb/SimpleSessionBean.java b/appserver/tests/appserv-tests/devtests/connector/txlevelswitch/ejb/SimpleSessionBean.java
index 25ab35a..5fa8b39 100644
--- a/appserver/tests/appserv-tests/devtests/connector/txlevelswitch/ejb/SimpleSessionBean.java
+++ b/appserver/tests/appserv-tests/devtests/connector/txlevelswitch/ejb/SimpleSessionBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -22,13 +22,13 @@
 import java.rmi.*;
 import java.util.*;
 import java.sql.*;
-import javax.jms.QueueConnectionFactory;
-import javax.jms.Queue;
-import javax.jms.QueueConnection;
-import javax.jms.QueueSession;
-import javax.jms.Session;
-import javax.jms.QueueSender;
-import javax.jms.TextMessage;
+import jakarta.jms.QueueConnectionFactory;
+import jakarta.jms.Queue;
+import jakarta.jms.QueueConnection;
+import jakarta.jms.QueueSession;
+import jakarta.jms.Session;
+import jakarta.jms.QueueSender;
+import jakarta.jms.TextMessage;
 
 
 public class SimpleSessionBean implements SessionBean
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition-embedra/descriptor/application.xml b/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition-embedra/descriptor/application.xml
index 81d425b..aebd3a1 100644
--- a/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition-embedra/descriptor/application.xml
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition-embedra/descriptor/application.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -40,7 +40,7 @@
     <administered-object>
        <description>global-scope resource defined in application DD</description>
        <name>java:global/env/EAR_AdminObject</name>
-       <interface-name>javax.jms.Destination</interface-name>
+       <interface-name>jakarta.jms.Destination</interface-name>
        <class-name>connector.MyAdminObject</class-name>
        <resource-adapter>#aod-ra</resource-adapter>
        <property>
@@ -52,7 +52,7 @@
     <administered-object>
        <description>application-scope resource defined in application DD</description>
        <name>java:app/env/EAR_AdminObject</name>
-       <interface-name>javax.jms.Destination</interface-name>
+       <interface-name>jakarta.jms.Destination</interface-name>
        <class-name>connector.MyAdminObject</class-name>
        <resource-adapter>#aod-ra</resource-adapter>
        <property>
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition-embedra/descriptor/ejb-jar.xml b/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition-embedra/descriptor/ejb-jar.xml
index 4bc3976..e574cd1 100644
--- a/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition-embedra/descriptor/ejb-jar.xml
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition-embedra/descriptor/ejb-jar.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8" standalone="no"?>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -33,7 +33,7 @@
       <administered-object>
         <description>global-scope resource to be modified by DD</description>
         <name>java:global/env/HelloStatefulEJB_ModByDD_AdminObject</name>
-        <interface-name>javax.jms.Destination</interface-name>
+        <interface-name>jakarta.jms.Destination</interface-name>
         <class-name>connector.MyAdminObject</class-name>
         <resource-adapter>#aod-ra</resource-adapter>
         <property>
@@ -45,7 +45,7 @@
       <administered-object>
         <description>global-scope resource defined in EJB DD</description>
         <name>java:global/env/HelloStatefulEJB_DD_AdminObject</name>
-        <interface-name>javax.jms.Destination</interface-name>
+        <interface-name>jakarta.jms.Destination</interface-name>
         <class-name>connector.MyAdminObject</class-name>
         <resource-adapter>#aod-ra</resource-adapter>
         <property>
@@ -57,7 +57,7 @@
       <administered-object>
         <description>module-scope resource defined in EJB DD</description>
         <name>java:module/env/HelloStatefulEJB_DD_AdminObject</name>
-        <interface-name>javax.jms.Destination</interface-name>
+        <interface-name>jakarta.jms.Destination</interface-name>
         <class-name>connector.MyAdminObject</class-name>
         <resource-adapter>#aod-ra</resource-adapter>
         <property>
@@ -69,7 +69,7 @@
       <administered-object>
         <description>application-scope resource defined in EJB DD</description>
         <name>java:app/env/HelloStatefulEJB_DD_AdminObject</name>
-        <interface-name>javax.jms.Destination</interface-name>
+        <interface-name>jakarta.jms.Destination</interface-name>
         <class-name>connector.MyAdminObject</class-name>
         <resource-adapter>#aod-ra</resource-adapter>
         <property>
@@ -81,7 +81,7 @@
       <administered-object>
         <description>component-scope resource defined in EJB DD</description>
         <name>java:comp/env/HelloStatefulEJB_DD_AdminObject</name>
-        <interface-name>javax.jms.Destination</interface-name>
+        <interface-name>jakarta.jms.Destination</interface-name>
         <class-name>connector.MyAdminObject</class-name>
         <resource-adapter>#aod-ra</resource-adapter>
         <property>
@@ -100,7 +100,7 @@
       <administered-object>
         <description>global-scope resource to be modified by DD</description>
         <name>java:global/env/HelloEJB_ModByDD_AdminObject</name>
-        <interface-name>javax.jms.Destination</interface-name>
+        <interface-name>jakarta.jms.Destination</interface-name>
         <class-name>connector.MyAdminObject</class-name>
         <resource-adapter>#aod-ra</resource-adapter>
         <property>
@@ -112,7 +112,7 @@
       <administered-object>
         <description>global-scope resource defined in EJB DD</description>
         <name>java:global/env/HelloEJB_DD_AdminObject</name>
-        <interface-name>javax.jms.Destination</interface-name>
+        <interface-name>jakarta.jms.Destination</interface-name>
         <class-name>connector.MyAdminObject</class-name>
         <resource-adapter>#aod-ra</resource-adapter>
         <property>
@@ -124,7 +124,7 @@
       <administered-object>
         <description>application-scope resource defined in EJB DD</description>
         <name>java:app/env/HelloEJB_DD_AdminObject</name>
-        <interface-name>javax.jms.Destination</interface-name>
+        <interface-name>jakarta.jms.Destination</interface-name>
         <class-name>connector.MyAdminObject</class-name>
         <resource-adapter>#aod-ra</resource-adapter>
         <property>
@@ -136,7 +136,7 @@
       <administered-object>
         <description>module-scope resource defined in EJB DD</description>
         <name>java:module/env/HelloEJB_DD_AdminObject</name>
-        <interface-name>javax.jms.Destination</interface-name>
+        <interface-name>jakarta.jms.Destination</interface-name>
         <class-name>connector.MyAdminObject</class-name>
         <resource-adapter>#aod-ra</resource-adapter>
         <property>
@@ -148,7 +148,7 @@
       <administered-object>
         <description>component-scope resource defined in EJB DD</description>
         <name>java:comp/env/HelloEJB_DD_AdminObject</name>
-        <interface-name>javax.jms.Destination</interface-name>
+        <interface-name>jakarta.jms.Destination</interface-name>
         <class-name>connector.MyAdminObject</class-name>
         <resource-adapter>#aod-ra</resource-adapter>
         <property>
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition-embedra/descriptor/web.xml b/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition-embedra/descriptor/web.xml
index a93d28b..4d4c93a 100644
--- a/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition-embedra/descriptor/web.xml
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition-embedra/descriptor/web.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2018, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -38,7 +38,7 @@
     <administered-object>
        <description>global-scope resource to be modified by DD</description>
        <name>java:global/env/Servlet_ModByDD_AdminObject</name>
-       <interface-name>javax.jms.Destination</interface-name>
+       <interface-name>jakarta.jms.Destination</interface-name>
        <class-name>connector.MyAdminObject</class-name>
        <resource-adapter>#aod-ra</resource-adapter>
        <property>
@@ -50,7 +50,7 @@
     <administered-object>
        <description>global-scope resource defined in Web DD</description>
        <name>java:global/env/Web_DD_AdminObject</name>
-       <interface-name>javax.jms.Destination</interface-name>
+       <interface-name>jakarta.jms.Destination</interface-name>
        <class-name>connector.MyAdminObject</class-name>
        <resource-adapter>#aod-ra</resource-adapter>
        <property>
@@ -62,7 +62,7 @@
     <administered-object>
        <description>application-scope resource defined in Web DD</description>
        <name>java:app/env/Web_DD_AdminObject</name>
-       <interface-name>javax.jms.Destination</interface-name>
+       <interface-name>jakarta.jms.Destination</interface-name>
        <class-name>connector.MyAdminObject</class-name>
        <resource-adapter>#aod-ra</resource-adapter>
        <property>
@@ -74,7 +74,7 @@
      <administered-object>
        <description>module-scope resource defined in Web DD</description>
        <name>java:module/env/Web_DD_AdminObject</name>
-       <interface-name>javax.jms.Destination</interface-name>
+       <interface-name>jakarta.jms.Destination</interface-name>
        <class-name>connector.MyAdminObject</class-name>
        <resource-adapter>#aod-ra</resource-adapter>
        <property>
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition-embedra/ejb/HelloEJB.java b/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition-embedra/ejb/HelloEJB.java
index 6f0295e..c699a2b 100644
--- a/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition-embedra/ejb/HelloEJB.java
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition-embedra/ejb/HelloEJB.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -27,7 +27,7 @@
           @AdministeredObjectDefinition(
                 description="global-scope resource defined by @AdministeredObjectDefinition",
                 name = "java:global/env/HelloEJB_ModByDD_AdminObject",
-                interfaceName = "javax.jms.Destination",
+                interfaceName = "jakarta.jms.Destination",
                 className = "connector.MyAdminObject",
                 resourceAdapter="#aod-ra",
                 properties = {"org.glassfish.admin-object.resType=connector.MyAdminObject"}
@@ -35,7 +35,7 @@
           @AdministeredObjectDefinition(
                description = "global-scope resource defined by @AdministeredObjectDefinition", 
                name = "java:global/env/HelloEJB_Annotation_AdminObject", 
-               interfaceName = "javax.jms.Destination",
+               interfaceName = "jakarta.jms.Destination",
                className = "connector.MyAdminObject",
                resourceAdapter="#aod-ra",
                properties = {"org.glassfish.admin-object.resType=connector.MyAdminObject"}
@@ -44,7 +44,7 @@
           @AdministeredObjectDefinition(
                description = "application-scope resource defined by @AdministeredObjectDefinition", 
                name = "java:app/env/HelloEJB_Annotation_AdminObject", 
-               interfaceName = "javax.jms.Destination",
+               interfaceName = "jakarta.jms.Destination",
                className = "connector.MyAdminObject",
                resourceAdapter="#aod-ra",
                properties = {"org.glassfish.admin-object.resType=connector.MyAdminObject"}
@@ -53,7 +53,7 @@
           @AdministeredObjectDefinition(
                description = "module-scope resource defined by @AdministeredObjectDefinition", 
                name = "java:module/env/HelloEJB_Annotation_AdminObject", 
-               interfaceName = "javax.jms.Destination",
+               interfaceName = "jakarta.jms.Destination",
                className = "connector.MyAdminObject",
                resourceAdapter="#aod-ra",
                properties = {"org.glassfish.admin-object.resType=connector.MyAdminObject"}
@@ -62,7 +62,7 @@
           @AdministeredObjectDefinition(
                description = "component-scope resource defined by @AdministeredObjectDefinition", 
                name = "java:comp/env/HelloEJB_Annotation_AdminObject", 
-               interfaceName = "javax.jms.Destination",
+               interfaceName = "jakarta.jms.Destination",
                className = "connector.MyAdminObject",
                resourceAdapter="#aod-ra",
                properties = {"org.glassfish.admin-object.resType=connector.MyAdminObject"}
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition-embedra/ejb/HelloStatefulEJB.java b/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition-embedra/ejb/HelloStatefulEJB.java
index a3fffe7..69a6c23 100644
--- a/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition-embedra/ejb/HelloStatefulEJB.java
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition-embedra/ejb/HelloStatefulEJB.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -28,7 +28,7 @@
                 @AdministeredObjectDefinition(
                         description="global-scope resource defined by @AdministeredObjectDefinition",
                         name = "java:global/env/HelloStatefulEJB_ModByDD_AdminObject",
-                        interfaceName = "javax.jms.Destination",
+                        interfaceName = "jakarta.jms.Destination",
                         className = "connector.MyAdminObject",
                         resourceAdapter="#aod-ra",
                         properties = {"org.glassfish.admin-object.resType=connector.MyAdminObject"}
@@ -37,7 +37,7 @@
                 @AdministeredObjectDefinition(
                         description="global-scope resource defined by @AdministeredObjectDefinition",
                         name = "java:global/env/HelloStatefulEJB_Annotation_AdminObject",
-                        interfaceName = "javax.jms.Destination",
+                        interfaceName = "jakarta.jms.Destination",
                         className = "connector.MyAdminObject",
                         resourceAdapter="#aod-ra",
                         properties = {"org.glassfish.admin-object.resType=connector.MyAdminObject"}
@@ -46,7 +46,7 @@
                 @AdministeredObjectDefinition(
                         description="application-scope resource defined by @AdministeredObjectDefinition",
                         name = "java:app/env/HelloStatefulEJB_Annotation_AdminObject",
-                        interfaceName = "javax.jms.Destination",
+                        interfaceName = "jakarta.jms.Destination",
                         className = "connector.MyAdminObject",
                         resourceAdapter="#aod-ra",
                         properties = {"org.glassfish.admin-object.resType=connector.MyAdminObject"}
@@ -55,7 +55,7 @@
                 @AdministeredObjectDefinition(
                         description="module-scope resource defined by @AdministeredObjectDefinition",
                         name = "java:module/env/HelloStatefulEJB_Annotation_AdminObject",
-                        interfaceName = "javax.jms.Destination",
+                        interfaceName = "jakarta.jms.Destination",
                         className = "connector.MyAdminObject",
                         resourceAdapter="#aod-ra",
                         properties = {"org.glassfish.admin-object.resType=connector.MyAdminObject"}
@@ -64,7 +64,7 @@
                 @AdministeredObjectDefinition(
                         description="component-scope resource defined by @AdministeredObjectDefinition",
                         name = "java:comp/env/HelloStatefulEJB_Annotation_AdminObject",
-                        interfaceName = "javax.jms.Destination",
+                        interfaceName = "jakarta.jms.Destination",
                         className = "connector.MyAdminObject",
                         resourceAdapter="#aod-ra",
                         properties = {"org.glassfish.admin-object.resType=connector.MyAdminObject"}
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition-embedra/ra/src/connector/MyAdminObject.java b/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition-embedra/ra/src/connector/MyAdminObject.java
index 9597c32..458b9a1 100644
--- a/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition-embedra/ra/src/connector/MyAdminObject.java
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition-embedra/ra/src/connector/MyAdminObject.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,9 +16,9 @@
 
 package connector;
 
-import javax.jms.Destination;
-import javax.jms.JMSException;
-import javax.jms.Queue;
+import jakarta.jms.Destination;
+import jakarta.jms.JMSException;
+import jakarta.jms.Queue;
 import javax.resource.spi.AdministeredObject;
 import javax.resource.spi.ConfigProperty;
 
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition-embedra/servlet/Servlet.java b/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition-embedra/servlet/Servlet.java
index 089ba5d..49962a7 100644
--- a/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition-embedra/servlet/Servlet.java
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition-embedra/servlet/Servlet.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2002, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2002, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -42,7 +42,7 @@
                         description="global-scope resource defined by @AdministeredObjectDefinition",
                         name = "java:global/env/Servlet_ModByDD_AdminObject",
                         resourceAdapter="#aod-ra",
-                        interfaceName = "javax.jms.Destination",
+                        interfaceName = "jakarta.jms.Destination",
                         className = "connector.MyAdminObject",
                         properties = {"org.glassfish.admin-object.resType=connector.MyAdminObject"}
                 ),
@@ -50,7 +50,7 @@
                 @AdministeredObjectDefinition(
                         description="global-scope resource defined by @AdministeredObjectDefinition",
                         name = "java:global/env/Servlet_AdminObject",
-                        interfaceName = "javax.jms.Destination",
+                        interfaceName = "jakarta.jms.Destination",
                         className = "connector.MyAdminObject",
                         resourceAdapter="#aod-ra",
                         properties = {"org.glassfish.admin-object.resType=connector.MyAdminObject"}
@@ -59,7 +59,7 @@
                 @AdministeredObjectDefinition(
                         description="application-scope resource defined by @AdministeredObjectDefinition",
                         name = "java:app/env/Servlet_AdminObject",
-                        interfaceName = "javax.jms.Destination",
+                        interfaceName = "jakarta.jms.Destination",
                         className = "connector.MyAdminObject",
                         resourceAdapter="#aod-ra",
                         properties = {"org.glassfish.admin-object.resType=connector.MyAdminObject"}
@@ -68,7 +68,7 @@
                 @AdministeredObjectDefinition(
                         description="module-scope resource defined by @AdministeredObjectDefinition",
                         name = "java:module/env/Servlet_AdminObject",
-                        interfaceName = "javax.jms.Destination",
+                        interfaceName = "jakarta.jms.Destination",
                         className = "connector.MyAdminObject",
                         resourceAdapter="#aod-ra",
                         properties = {"org.glassfish.admin-object.resType=connector.MyAdminObject"}
@@ -77,7 +77,7 @@
                 @AdministeredObjectDefinition(
                         description="component-scope resource defined by @AdministeredObjectDefinition",
                         name = "java:comp/env/Servlet_AdminObject",
-                        interfaceName = "javax.jms.Destination",
+                        interfaceName = "jakarta.jms.Destination",
                         className = "connector.MyAdminObject",
                         resourceAdapter="#aod-ra",
                         properties = {"org.glassfish.admin-object.resType=connector.MyAdminObject"}
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/descriptor/application.xml b/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/descriptor/application.xml
index a90f01a..057df28 100644
--- a/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/descriptor/application.xml
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/descriptor/application.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -36,7 +36,7 @@
     <administered-object>
        <description>global-scope resource defined in application DD</description>
        <name>java:global/env/EAR_AdminObject</name>
-       <interface-name>javax.jms.Destination</interface-name>
+       <interface-name>jakarta.jms.Destination</interface-name>
        <class-name>connector.MyAdminObject</class-name>
        <resource-adapter>aod-ra</resource-adapter>
        <property>
@@ -48,7 +48,7 @@
     <administered-object>
        <description>application-scope resource defined in application DD</description>
        <name>java:app/env/EAR_AdminObject</name>
-       <interface-name>javax.jms.Destination</interface-name>
+       <interface-name>jakarta.jms.Destination</interface-name>
        <class-name>connector.MyAdminObject</class-name>
        <resource-adapter>aod-ra</resource-adapter>
        <property>
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/descriptor/ejb-jar.xml b/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/descriptor/ejb-jar.xml
index 07a6572..8b2b5cf 100644
--- a/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/descriptor/ejb-jar.xml
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/descriptor/ejb-jar.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8" standalone="no"?>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -33,7 +33,7 @@
       <administered-object>
         <description>global-scope resource to be modified by DD</description>
         <name>java:global/env/HelloStatefulEJB_ModByDD_AdminObject</name>
-        <interface-name>javax.jms.Destination</interface-name>
+        <interface-name>jakarta.jms.Destination</interface-name>
         <class-name>connector.MyAdminObject</class-name>
         <resource-adapter>aod-ra</resource-adapter>
         <property>
@@ -45,7 +45,7 @@
       <administered-object>
         <description>global-scope resource defined in EJB DD</description>
         <name>java:global/env/HelloStatefulEJB_DD_AdminObject</name>
-        <interface-name>javax.jms.Destination</interface-name>
+        <interface-name>jakarta.jms.Destination</interface-name>
         <class-name>connector.MyAdminObject</class-name>
         <resource-adapter>aod-ra</resource-adapter>
         <property>
@@ -57,7 +57,7 @@
       <administered-object>
         <description>module-scope resource defined in EJB DD</description>
         <name>java:module/env/HelloStatefulEJB_DD_AdminObject</name>
-        <interface-name>javax.jms.Destination</interface-name>
+        <interface-name>jakarta.jms.Destination</interface-name>
         <class-name>connector.MyAdminObject</class-name>
         <resource-adapter>aod-ra</resource-adapter>
         <property>
@@ -69,7 +69,7 @@
       <administered-object>
         <description>application-scope resource defined in EJB DD</description>
         <name>java:app/env/HelloStatefulEJB_DD_AdminObject</name>
-        <interface-name>javax.jms.Destination</interface-name>
+        <interface-name>jakarta.jms.Destination</interface-name>
         <class-name>connector.MyAdminObject</class-name>
         <resource-adapter>aod-ra</resource-adapter>
         <property>
@@ -81,7 +81,7 @@
       <administered-object>
         <description>component-scope resource defined in EJB DD</description>
         <name>java:comp/env/HelloStatefulEJB_DD_AdminObject</name>
-        <interface-name>javax.jms.Destination</interface-name>
+        <interface-name>jakarta.jms.Destination</interface-name>
         <class-name>connector.MyAdminObject</class-name>
         <resource-adapter>aod-ra</resource-adapter>
         <property>
@@ -100,7 +100,7 @@
       <administered-object>
         <description>global-scope resource to be modified by DD</description>
         <name>java:global/env/HelloEJB_ModByDD_AdminObject</name>
-        <interface-name>javax.jms.Destination</interface-name>
+        <interface-name>jakarta.jms.Destination</interface-name>
         <class-name>connector.MyAdminObject</class-name>
         <resource-adapter>aod-ra</resource-adapter>
         <property>
@@ -112,7 +112,7 @@
       <administered-object>
         <description>global-scope resource defined in EJB DD</description>
         <name>java:global/env/HelloEJB_DD_AdminObject</name>
-        <interface-name>javax.jms.Destination</interface-name>
+        <interface-name>jakarta.jms.Destination</interface-name>
         <class-name>connector.MyAdminObject</class-name>
         <resource-adapter>aod-ra</resource-adapter>
         <property>
@@ -124,7 +124,7 @@
       <administered-object>
         <description>application-scope resource defined in EJB DD</description>
         <name>java:app/env/HelloEJB_DD_AdminObject</name>
-        <interface-name>javax.jms.Destination</interface-name>
+        <interface-name>jakarta.jms.Destination</interface-name>
         <class-name>connector.MyAdminObject</class-name>
         <resource-adapter>aod-ra</resource-adapter>
         <property>
@@ -136,7 +136,7 @@
       <administered-object>
         <description>module-scope resource defined in EJB DD</description>
         <name>java:module/env/HelloEJB_DD_AdminObject</name>
-        <interface-name>javax.jms.Destination</interface-name>
+        <interface-name>jakarta.jms.Destination</interface-name>
         <class-name>connector.MyAdminObject</class-name>
         <resource-adapter>aod-ra</resource-adapter>
         <property>
@@ -148,7 +148,7 @@
       <administered-object>
         <description>component-scope resource defined in EJB DD</description>
         <name>java:comp/env/HelloEJB_DD_AdminObject</name>
-        <interface-name>javax.jms.Destination</interface-name>
+        <interface-name>jakarta.jms.Destination</interface-name>
         <class-name>connector.MyAdminObject</class-name>
         <resource-adapter>aod-ra</resource-adapter>
         <property>
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/descriptor/ut-application.xml b/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/descriptor/ut-application.xml
index c8067cd..dd3fbec 100644
--- a/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/descriptor/ut-application.xml
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/descriptor/ut-application.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -28,7 +28,7 @@
     <administered-object>
        <description>global-scope resource defined in application DD</description>
        <name>java:global/env/AdminObject</name>
-       <interface-name>javax.jms.Destination</interface-name>
+       <interface-name>jakarta.jms.Destination</interface-name>
        <class-name>connector.MyAdminObject</class-name>
        <resource-adapter>aod-ra</resource-adapter>
        <property>
@@ -40,7 +40,7 @@
     <administered-object>
        <description>application-scope resource defined in application DD</description>
        <name>java:app/env/AdminObject</name>
-       <interface-name>javax.jms.Destination</interface-name>
+       <interface-name>jakarta.jms.Destination</interface-name>
        <class-name>connector.MyAdminObject</class-name>
        <resource-adapter>aod-ra</resource-adapter>
        <property>
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/descriptor/ut-entity-ejb-jar.xml b/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/descriptor/ut-entity-ejb-jar.xml
index d778e5c..66aa7ba 100644
--- a/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/descriptor/ut-entity-ejb-jar.xml
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/descriptor/ut-entity-ejb-jar.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8" standalone="no"?>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -33,7 +33,7 @@
       <administered-object>
         <description>global-scope resource defined in EJB DD</description>
         <name>java:global/env/Entity_AdminObject</name>
-        <interface-name>javax.jms.Destination</interface-name>
+        <interface-name>jakarta.jms.Destination</interface-name>
         <class-name>connector.MyAdminObject</class-name>
         <resource-adapter>aod-ra</resource-adapter>
         <property>
@@ -45,7 +45,7 @@
       <administered-object>
         <description>module-scope resource defined in EJB DD</description>
         <name>java:module/env/Entity_AdminObject</name>
-        <interface-name>javax.jms.Destination</interface-name>
+        <interface-name>jakarta.jms.Destination</interface-name>
         <class-name>connector.MyAdminObject</class-name>
         <resource-adapter>aod-ra</resource-adapter>
         <property>
@@ -57,7 +57,7 @@
       <administered-object>
         <description>component-scope resource defined in EJB DD</description>
         <name>java:comp/env/Entity_AdminObject</name>
-        <interface-name>javax.jms.Destination</interface-name>
+        <interface-name>jakarta.jms.Destination</interface-name>
         <class-name>connector.MyAdminObject</class-name>
         <resource-adapter>aod-ra</resource-adapter>
         <property>
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/descriptor/ut-interceptor-ejb-jar.xml b/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/descriptor/ut-interceptor-ejb-jar.xml
index ac8f2a3..248b861 100644
--- a/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/descriptor/ut-interceptor-ejb-jar.xml
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/descriptor/ut-interceptor-ejb-jar.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8" standalone="no"?>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -29,7 +29,7 @@
       <administered-object>
         <description>global-scope resource defined in EJB DD</description>
         <name>java:global/env/Interceptor_AdminObject</name>
-        <interface-name>javax.jms.Destination</interface-name>
+        <interface-name>jakarta.jms.Destination</interface-name>
         <class-name>connector.MyAdminObject</class-name>
         <resource-adapter>aod-ra</resource-adapter>
         <property>
@@ -41,7 +41,7 @@
       <administered-object>
         <description>module-scope resource defined in EJB DD</description>
         <name>java:module/env/Interceptor_AdminObject</name>
-        <interface-name>javax.jms.Destination</interface-name>
+        <interface-name>jakarta.jms.Destination</interface-name>
         <class-name>connector.MyAdminObject</class-name>
         <resource-adapter>aod-ra</resource-adapter>
         <property>
@@ -53,7 +53,7 @@
       <administered-object>
         <description>component-scope resource defined in EJB DD</description>
         <name>java:comp/env/Interceptor_AdminObject</name>
-        <interface-name>javax.jms.Destination</interface-name>
+        <interface-name>jakarta.jms.Destination</interface-name>
         <class-name>connector.MyAdminObject</class-name>
         <resource-adapter>aod-ra</resource-adapter>
         <property>
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/descriptor/ut-mdb-ejb-jar.xml b/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/descriptor/ut-mdb-ejb-jar.xml
index efff5f8..efd89f4 100644
--- a/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/descriptor/ut-mdb-ejb-jar.xml
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/descriptor/ut-mdb-ejb-jar.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8" standalone="no"?>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -32,7 +32,7 @@
       <administered-object>
         <description>global-scope resource defined in EJB DD</description>
         <name>java:global/env/MDB_AdminObject</name>
-        <interface-name>javax.jms.Destination</interface-name>
+        <interface-name>jakarta.jms.Destination</interface-name>
         <class-name>connector.MyAdminObject</class-name>
         <resource-adapter>aod-ra</resource-adapter>
         <property>
@@ -44,7 +44,7 @@
       <administered-object>
         <description>module-scope resource defined in EJB DD</description>
         <name>java:module/env/MDB_AdminObject</name>
-        <interface-name>javax.jms.Destination</interface-name>
+        <interface-name>jakarta.jms.Destination</interface-name>
         <class-name>connector.MyAdminObject</class-name>
         <resource-adapter>aod-ra</resource-adapter>
         <property>
@@ -56,7 +56,7 @@
       <administered-object>
         <description>component-scope resource defined in EJB DD</description>
         <name>java:comp/env/MDB_AdminObject</name>
-        <interface-name>javax.jms.Destination</interface-name>
+        <interface-name>jakarta.jms.Destination</interface-name>
         <class-name>connector.MyAdminObject</class-name>
         <resource-adapter>aod-ra</resource-adapter>
         <property>
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/descriptor/ut-session-ejb-jar.xml b/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/descriptor/ut-session-ejb-jar.xml
index 3cad475..c722295 100644
--- a/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/descriptor/ut-session-ejb-jar.xml
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/descriptor/ut-session-ejb-jar.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8" standalone="no"?>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -32,7 +32,7 @@
       <administered-object>
         <description>global-scope resource defined in EJB DD</description>
         <name>java:global/env/StatefulEJB_AdminObject</name>
-        <interface-name>javax.jms.Destination</interface-name>
+        <interface-name>jakarta.jms.Destination</interface-name>
         <class-name>connector.MyAdminObject</class-name>
         <resource-adapter>aod-ra</resource-adapter>
         <property>
@@ -44,7 +44,7 @@
       <administered-object>
         <description>module-scope resource defined in EJB DD</description>
         <name>java:module/env/StatefulEJB_AdminObject</name>
-        <interface-name>javax.jms.Destination</interface-name>
+        <interface-name>jakarta.jms.Destination</interface-name>
         <class-name>connector.MyAdminObject</class-name>
         <resource-adapter>aod-ra</resource-adapter>
         <property>
@@ -56,7 +56,7 @@
       <administered-object>
         <description>component-scope resource defined in EJB DD</description>
         <name>java:comp/env/StatefulEJB_AdminObject</name>
-        <interface-name>javax.jms.Destination</interface-name>
+        <interface-name>jakarta.jms.Destination</interface-name>
         <class-name>connector.MyAdminObject</class-name>
         <resource-adapter>aod-ra</resource-adapter>
         <property>
@@ -75,7 +75,7 @@
       <administered-object>
         <description>global-scope resource defined in EJB DD</description>
         <name>java:global/env/HelloEJB_AdminObject</name>
-        <interface-name>javax.jms.Destination</interface-name>
+        <interface-name>jakarta.jms.Destination</interface-name>
         <class-name>connector.MyAdminObject</class-name>
         <resource-adapter>aod-ra</resource-adapter>
         <property>
@@ -87,7 +87,7 @@
       <administered-object>
         <description>module-scope resource defined in EJB DD</description>
         <name>java:module/env/HelloEJB_AdminObject</name>
-        <interface-name>javax.jms.Destination</interface-name>
+        <interface-name>jakarta.jms.Destination</interface-name>
         <class-name>connector.MyAdminObject</class-name>
         <resource-adapter>aod-ra</resource-adapter>
         <property>
@@ -99,7 +99,7 @@
       <administered-object>
         <description>component-scope resource defined in EJB DD</description>
         <name>java:comp/env/HelloEJB_AdminObject</name>
-        <interface-name>javax.jms.Destination</interface-name>
+        <interface-name>jakarta.jms.Destination</interface-name>
         <class-name>connector.MyAdminObject</class-name>
         <resource-adapter>aod-ra</resource-adapter>
         <property>
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/descriptor/ut-web.xml b/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/descriptor/ut-web.xml
index ed95226..7fe317e 100644
--- a/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/descriptor/ut-web.xml
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/descriptor/ut-web.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -48,7 +48,7 @@
     <administered-object>
        <description>application-scope resource defined in Web DD</description>
        <name>java:app/env/AdminObject</name>
-       <interface-name>javax.jms.Destination</interface-name>
+       <interface-name>jakarta.jms.Destination</interface-name>
        <class-name>connector.MyAdminObject</class-name>
        <resource-adapter>aod-ra</resource-adapter>
        <property>
@@ -60,7 +60,7 @@
      <administered-object>
        <description>module-scope resource defined in Web DD</description>
        <name>java:module/env/AdminObject</name>
-       <interface-name>javax.jms.Destination</interface-name>
+       <interface-name>jakarta.jms.Destination</interface-name>
        <class-name>connector.MyAdminObject</class-name>
        <resource-adapter>aod-ra</resource-adapter>
        <property>
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/descriptor/web.xml b/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/descriptor/web.xml
index f4399b1..9476e34 100644
--- a/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/descriptor/web.xml
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/descriptor/web.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2018, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -38,7 +38,7 @@
     <administered-object>
        <description>global-scope resource to be modified by DD</description>
        <name>java:global/env/Servlet_ModByDD_AdminObject</name>
-       <interface-name>javax.jms.Destination</interface-name>
+       <interface-name>jakarta.jms.Destination</interface-name>
        <class-name>connector.MyAdminObject</class-name>
        <resource-adapter>aod-ra</resource-adapter>
        <property>
@@ -50,7 +50,7 @@
     <administered-object>
        <description>global-scope resource defined in Web DD</description>
        <name>java:global/env/Web_DD_AdminObject</name>
-       <interface-name>javax.jms.Destination</interface-name>
+       <interface-name>jakarta.jms.Destination</interface-name>
        <class-name>connector.MyAdminObject</class-name>
        <resource-adapter>aod-ra</resource-adapter>
        <property>
@@ -62,7 +62,7 @@
     <administered-object>
        <description>application-scope resource defined in Web DD</description>
        <name>java:app/env/Web_DD_AdminObject</name>
-       <interface-name>javax.jms.Destination</interface-name>
+       <interface-name>jakarta.jms.Destination</interface-name>
        <class-name>connector.MyAdminObject</class-name>
        <resource-adapter>aod-ra</resource-adapter>
        <property>
@@ -74,7 +74,7 @@
      <administered-object>
        <description>module-scope resource defined in Web DD</description>
        <name>java:module/env/Web_DD_AdminObject</name>
-       <interface-name>javax.jms.Destination</interface-name>
+       <interface-name>jakarta.jms.Destination</interface-name>
        <class-name>connector.MyAdminObject</class-name>
        <resource-adapter>aod-ra</resource-adapter>
        <property>
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/ejb/HelloEJB.java b/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/ejb/HelloEJB.java
index a65c19e..6e72a41 100644
--- a/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/ejb/HelloEJB.java
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/ejb/HelloEJB.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -27,7 +27,7 @@
           @AdministeredObjectDefinition(
                 description="global-scope resource defined by @AdministeredObjectDefinition",
                 name = "java:global/env/HelloEJB_ModByDD_AdminObject",
-                interfaceName = "javax.jms.Destination",
+                interfaceName = "jakarta.jms.Destination",
                 className = "connector.MyAdminObject",
                 resourceAdapter="aod-ra",
                 properties = {"org.glassfish.admin-object.resType=connector.MyAdminObject"}
@@ -35,7 +35,7 @@
           @AdministeredObjectDefinition(
                description = "global-scope resource defined by @AdministeredObjectDefinition", 
                name = "java:global/env/HelloEJB_Annotation_AdminObject", 
-               interfaceName = "javax.jms.Destination",
+               interfaceName = "jakarta.jms.Destination",
                className = "connector.MyAdminObject",
                resourceAdapter="aod-ra",
                properties = {"org.glassfish.admin-object.resType=connector.MyAdminObject"}
@@ -44,7 +44,7 @@
           @AdministeredObjectDefinition(
                description = "application-scope resource defined by @AdministeredObjectDefinition", 
                name = "java:app/env/HelloEJB_Annotation_AdminObject", 
-               interfaceName = "javax.jms.Destination",
+               interfaceName = "jakarta.jms.Destination",
                className = "connector.MyAdminObject",
                resourceAdapter="aod-ra",
                properties = {"org.glassfish.admin-object.resType=connector.MyAdminObject"}
@@ -53,7 +53,7 @@
           @AdministeredObjectDefinition(
                description = "module-scope resource defined by @AdministeredObjectDefinition", 
                name = "java:module/env/HelloEJB_Annotation_AdminObject", 
-               interfaceName = "javax.jms.Destination",
+               interfaceName = "jakarta.jms.Destination",
                className = "connector.MyAdminObject",
                resourceAdapter="aod-ra",
                properties = {"org.glassfish.admin-object.resType=connector.MyAdminObject"}
@@ -62,7 +62,7 @@
           @AdministeredObjectDefinition(
                description = "component-scope resource defined by @AdministeredObjectDefinition", 
                name = "java:comp/env/HelloEJB_Annotation_AdminObject", 
-               interfaceName = "javax.jms.Destination",
+               interfaceName = "jakarta.jms.Destination",
                className = "connector.MyAdminObject",
                resourceAdapter="aod-ra",
                properties = {"org.glassfish.admin-object.resType=connector.MyAdminObject"}
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/ejb/HelloStatefulEJB.java b/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/ejb/HelloStatefulEJB.java
index fc5f765..2dd0656 100644
--- a/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/ejb/HelloStatefulEJB.java
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/ejb/HelloStatefulEJB.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -28,7 +28,7 @@
                 @AdministeredObjectDefinition(
                         description="global-scope resource defined by @AdministeredObjectDefinition",
                         name = "java:global/env/HelloStatefulEJB_ModByDD_AdminObject",
-                        interfaceName = "javax.jms.Destination",
+                        interfaceName = "jakarta.jms.Destination",
                         className = "connector.MyAdminObject",
                         resourceAdapter="aod-ra",
                         properties = {"org.glassfish.admin-object.resType=connector.MyAdminObject"}
@@ -37,7 +37,7 @@
                 @AdministeredObjectDefinition(
                         description="global-scope resource defined by @AdministeredObjectDefinition",
                         name = "java:global/env/HelloStatefulEJB_Annotation_AdminObject",
-                        interfaceName = "javax.jms.Destination",
+                        interfaceName = "jakarta.jms.Destination",
                         className = "connector.MyAdminObject",
                         resourceAdapter="aod-ra",
                         properties = {"org.glassfish.admin-object.resType=connector.MyAdminObject"}
@@ -46,7 +46,7 @@
                 @AdministeredObjectDefinition(
                         description="application-scope resource defined by @AdministeredObjectDefinition",
                         name = "java:app/env/HelloStatefulEJB_Annotation_AdminObject",
-                        interfaceName = "javax.jms.Destination",
+                        interfaceName = "jakarta.jms.Destination",
                         className = "connector.MyAdminObject",
                         resourceAdapter="aod-ra",
                         properties = {"org.glassfish.admin-object.resType=connector.MyAdminObject"}
@@ -55,7 +55,7 @@
                 @AdministeredObjectDefinition(
                         description="module-scope resource defined by @AdministeredObjectDefinition",
                         name = "java:module/env/HelloStatefulEJB_Annotation_AdminObject",
-                        interfaceName = "javax.jms.Destination",
+                        interfaceName = "jakarta.jms.Destination",
                         className = "connector.MyAdminObject",
                         resourceAdapter="aod-ra",
                         properties = {"org.glassfish.admin-object.resType=connector.MyAdminObject"}
@@ -64,7 +64,7 @@
                 @AdministeredObjectDefinition(
                         description="component-scope resource defined by @AdministeredObjectDefinition",
                         name = "java:comp/env/HelloStatefulEJB_Annotation_AdminObject",
-                        interfaceName = "javax.jms.Destination",
+                        interfaceName = "jakarta.jms.Destination",
                         className = "connector.MyAdminObject",
                         resourceAdapter="aod-ra",
                         properties = {"org.glassfish.admin-object.resType=connector.MyAdminObject"}
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/ra/build.xml b/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/ra/build.xml
index f2c8835..c682686 100755
--- a/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/ra/build.xml
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/ra/build.xml
@@ -1,6 +1,6 @@
 <!--
 
-    Copyright (c) 2002, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2002, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -53,7 +53,7 @@
 
   <target name="testAddAdmin" depends="init-common">
     <antcall target="asadmin-common">
-      <param name="admin.command" value="create-admin-object --target ${appserver.instance.name} --restype javax.jms.Destination --raname aod-ra --property ResetControl=BEGINNING"/>
+      <param name="admin.command" value="create-admin-object --target ${appserver.instance.name} --restype jakarta.jms.Destination --raname aod-ra --property ResetControl=BEGINNING"/>
       <param name="operand.props" value="eis/testAdmin"/>
     </antcall>
     <!--<antcall target="reconfig-common"/>-->
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/ra/src/connector/MyAdminObject.java b/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/ra/src/connector/MyAdminObject.java
index 9597c32..458b9a1 100755
--- a/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/ra/src/connector/MyAdminObject.java
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/ra/src/connector/MyAdminObject.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,9 +16,9 @@
 
 package connector;
 
-import javax.jms.Destination;
-import javax.jms.JMSException;
-import javax.jms.Queue;
+import jakarta.jms.Destination;
+import jakarta.jms.JMSException;
+import jakarta.jms.Queue;
 import javax.resource.spi.AdministeredObject;
 import javax.resource.spi.ConfigProperty;
 
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/servlet/Servlet.java b/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/servlet/Servlet.java
index f3daeaf..1b55f48 100644
--- a/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/servlet/Servlet.java
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/servlet/Servlet.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2002, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2002, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -42,7 +42,7 @@
                         description="global-scope resource defined by @AdministeredObjectDefinition",
                         name = "java:global/env/Servlet_ModByDD_AdminObject",
                         resourceAdapter="aod-ra",
-                        interfaceName = "javax.jms.Destination",
+                        interfaceName = "jakarta.jms.Destination",
                         className = "connector.MyAdminObject",
                         properties = {"org.glassfish.admin-object.resType=connector.MyAdminObject"}
                 ),
@@ -50,7 +50,7 @@
                 @AdministeredObjectDefinition(
                         description="global-scope resource defined by @AdministeredObjectDefinition",
                         name = "java:global/env/Servlet_AdminObject",
-                        interfaceName = "javax.jms.Destination",
+                        interfaceName = "jakarta.jms.Destination",
                         className = "connector.MyAdminObject",
                         resourceAdapter="aod-ra",
                         properties = {"org.glassfish.admin-object.resType=connector.MyAdminObject"}
@@ -59,7 +59,7 @@
                 @AdministeredObjectDefinition(
                         description="application-scope resource defined by @AdministeredObjectDefinition",
                         name = "java:app/env/Servlet_AdminObject",
-                        interfaceName = "javax.jms.Destination",
+                        interfaceName = "jakarta.jms.Destination",
                         className = "connector.MyAdminObject",
                         resourceAdapter="aod-ra",
                         properties = {"org.glassfish.admin-object.resType=connector.MyAdminObject"}
@@ -68,7 +68,7 @@
                 @AdministeredObjectDefinition(
                         description="module-scope resource defined by @AdministeredObjectDefinition",
                         name = "java:module/env/Servlet_AdminObject",
-                        interfaceName = "javax.jms.Destination",
+                        interfaceName = "jakarta.jms.Destination",
                         className = "connector.MyAdminObject",
                         resourceAdapter="aod-ra",
                         properties = {"org.glassfish.admin-object.resType=connector.MyAdminObject"}
@@ -77,7 +77,7 @@
                 @AdministeredObjectDefinition(
                         description="component-scope resource defined by @AdministeredObjectDefinition",
                         name = "java:comp/env/Servlet_AdminObject",
-                        interfaceName = "javax.jms.Destination",
+                        interfaceName = "jakarta.jms.Destination",
                         className = "connector.MyAdminObject",
                         resourceAdapter="aod-ra",
                         properties = {"org.glassfish.admin-object.resType=connector.MyAdminObject"}
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/ut/ArchiveTest.java b/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/ut/ArchiveTest.java
index a8d55ae..7105b2f 100644
--- a/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/ut/ArchiveTest.java
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/ut/ArchiveTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2002, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2002, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -86,7 +86,7 @@
         desc = new AdministeredObjectDefinitionDescriptor();
         desc.setDescription("global-scope resource defined in application DD");
         desc.setName("java:global/env/AdminObject");
-        desc.setInterfaceName("javax.jms.Destination");
+        desc.setInterfaceName("jakarta.jms.Destination");
         desc.setClassName("connector.MyAdminObject");
         desc.setResourceAdapter("aod-ra");
         desc.addProperty("org.glassfish.admin-object.resType", "connector.MyAdminObject");
@@ -95,7 +95,7 @@
         desc = new AdministeredObjectDefinitionDescriptor();
         desc.setDescription("application-scope resource defined in application DD");
         desc.setName("java:app/env/AdminObject");
-        desc.setInterfaceName("javax.jms.Destination");
+        desc.setInterfaceName("jakarta.jms.Destination");
         desc.setClassName("connector.MyAdminObject");
         desc.setResourceAdapter("aod-ra");
         desc.addProperty("org.glassfish.admin-object.resType", "connector.MyAdminObject");
@@ -145,7 +145,7 @@
         desc = new AdministeredObjectDefinitionDescriptor();
         desc.setDescription("global-scope resource to be modified by DD");
         desc.setName("java:global/env/Servlet_ModByDD_AdminObject");
-        desc.setInterfaceName("javax.jms.Destination");
+        desc.setInterfaceName("jakarta.jms.Destination");
         desc.setClassName("connector.MyAdminObject");
         desc.setResourceAdapter("aod-ra");
         desc.addProperty("org.glassfish.admin-object.resType", "connector.MyAdminObject");
@@ -154,7 +154,7 @@
         desc = new AdministeredObjectDefinitionDescriptor();
         desc.setDescription("global-scope resource defined by @AdministeredObjectDefinition");
         desc.setName("java:global/env/Servlet_AdminObject");
-        desc.setInterfaceName("javax.jms.Destination");
+        desc.setInterfaceName("jakarta.jms.Destination");
         desc.setClassName("connector.MyAdminObject");
         desc.setResourceAdapter("aod-ra");
         desc.addProperty("org.glassfish.admin-object.resType", "connector.MyAdminObject");
@@ -163,7 +163,7 @@
         desc = new AdministeredObjectDefinitionDescriptor();
         desc.setDescription("application-scope resource defined by @AdministeredObjectDefinition");
         desc.setName("java:app/env/Servlet_AdminObject");
-        desc.setInterfaceName("javax.jms.Destination");
+        desc.setInterfaceName("jakarta.jms.Destination");
         desc.setClassName("connector.MyAdminObject");
         desc.setResourceAdapter("aod-ra");
         desc.addProperty("org.glassfish.admin-object.resType", "connector.MyAdminObject");
@@ -172,7 +172,7 @@
         desc = new AdministeredObjectDefinitionDescriptor();
         desc.setDescription("module-scope resource defined by @AdministeredObjectDefinition");
         desc.setName("java:module/env/Servlet_AdminObject");
-        desc.setInterfaceName("javax.jms.Destination");
+        desc.setInterfaceName("jakarta.jms.Destination");
         desc.setClassName("connector.MyAdminObject");
         desc.setResourceAdapter("aod-ra");
         desc.addProperty("org.glassfish.admin-object.resType", "connector.MyAdminObject");
@@ -181,7 +181,7 @@
         desc = new AdministeredObjectDefinitionDescriptor();
         desc.setDescription("component-scope resource defined by @AdministeredObjectDefinition");
         desc.setName("java:comp/env/Servlet_AdminObject");
-        desc.setInterfaceName("javax.jms.Destination");
+        desc.setInterfaceName("jakarta.jms.Destination");
         desc.setClassName("connector.MyAdminObject");
         desc.setResourceAdapter("aod-ra");
         desc.addProperty("org.glassfish.admin-object.resType", "connector.MyAdminObject");
@@ -190,7 +190,7 @@
         desc = new AdministeredObjectDefinitionDescriptor();
         desc.setDescription("global-scope resource defined in Web DD");
         desc.setName("java:global/env/Web_DD_AdminObject");
-        desc.setInterfaceName("javax.jms.Destination");
+        desc.setInterfaceName("jakarta.jms.Destination");
         desc.setClassName("connector.MyAdminObject");
         desc.setResourceAdapter("aod-ra");
         desc.addProperty("org.glassfish.admin-object.resType", "connector.MyAdminObject");
@@ -199,7 +199,7 @@
         desc = new AdministeredObjectDefinitionDescriptor();
         desc.setDescription("application-scope resource defined in Web DD");
         desc.setName("java:app/env/Web_DD_AdminObject");
-        desc.setInterfaceName("javax.jms.Destination");
+        desc.setInterfaceName("jakarta.jms.Destination");
         desc.setClassName("connector.MyAdminObject");
         desc.setResourceAdapter("aod-ra");
         desc.addProperty("org.glassfish.admin-object.resType", "connector.MyAdminObject");
@@ -208,7 +208,7 @@
         desc = new AdministeredObjectDefinitionDescriptor();
         desc.setDescription("module-scope resource defined in Web DD");
         desc.setName("java:module/env/Web_DD_AdminObject");
-        desc.setInterfaceName("javax.jms.Destination");
+        desc.setInterfaceName("jakarta.jms.Destination");
         desc.setClassName("connector.MyAdminObject");
         desc.setResourceAdapter("aod-ra");
         desc.addProperty("org.glassfish.admin-object.resType", "connector.MyAdminObject");
@@ -259,7 +259,7 @@
         desc = new AdministeredObjectDefinitionDescriptor();
         desc.setDescription("global-scope resource to be modified by DD");
         desc.setName("java:global/env/HelloStatefulEJB_ModByDD_AdminObject");
-        desc.setInterfaceName("javax.jms.Destination");
+        desc.setInterfaceName("jakarta.jms.Destination");
         desc.setClassName("connector.MyAdminObject");
         desc.setResourceAdapter("aod-ra");
         desc.addProperty("org.glassfish.admin-object.resType", "connector.MyAdminObject");
@@ -267,7 +267,7 @@
 
         desc.setDescription("global-scope resource to be modified by DD");
         desc.setName("java:global/env/HelloEJB_ModByDD_AdminObject");
-        desc.setInterfaceName("javax.jms.Destination");
+        desc.setInterfaceName("jakarta.jms.Destination");
         desc.setClassName("connector.MyAdminObject");
         desc.setResourceAdapter("aod-ra");
         desc.addProperty("org.glassfish.admin-object.resType", "connector.MyAdminObject");
@@ -278,7 +278,7 @@
             desc = new AdministeredObjectDefinitionDescriptor();
             desc.setDescription("global-scope resource defined in EJB DD");
             desc.setName("java:global/env/HelloStatefulEJB_DD_AdminObject");
-            desc.setInterfaceName("javax.jms.Destination");
+            desc.setInterfaceName("jakarta.jms.Destination");
             desc.setClassName("connector.MyAdminObject");
             desc.setResourceAdapter("aod-ra");
             desc.addProperty("org.glassfish.admin-object.resType", "connector.MyAdminObject");
@@ -287,7 +287,7 @@
             desc = new AdministeredObjectDefinitionDescriptor();
             desc.setDescription("application-scope resource defined in EJB DD");
             desc.setName("java:app/env/HelloStatefulEJB_DD_AdminObject");
-            desc.setInterfaceName("javax.jms.Destination");
+            desc.setInterfaceName("jakarta.jms.Destination");
             desc.setClassName("connector.MyAdminObject");
             desc.setResourceAdapter("aod-ra");
             desc.addProperty("org.glassfish.admin-object.resType", "connector.MyAdminObject");
@@ -296,7 +296,7 @@
             desc = new AdministeredObjectDefinitionDescriptor();
             desc.setDescription("module-scope resource defined in EJB DD");
             desc.setName("java:module/env/HelloStatefulEJB_DD_AdminObject");
-            desc.setInterfaceName("javax.jms.Destination");
+            desc.setInterfaceName("jakarta.jms.Destination");
             desc.setClassName("connector.MyAdminObject");
             desc.setResourceAdapter("aod-ra");
             desc.addProperty("org.glassfish.admin-object.resType", "connector.MyAdminObject");
@@ -305,7 +305,7 @@
             desc = new AdministeredObjectDefinitionDescriptor();
             desc.setDescription("component-scope resource defined in EJB DD");
             desc.setName("java:comp/env/HelloStatefulEJB_DD_AdminObject");
-            desc.setInterfaceName("javax.jms.Destination");
+            desc.setInterfaceName("jakarta.jms.Destination");
             desc.setClassName("connector.MyAdminObject");
             desc.setResourceAdapter("aod-ra");
             desc.addProperty("org.glassfish.admin-object.resType", "connector.MyAdminObject");
@@ -316,7 +316,7 @@
             desc = new AdministeredObjectDefinitionDescriptor();
             desc.setDescription("global-scope resource defined in EJB DD");
             desc.setName("java:global/env/HelloEJB_DD_AdminObject");
-            desc.setInterfaceName("javax.jms.Destination");
+            desc.setInterfaceName("jakarta.jms.Destination");
             desc.setClassName("connector.MyAdminObject");
             desc.setResourceAdapter("aod-ra");
             desc.addProperty("org.glassfish.admin-object.resType", "connector.MyAdminObject");
@@ -325,7 +325,7 @@
             desc = new AdministeredObjectDefinitionDescriptor();
             desc.setDescription("application-scope resource defined in EJB DD");
             desc.setName("java:app/env/HelloEJB_DD_AdminObject");
-            desc.setInterfaceName("javax.jms.Destination");
+            desc.setInterfaceName("jakarta.jms.Destination");
             desc.setClassName("connector.MyAdminObject");
             desc.setResourceAdapter("aod-ra");
             desc.addProperty("org.glassfish.admin-object.resType", "connector.MyAdminObject");
@@ -334,7 +334,7 @@
             desc = new AdministeredObjectDefinitionDescriptor();
             desc.setDescription("module-scope resource defined in EJB DD");
             desc.setName("java:module/env/HelloEJB_DD_AdminObject");
-            desc.setInterfaceName("javax.jms.Destination");
+            desc.setInterfaceName("jakarta.jms.Destination");
             desc.setClassName("connector.MyAdminObject");
             desc.setResourceAdapter("aod-ra");
             desc.addProperty("org.glassfish.admin-object.resType", "connector.MyAdminObject");
@@ -343,7 +343,7 @@
             desc = new AdministeredObjectDefinitionDescriptor();
             desc.setDescription("component-scope resource defined in EJB DD");
             desc.setName("java:comp/env/HelloEJB_DD_AdminObject");
-            desc.setInterfaceName("javax.jms.Destination");
+            desc.setInterfaceName("jakarta.jms.Destination");
             desc.setClassName("connector.MyAdminObject");
             desc.setResourceAdapter("aod-ra");
             desc.addProperty("org.glassfish.admin-object.resType", "connector.MyAdminObject");
@@ -355,7 +355,7 @@
             desc = new AdministeredObjectDefinitionDescriptor();
             desc.setDescription("global-scope resource defined by @AdministeredObjectDefinition");
             desc.setName("java:global/env/HelloStatefulEJB_Annotation_AdminObject");
-            desc.setInterfaceName("javax.jms.Destination");
+            desc.setInterfaceName("jakarta.jms.Destination");
             desc.setClassName("connector.MyAdminObject");
             desc.setResourceAdapter("aod-ra");
             desc.addProperty("org.glassfish.admin-object.resType", "connector.MyAdminObject");
@@ -364,7 +364,7 @@
             desc = new AdministeredObjectDefinitionDescriptor();
             desc.setDescription("application-scope resource defined by @AdministeredObjectDefinition");
             desc.setName("java:app/env/HelloStatefulEJB_Annotation_AdminObject");
-            desc.setInterfaceName("javax.jms.Destination");
+            desc.setInterfaceName("jakarta.jms.Destination");
             desc.setClassName("connector.MyAdminObject");
             desc.setResourceAdapter("aod-ra");
             desc.addProperty("org.glassfish.admin-object.resType", "connector.MyAdminObject");
@@ -373,7 +373,7 @@
             desc = new AdministeredObjectDefinitionDescriptor();
             desc.setDescription("module-scope resource defined by @AdministeredObjectDefinition");
             desc.setName("java:module/env/HelloStatefulEJB_Annotation_AdminObject");
-            desc.setInterfaceName("javax.jms.Destination");
+            desc.setInterfaceName("jakarta.jms.Destination");
             desc.setClassName("connector.MyAdminObject");
             desc.setResourceAdapter("aod-ra");
             desc.addProperty("org.glassfish.admin-object.resType", "connector.MyAdminObject");
@@ -382,7 +382,7 @@
             desc = new AdministeredObjectDefinitionDescriptor();
             desc.setDescription("component-scope resource defined by @AdministeredObjectDefinition");
             desc.setName("java:comp/env/HelloStatefulEJB_Annotation_AdminObject");
-            desc.setInterfaceName("javax.jms.Destination");
+            desc.setInterfaceName("jakarta.jms.Destination");
             desc.setClassName("connector.MyAdminObject");
             desc.setResourceAdapter("aod-ra");
             desc.addProperty("org.glassfish.admin-object.resType", "connector.MyAdminObject");
@@ -394,7 +394,7 @@
             desc = new AdministeredObjectDefinitionDescriptor();
             desc.setDescription("global-scope resource defined by @AdministeredObjectDefinition");
             desc.setName("java:global/env/HelloEJB_Annotation_AdminObject");
-            desc.setInterfaceName("javax.jms.Destination");
+            desc.setInterfaceName("jakarta.jms.Destination");
             desc.setClassName("connector.MyAdminObject");
             desc.setResourceAdapter("aod-ra");
             desc.addProperty("org.glassfish.admin-object.resType", "connector.MyAdminObject");
@@ -403,7 +403,7 @@
             desc = new AdministeredObjectDefinitionDescriptor();
             desc.setDescription("application-scope resource defined by @AdministeredObjectDefinition");
             desc.setName("java:app/env/HelloEJB_Annotation_AdminObject");
-            desc.setInterfaceName("javax.jms.Destination");
+            desc.setInterfaceName("jakarta.jms.Destination");
             desc.setClassName("connector.MyAdminObject");
             desc.setResourceAdapter("aod-ra");
             desc.addProperty("org.glassfish.admin-object.resType", "connector.MyAdminObject");
@@ -412,7 +412,7 @@
             desc = new AdministeredObjectDefinitionDescriptor();
             desc.setDescription("module-scope resource defined by @AdministeredObjectDefinition");
             desc.setName("java:module/env/HelloEJB_Annotation_AdminObject");
-            desc.setInterfaceName("javax.jms.Destination");
+            desc.setInterfaceName("jakarta.jms.Destination");
             desc.setClassName("connector.MyAdminObject");
             desc.setResourceAdapter("aod-ra");
             desc.addProperty("org.glassfish.admin-object.resType", "connector.MyAdminObject");
@@ -421,7 +421,7 @@
             desc = new AdministeredObjectDefinitionDescriptor();
             desc.setDescription("component-scope resource defined by @AdministeredObjectDefinition");
             desc.setName("java:comp/env/HelloEJB_Annotation_AdminObject");
-            desc.setInterfaceName("javax.jms.Destination");
+            desc.setInterfaceName("jakarta.jms.Destination");
             desc.setClassName("connector.MyAdminObject");
             desc.setResourceAdapter("aod-ra");
             desc.addProperty("org.glassfish.admin-object.resType", "connector.MyAdminObject");
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/ut/DDTest.java b/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/ut/DDTest.java
index 5f9b308..f411c9e 100644
--- a/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/ut/DDTest.java
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/administered-object-definition/ut/DDTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2002, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2002, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -68,7 +68,7 @@
 
             desc = new AdministeredObjectDefinitionDescriptor();
             desc.setName("java:global/env/AdminObject");
-            desc.setInterfaceName("javax.jms.Destination");
+            desc.setInterfaceName("jakarta.jms.Destination");
             desc.setClassName("connector.MyAdminObject");
             desc.setDescription("global-scope resource defined in application DD");
             desc.setResourceAdapter("aod-ra");
@@ -77,7 +77,7 @@
             
             desc = new AdministeredObjectDefinitionDescriptor();
             desc.setName("java:app/env/AdminObject");
-            desc.setInterfaceName("javax.jms.Destination");
+            desc.setInterfaceName("jakarta.jms.Destination");
             desc.setClassName("connector.MyAdminObject");
             desc.setDescription("application-scope resource defined in application DD");
             desc.setResourceAdapter("aod-ra");
@@ -144,7 +144,7 @@
         desc = new AdministeredObjectDefinitionDescriptor();
         desc.setDescription("global-scope resource defined in EJB DD");
         desc.setName("java:global/env/StatefulEJB_AdminObject");
-        desc.setInterfaceName("javax.jms.Destination");
+        desc.setInterfaceName("jakarta.jms.Destination");
         desc.setClassName("connector.MyAdminObject");
         desc.setResourceAdapter("aod-ra");
         desc.addProperty("org.glassfish.admin-object.resType", "connector.MyAdminObject");
@@ -153,7 +153,7 @@
         desc = new AdministeredObjectDefinitionDescriptor();
         desc.setDescription("module-scope resource defined in EJB DD");
         desc.setName("java:module/env/StatefulEJB_AdminObject");
-        desc.setInterfaceName("javax.jms.Destination");
+        desc.setInterfaceName("jakarta.jms.Destination");
         desc.setClassName("connector.MyAdminObject");
         desc.setResourceAdapter("aod-ra");
         desc.addProperty("org.glassfish.admin-object.resType", "connector.MyAdminObject");
@@ -162,7 +162,7 @@
         desc = new AdministeredObjectDefinitionDescriptor();
         desc.setDescription("component-scope resource defined in EJB DD");
         desc.setName("java:comp/env/StatefulEJB_AdminObject");
-        desc.setInterfaceName("javax.jms.Destination");
+        desc.setInterfaceName("jakarta.jms.Destination");
         desc.setClassName("connector.MyAdminObject");
         desc.setResourceAdapter("aod-ra");
         desc.addProperty("org.glassfish.admin-object.resType", "connector.MyAdminObject");
@@ -179,7 +179,7 @@
         desc = new AdministeredObjectDefinitionDescriptor();
         desc.setDescription("global-scope resource defined in EJB DD");
         desc.setName("java:global/env/HelloEJB_AdminObject");
-        desc.setInterfaceName("javax.jms.Destination");
+        desc.setInterfaceName("jakarta.jms.Destination");
         desc.setClassName("connector.MyAdminObject");
         desc.setResourceAdapter("aod-ra");
         desc.addProperty("org.glassfish.admin-object.resType", "connector.MyAdminObject");
@@ -188,7 +188,7 @@
         desc = new AdministeredObjectDefinitionDescriptor();
         desc.setDescription("module-scope resource defined in EJB DD");
         desc.setName("java:module/env/HelloEJB_AdminObject");
-        desc.setInterfaceName("javax.jms.Destination");
+        desc.setInterfaceName("jakarta.jms.Destination");
         desc.setClassName("connector.MyAdminObject");
         desc.setResourceAdapter("aod-ra");
         desc.addProperty("org.glassfish.admin-object.resType", "connector.MyAdminObject");
@@ -197,7 +197,7 @@
         desc = new AdministeredObjectDefinitionDescriptor();
         desc.setDescription("component-scope resource defined in EJB DD");
         desc.setName("java:comp/env/HelloEJB_AdminObject");
-        desc.setInterfaceName("javax.jms.Destination");
+        desc.setInterfaceName("jakarta.jms.Destination");
         desc.setClassName("connector.MyAdminObject");
         desc.setResourceAdapter("aod-ra");
         desc.addProperty("org.glassfish.admin-object.resType", "connector.MyAdminObject");
@@ -227,7 +227,7 @@
                 desc = new AdministeredObjectDefinitionDescriptor();
                 desc.setDescription("global-scope resource defined in EJB DD");
                 desc.setName("java:global/env/Entity_AdminObject");
-                desc.setInterfaceName("javax.jms.Destination");
+                desc.setInterfaceName("jakarta.jms.Destination");
                 desc.setClassName("connector.MyAdminObject");
                 desc.setResourceAdapter("aod-ra");
                 desc.addProperty("org.glassfish.admin-object.resType", "connector.MyAdminObject");
@@ -236,7 +236,7 @@
                 desc = new AdministeredObjectDefinitionDescriptor();
                 desc.setDescription("module-scope resource defined in EJB DD");
                 desc.setName("java:module/env/Entity_AdminObject");
-                desc.setInterfaceName("javax.jms.Destination");
+                desc.setInterfaceName("jakarta.jms.Destination");
                 desc.setClassName("connector.MyAdminObject");
                 desc.setResourceAdapter("aod-ra");
                 desc.addProperty("org.glassfish.admin-object.resType", "connector.MyAdminObject");
@@ -245,7 +245,7 @@
                 desc = new AdministeredObjectDefinitionDescriptor();
                 desc.setDescription("component-scope resource defined in EJB DD");
                 desc.setName("java:comp/env/Entity_AdminObject");
-                desc.setInterfaceName("javax.jms.Destination");
+                desc.setInterfaceName("jakarta.jms.Destination");
                 desc.setClassName("connector.MyAdminObject");
                 desc.setResourceAdapter("aod-ra");
                 desc.addProperty("org.glassfish.admin-object.resType", "connector.MyAdminObject");
@@ -288,7 +288,7 @@
                 desc = new AdministeredObjectDefinitionDescriptor();
                 desc.setDescription("global-scope resource defined in EJB DD");
                 desc.setName("java:global/env/MDB_AdminObject");
-                desc.setInterfaceName("javax.jms.Destination");
+                desc.setInterfaceName("jakarta.jms.Destination");
                 desc.setClassName("connector.MyAdminObject");
                 desc.setResourceAdapter("aod-ra");
                 desc.addProperty("org.glassfish.admin-object.resType", "connector.MyAdminObject");
@@ -297,7 +297,7 @@
                 desc = new AdministeredObjectDefinitionDescriptor();
                 desc.setDescription("module-scope resource defined in EJB DD");
                 desc.setName("java:module/env/MDB_AdminObject");
-                desc.setInterfaceName("javax.jms.Destination");
+                desc.setInterfaceName("jakarta.jms.Destination");
                 desc.setClassName("connector.MyAdminObject");
                 desc.setResourceAdapter("aod-ra");
                 desc.addProperty("org.glassfish.admin-object.resType", "connector.MyAdminObject");
@@ -306,7 +306,7 @@
                 desc = new AdministeredObjectDefinitionDescriptor();
                 desc.setDescription("component-scope resource defined in EJB DD");
                 desc.setName("java:comp/env/MDB_AdminObject");
-                desc.setInterfaceName("javax.jms.Destination");
+                desc.setInterfaceName("jakarta.jms.Destination");
                 desc.setClassName("connector.MyAdminObject");
                 desc.setResourceAdapter("aod-ra");
                 desc.addProperty("org.glassfish.admin-object.resType", "connector.MyAdminObject");
@@ -349,7 +349,7 @@
                 desc = new AdministeredObjectDefinitionDescriptor();
                 desc.setDescription("global-scope resource defined in EJB DD");
                 desc.setName("java:global/env/Interceptor_AdminObject");
-                desc.setInterfaceName("javax.jms.Destination");
+                desc.setInterfaceName("jakarta.jms.Destination");
                 desc.setClassName("connector.MyAdminObject");
                 desc.setResourceAdapter("aod-ra");
                 desc.addProperty("org.glassfish.admin-object.resType", "connector.MyAdminObject");
@@ -358,7 +358,7 @@
                 desc = new AdministeredObjectDefinitionDescriptor();
                 desc.setDescription("module-scope resource defined in EJB DD");
                 desc.setName("java:module/env/Interceptor_AdminObject");
-                desc.setInterfaceName("javax.jms.Destination");
+                desc.setInterfaceName("jakarta.jms.Destination");
                 desc.setClassName("connector.MyAdminObject");
                 desc.setResourceAdapter("aod-ra");
                 desc.addProperty("org.glassfish.admin-object.resType", "connector.MyAdminObject");
@@ -367,7 +367,7 @@
                 desc = new AdministeredObjectDefinitionDescriptor();
                 desc.setDescription("component-scope resource defined in EJB DD");
                 desc.setName("java:comp/env/Interceptor_AdminObject");
-                desc.setInterfaceName("javax.jms.Destination");
+                desc.setInterfaceName("jakarta.jms.Destination");
                 desc.setClassName("connector.MyAdminObject");
                 desc.setResourceAdapter("aod-ra");
                 desc.addProperty("org.glassfish.admin-object.resType", "connector.MyAdminObject");
@@ -418,7 +418,7 @@
             desc = new AdministeredObjectDefinitionDescriptor();
             desc.setDescription("application-scope resource defined in Web DD");
             desc.setName("java:app/env/AdminObject");
-            desc.setInterfaceName("javax.jms.Destination");
+            desc.setInterfaceName("jakarta.jms.Destination");
             desc.setClassName("connector.MyAdminObject");
             desc.setResourceAdapter("aod-ra");
             desc.addProperty("org.glassfish.admin-object.resType", "connector.MyAdminObject");
@@ -427,7 +427,7 @@
             desc = new AdministeredObjectDefinitionDescriptor();
             desc.setDescription("module-scope resource defined in Web DD");
             desc.setName("java:module/env/AdminObject");
-            desc.setInterfaceName("javax.jms.Destination");
+            desc.setInterfaceName("jakarta.jms.Destination");
             desc.setClassName("connector.MyAdminObject");
             desc.setResourceAdapter("aod-ra");
             desc.addProperty("org.glassfish.admin-object.resType", "connector.MyAdminObject");
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/annotation-connector-mixedmode/app/src/mdb/MyMessageBean.java b/appserver/tests/appserv-tests/devtests/connector/v3/annotation-connector-mixedmode/app/src/mdb/MyMessageBean.java
index 647b114..cb0d388 100755
--- a/appserver/tests/appserv-tests/devtests/connector/v3/annotation-connector-mixedmode/app/src/mdb/MyMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/annotation-connector-mixedmode/app/src/mdb/MyMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2001, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,13 +19,11 @@
 import connector.MyMessageListener;
 import javax.ejb.*;
 import javax.naming.*;
-import java.io.*;
-import java.rmi.RemoteException;
 import javax.servlet.*;
 import javax.servlet.http.*;
 import java.sql.*;
 import javax.sql.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.transaction.*;
 
 
@@ -63,7 +61,7 @@
     /**
      * onMessage method, declared as public (but not final or 
      * static), with a return type of void, and with one argument
-     * of type javax.jms.Message.
+     * of type jakarta.jms.Message.
      *
      * Casts the incoming Message to a TextMessage and displays 
      * the text.
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/annotation-connector1.5/app/src/mdb/MyMessageBean.java b/appserver/tests/appserv-tests/devtests/connector/v3/annotation-connector1.5/app/src/mdb/MyMessageBean.java
index aed7974..467425a 100755
--- a/appserver/tests/appserv-tests/devtests/connector/v3/annotation-connector1.5/app/src/mdb/MyMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/annotation-connector1.5/app/src/mdb/MyMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2001, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -25,7 +25,7 @@
 import javax.servlet.http.*;
 import java.sql.*;
 import javax.sql.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.transaction.*;
 
 
@@ -63,7 +63,7 @@
     /**
      * onMessage method, declared as public (but not final or 
      * static), with a return type of void, and with one argument
-     * of type javax.jms.Message.
+     * of type jakarta.jms.Message.
      *
      * Casts the incoming Message to a TextMessage and displays 
      * the text.
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/app-scoped-resources-ms4-demo/app/src/mdb/MyMessageBean.java b/appserver/tests/appserv-tests/devtests/connector/v3/app-scoped-resources-ms4-demo/app/src/mdb/MyMessageBean.java
index a5c3e06..d6950b7 100755
--- a/appserver/tests/appserv-tests/devtests/connector/v3/app-scoped-resources-ms4-demo/app/src/mdb/MyMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/app-scoped-resources-ms4-demo/app/src/mdb/MyMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2001, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,13 +19,11 @@
 import connector.MyMessageListener;
 import javax.ejb.*;
 import javax.naming.*;
-import java.io.*;
-import java.rmi.RemoteException;
 import javax.servlet.*;
 import javax.servlet.http.*;
 import java.sql.*;
 import javax.sql.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.transaction.*;
 
 
@@ -63,7 +61,7 @@
     /**
      * onMessage method, declared as public (but not final or 
      * static), with a return type of void, and with one argument
-     * of type javax.jms.Message.
+     * of type jakarta.jms.Message.
      *
      * Casts the incoming Message to a TextMessage and displays 
      * the text.
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/beanvalidation-simple-resources-xml/app/META-INF/glassfish-resources.xml b/appserver/tests/appserv-tests/devtests/connector/v3/beanvalidation-simple-resources-xml/app/META-INF/glassfish-resources.xml
index e8e29bb..9554b37 100755
--- a/appserver/tests/appserv-tests/devtests/connector/v3/beanvalidation-simple-resources-xml/app/META-INF/glassfish-resources.xml
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/beanvalidation-simple-resources-xml/app/META-INF/glassfish-resources.xml
@@ -2,7 +2,7 @@
 <!DOCTYPE resources PUBLIC "-//GlassFish.org//DTD GlassFish Application Server 3.1 Resource Definitions //EN" "http://glassfish.org/dtds/glassfish-resources_1_5.dtd">
 <!--
 
-    Copyright (c) 2004, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2004, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -57,7 +57,7 @@
           <property name="connectionAttributes" value="create=true" />
         </jdbc-connection-pool>
 
- <admin-object-resource enabled="true" jndi-name="java:app/jms/MyQueueWeb_1" object-type="user" res-adapter="jmsra" res-type="javax.jms.Queue">
+ <admin-object-resource enabled="true" jndi-name="java:app/jms/MyQueueWeb_1" object-type="user" res-adapter="jmsra" res-type="jakarta.jms.Queue">
     <property name="Name" value="PQueueWeb"/>
   </admin-object-resource>
 
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/beanvalidation-simple-resources-xml/app/src/mdb/MyMessageBean.java b/appserver/tests/appserv-tests/devtests/connector/v3/beanvalidation-simple-resources-xml/app/src/mdb/MyMessageBean.java
index aed7974..bc32dc0 100755
--- a/appserver/tests/appserv-tests/devtests/connector/v3/beanvalidation-simple-resources-xml/app/src/mdb/MyMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/beanvalidation-simple-resources-xml/app/src/mdb/MyMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2001, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,13 +19,11 @@
 import connector.MyMessageListener;
 import javax.ejb.*;
 import javax.naming.*;
-import java.io.*;
-import java.rmi.RemoteException;
 import javax.servlet.*;
 import javax.servlet.http.*;
 import java.sql.*;
 import javax.sql.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.transaction.*;
 
 
@@ -63,7 +61,7 @@
     /**
      * onMessage method, declared as public (but not final or 
      * static), with a return type of void, and with one argument
-     * of type javax.jms.Message.
+     * of type jakarta.jms.Message.
      *
      * Casts the incoming Message to a TextMessage and displays 
      * the text.
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/beanvalidation-simple/app/src/mdb/MyMessageBean.java b/appserver/tests/appserv-tests/devtests/connector/v3/beanvalidation-simple/app/src/mdb/MyMessageBean.java
index aed7974..bc32dc0 100755
--- a/appserver/tests/appserv-tests/devtests/connector/v3/beanvalidation-simple/app/src/mdb/MyMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/beanvalidation-simple/app/src/mdb/MyMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2001, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,13 +19,11 @@
 import connector.MyMessageListener;
 import javax.ejb.*;
 import javax.naming.*;
-import java.io.*;
-import java.rmi.RemoteException;
 import javax.servlet.*;
 import javax.servlet.http.*;
 import java.sql.*;
 import javax.sql.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.transaction.*;
 
 
@@ -63,7 +61,7 @@
     /**
      * onMessage method, declared as public (but not final or 
      * static), with a return type of void, and with one argument
-     * of type javax.jms.Message.
+     * of type jakarta.jms.Message.
      *
      * Casts the incoming Message to a TextMessage and displays 
      * the text.
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/connector1.5/app/src/mdb/MyMessageBean.java b/appserver/tests/appserv-tests/devtests/connector/v3/connector1.5/app/src/mdb/MyMessageBean.java
index aed7974..bc32dc0 100755
--- a/appserver/tests/appserv-tests/devtests/connector/v3/connector1.5/app/src/mdb/MyMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/connector1.5/app/src/mdb/MyMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2001, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,13 +19,11 @@
 import connector.MyMessageListener;
 import javax.ejb.*;
 import javax.naming.*;
-import java.io.*;
-import java.rmi.RemoteException;
 import javax.servlet.*;
 import javax.servlet.http.*;
 import java.sql.*;
 import javax.sql.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.transaction.*;
 
 
@@ -63,7 +61,7 @@
     /**
      * onMessage method, declared as public (but not final or 
      * static), with a return type of void, and with one argument
-     * of type javax.jms.Message.
+     * of type jakarta.jms.Message.
      *
      * Casts the incoming Message to a TextMessage and displays 
      * the text.
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/connector1.6-resources-xml/app/src/mdb/MyMessageBean.java b/appserver/tests/appserv-tests/devtests/connector/v3/connector1.6-resources-xml/app/src/mdb/MyMessageBean.java
index a5c3e06..9e1ec9c 100755
--- a/appserver/tests/appserv-tests/devtests/connector/v3/connector1.6-resources-xml/app/src/mdb/MyMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/connector1.6-resources-xml/app/src/mdb/MyMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2001, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -25,7 +25,7 @@
 import javax.servlet.http.*;
 import java.sql.*;
 import javax.sql.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.transaction.*;
 
 
@@ -63,7 +63,7 @@
     /**
      * onMessage method, declared as public (but not final or 
      * static), with a return type of void, and with one argument
-     * of type javax.jms.Message.
+     * of type jakarta.jms.Message.
      *
      * Casts the incoming Message to a TextMessage and displays 
      * the text.
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/connector1.6/app/src/mdb/MyMessageBean.java b/appserver/tests/appserv-tests/devtests/connector/v3/connector1.6/app/src/mdb/MyMessageBean.java
index a5c3e06..9e1ec9c 100755
--- a/appserver/tests/appserv-tests/devtests/connector/v3/connector1.6/app/src/mdb/MyMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/connector1.6/app/src/mdb/MyMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2001, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -25,7 +25,7 @@
 import javax.servlet.http.*;
 import java.sql.*;
 import javax.sql.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.transaction.*;
 
 
@@ -63,7 +63,7 @@
     /**
      * onMessage method, declared as public (but not final or 
      * static), with a return type of void, and with one argument
-     * of type javax.jms.Message.
+     * of type jakarta.jms.Message.
      *
      * Casts the incoming Message to a TextMessage and displays 
      * the text.
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/defaultConnectorResource-standalone-rar/app/src/mdb/MyMessageBean.java b/appserver/tests/appserv-tests/devtests/connector/v3/defaultConnectorResource-standalone-rar/app/src/mdb/MyMessageBean.java
index 0367f3c..cf1877b 100755
--- a/appserver/tests/appserv-tests/devtests/connector/v3/defaultConnectorResource-standalone-rar/app/src/mdb/MyMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/defaultConnectorResource-standalone-rar/app/src/mdb/MyMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2001, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,13 +20,11 @@
 
 import javax.ejb.*;
 import javax.naming.*;
-import java.io.*;
-import java.rmi.RemoteException;
 import javax.servlet.*;
 import javax.servlet.http.*;
 import java.sql.*;
 import javax.sql.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.transaction.*;
 
 
@@ -66,7 +64,7 @@
     /**
      * onMessage method, declared as public (but not final or
      * static), with a return type of void, and with one argument
-     * of type javax.jms.Message.
+     * of type jakarta.jms.Message.
      * <p/>
      * Casts the incoming Message to a TextMessage and displays
      * the text.
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/defaultConnectorResource/app/src/mdb/MyMessageBean.java b/appserver/tests/appserv-tests/devtests/connector/v3/defaultConnectorResource/app/src/mdb/MyMessageBean.java
index 0367f3c..1b2cc5a 100755
--- a/appserver/tests/appserv-tests/devtests/connector/v3/defaultConnectorResource/app/src/mdb/MyMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/defaultConnectorResource/app/src/mdb/MyMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2001, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -26,7 +26,7 @@
 import javax.servlet.http.*;
 import java.sql.*;
 import javax.sql.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.transaction.*;
 
 
@@ -66,7 +66,7 @@
     /**
      * onMessage method, declared as public (but not final or
      * static), with a return type of void, and with one argument
-     * of type javax.jms.Message.
+     * of type jakarta.jms.Message.
      * <p/>
      * Casts the incoming Message to a TextMessage and displays
      * the text.
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/jms-connection-factory-definition/client/Client.java b/appserver/tests/appserv-tests/devtests/connector/v3/jms-connection-factory-definition/client/Client.java
index 1bcff3f..a95e04e 100644
--- a/appserver/tests/appserv-tests/devtests/connector/v3/jms-connection-factory-definition/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/jms-connection-factory-definition/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -24,10 +24,10 @@
 import java.net.HttpURLConnection;
 import java.net.URL;
 
-import javax.jms.Connection;
-import javax.jms.ConnectionFactory;
-import javax.jms.JMSConnectionFactoryDefinition;
-import javax.jms.JMSConnectionFactoryDefinitions;
+import jakarta.jms.Connection;
+import jakarta.jms.ConnectionFactory;
+import jakarta.jms.JMSConnectionFactoryDefinition;
+import jakarta.jms.JMSConnectionFactoryDefinitions;
 import javax.naming.InitialContext;
 
 @JMSConnectionFactoryDefinitions(
@@ -36,7 +36,7 @@
                @JMSConnectionFactoryDefinition(
                         description = "global-scope resource defined by @JMSConnectionFactoryDefinition",
                         name = "java:global/env/Appclient_ModByDD_JMSConnectionFactory",
-                        interfaceName = "javax.jms.ConnectionFactory",
+                        interfaceName = "jakarta.jms.ConnectionFactory",
                         resourceAdapter = "jmsra",
                         user = "admin",
                         password = "admin",
@@ -47,7 +47,7 @@
                @JMSConnectionFactoryDefinition(
                         description = "global-scope resource defined by @JMSConnectionFactoryDefinition",
                         name = "java:global/env/Appclient_Annotation_JMSConnectionFactory",
-                        interfaceName = "javax.jms.ConnectionFactory",
+                        interfaceName = "jakarta.jms.ConnectionFactory",
                         resourceAdapter = "jmsra",
                         user = "admin",
                         password = "admin",
@@ -58,7 +58,7 @@
                 @JMSConnectionFactoryDefinition(
                         description = "application-scope resource defined by @JMSConnectionFactoryDefinition",
                         name = "java:app/env/Appclient_Annotation_JMSConnectionFactory",
-                        interfaceName = "javax.jms.ConnectionFactory",
+                        interfaceName = "jakarta.jms.ConnectionFactory",
                         resourceAdapter = "jmsra",
                         user = "admin",
                         password = "admin",
@@ -69,7 +69,7 @@
                 @JMSConnectionFactoryDefinition(
                         description = "module-scope resource defined by @JMSConnectionFactoryDefinition",
                         name = "java:module/env/Appclient_Annotation_JMSConnectionFactory",
-                        interfaceName = "javax.jms.ConnectionFactory",
+                        interfaceName = "jakarta.jms.ConnectionFactory",
                         resourceAdapter = "jmsra",
                         user = "admin",
                         password = "admin",
@@ -80,7 +80,7 @@
                 @JMSConnectionFactoryDefinition(
                         description = "component-scope resource defined by @JMSConnectionFactoryDefinition",
                         name = "java:comp/env/Appclient_Annotation_JMSConnectionFactory",
-                        interfaceName = "javax.jms.ConnectionFactory",
+                        interfaceName = "jakarta.jms.ConnectionFactory",
                         resourceAdapter = "jmsra",
                         user = "admin",
                         password = "admin",
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/jms-connection-factory-definition/descriptor/application-client.xml b/appserver/tests/appserv-tests/devtests/connector/v3/jms-connection-factory-definition/descriptor/application-client.xml
index a919cd3..cbe41fd 100644
--- a/appserver/tests/appserv-tests/devtests/connector/v3/jms-connection-factory-definition/descriptor/application-client.xml
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/jms-connection-factory-definition/descriptor/application-client.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -26,7 +26,7 @@
     <jms-connection-factory>
         <description>global-scope resource to be modified by Appclient DD</description>
         <name>java:global/env/Appclient_ModByDD_JMSConnectionFactory</name>
-        <interface-name>javax.jms.ConnectionFactory</interface-name>
+        <interface-name>jakarta.jms.ConnectionFactory</interface-name>
         <resource-adapter>jmsra</resource-adapter>
         <user>admin</user>
         <password>admin</password>
@@ -40,7 +40,7 @@
     <jms-connection-factory>
         <description>global-scope resource defined in Appclient DD</description>
         <name>java:global/env/Appclient_DD_JMSConnectionFactory</name>
-        <interface-name>javax.jms.ConnectionFactory</interface-name>
+        <interface-name>jakarta.jms.ConnectionFactory</interface-name>
         <resource-adapter>jmsra</resource-adapter>
         <user>admin</user>
         <password>admin</password>
@@ -54,7 +54,7 @@
     <jms-connection-factory>
         <description>application-scope resource defined in Appclient DD</description>
         <name>java:app/env/Appclient_DD_JMSConnectionFactory</name>
-        <interface-name>javax.jms.ConnectionFactory</interface-name>
+        <interface-name>jakarta.jms.ConnectionFactory</interface-name>
         <resource-adapter>jmsra</resource-adapter>
         <user>admin</user>
         <password>admin</password>
@@ -68,7 +68,7 @@
     <jms-connection-factory>
         <description>module-scope resource defined in Appclient DD</description>
         <name>java:module/env/Appclient_DD_JMSConnectionFactory</name>
-        <interface-name>javax.jms.ConnectionFactory</interface-name>
+        <interface-name>jakarta.jms.ConnectionFactory</interface-name>
         <resource-adapter>jmsra</resource-adapter>
         <user>admin</user>
         <password>admin</password>
@@ -82,7 +82,7 @@
     <jms-connection-factory>
         <description>component-scope resource defined in Appclient DD</description>
         <name>java:comp/env/Appclient_DD_JMSConnectionFactory</name>
-        <interface-name>javax.jms.ConnectionFactory</interface-name>
+        <interface-name>jakarta.jms.ConnectionFactory</interface-name>
         <resource-adapter>jmsra</resource-adapter>
         <user>admin</user>
         <password>admin</password>
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/jms-connection-factory-definition/descriptor/application.xml b/appserver/tests/appserv-tests/devtests/connector/v3/jms-connection-factory-definition/descriptor/application.xml
index 8a66349..5d90f1b 100644
--- a/appserver/tests/appserv-tests/devtests/connector/v3/jms-connection-factory-definition/descriptor/application.xml
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/jms-connection-factory-definition/descriptor/application.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -38,7 +38,7 @@
     <jms-connection-factory>
         <description>global-scope resource defined in Application DD</description>
         <name>java:global/env/Application_DD_JMSConnectionFactory</name>
-        <interface-name>javax.jms.ConnectionFactory</interface-name>
+        <interface-name>jakarta.jms.ConnectionFactory</interface-name>
         <resource-adapter>jmsra</resource-adapter>
         <user>admin</user>
         <password>admin</password>
@@ -52,7 +52,7 @@
     <jms-connection-factory>
         <description>application-scope resource defined in Application DD</description>
         <name>java:app/env/Application_DD_JMSConnectionFactory</name>
-        <interface-name>javax.jms.ConnectionFactory</interface-name>
+        <interface-name>jakarta.jms.ConnectionFactory</interface-name>
         <resource-adapter>jmsra</resource-adapter>
         <user>admin</user>
         <password>admin</password>
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/jms-connection-factory-definition/descriptor/ejb-jar.xml b/appserver/tests/appserv-tests/devtests/connector/v3/jms-connection-factory-definition/descriptor/ejb-jar.xml
index e0f1d4b..659d209 100644
--- a/appserver/tests/appserv-tests/devtests/connector/v3/jms-connection-factory-definition/descriptor/ejb-jar.xml
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/jms-connection-factory-definition/descriptor/ejb-jar.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8" standalone="no"?>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -34,7 +34,7 @@
             <jms-connection-factory>
                 <description>global-scope resource to be modified by EJB DD</description>
                 <name>java:global/env/HelloStatefulEJB_ModByDD_JMSConnectionFactory</name>
-                <interface-name>javax.jms.ConnectionFactory</interface-name>
+                <interface-name>jakarta.jms.ConnectionFactory</interface-name>
                 <resource-adapter>jmsra</resource-adapter>
                 <user>admin</user>
                 <password>admin</password>
@@ -48,7 +48,7 @@
             <jms-connection-factory>
                 <description>global-scope resource defined in EJB DD</description>
                 <name>java:global/env/HelloStatefulEJB_DD_JMSConnectionFactory</name>
-                <interface-name>javax.jms.ConnectionFactory</interface-name>
+                <interface-name>jakarta.jms.ConnectionFactory</interface-name>
                 <resource-adapter>jmsra</resource-adapter>
                 <user>admin</user>
                 <password>admin</password>
@@ -62,7 +62,7 @@
             <jms-connection-factory>
                 <description>application-scope resource defined in EJB DD</description>
                 <name>java:app/env/HelloStatefulEJB_DD_JMSConnectionFactory</name>
-                <interface-name>javax.jms.ConnectionFactory</interface-name>
+                <interface-name>jakarta.jms.ConnectionFactory</interface-name>
                 <resource-adapter>jmsra</resource-adapter>
                 <user>admin</user>
                 <password>admin</password>
@@ -76,7 +76,7 @@
             <jms-connection-factory>
                 <description>module-scope resource defined in EJB DD</description>
                 <name>java:module/env/HelloStatefulEJB_DD_JMSConnectionFactory</name>
-                <interface-name>javax.jms.ConnectionFactory</interface-name>
+                <interface-name>jakarta.jms.ConnectionFactory</interface-name>
                 <resource-adapter>jmsra</resource-adapter>
                 <user>admin</user>
                 <password>admin</password>
@@ -90,7 +90,7 @@
             <jms-connection-factory>
                 <description>component-scope resource defined in EJB DD</description>
                 <name>java:comp/env/HelloStatefulEJB_DD_JMSConnectionFactory</name>
-                <interface-name>javax.jms.ConnectionFactory</interface-name>
+                <interface-name>jakarta.jms.ConnectionFactory</interface-name>
                 <resource-adapter>jmsra</resource-adapter>
                 <user>admin</user>
                 <password>admin</password>
@@ -112,7 +112,7 @@
             <jms-connection-factory>
                 <description>global-scope resource to be modified by EJB DD</description>
                 <name>java:global/env/HelloEJB_ModByDD_JMSConnectionFactory</name>
-                <interface-name>javax.jms.ConnectionFactory</interface-name>
+                <interface-name>jakarta.jms.ConnectionFactory</interface-name>
                 <resource-adapter>jmsra</resource-adapter>
                 <user>admin</user>
                 <password>admin</password>
@@ -126,7 +126,7 @@
             <jms-connection-factory>
                 <description>global-scope resource defined in EJB DD</description>
                 <name>java:global/env/HelloEJB_DD_JMSConnectionFactory</name>
-                <interface-name>javax.jms.ConnectionFactory</interface-name>
+                <interface-name>jakarta.jms.ConnectionFactory</interface-name>
                 <resource-adapter>jmsra</resource-adapter>
                 <user>admin</user>
                 <password>admin</password>
@@ -140,7 +140,7 @@
             <jms-connection-factory>
                 <description>application-scope resource defined in EJB DD</description>
                 <name>java:app/env/HelloEJB_DD_JMSConnectionFactory</name>
-                <interface-name>javax.jms.ConnectionFactory</interface-name>
+                <interface-name>jakarta.jms.ConnectionFactory</interface-name>
                 <resource-adapter>jmsra</resource-adapter>
                 <user>admin</user>
                 <password>admin</password>
@@ -154,7 +154,7 @@
             <jms-connection-factory>
                 <description>module-scope resource defined in EJB DD</description>
                 <name>java:module/env/HelloEJB_DD_JMSConnectionFactory</name>
-                <interface-name>javax.jms.ConnectionFactory</interface-name>
+                <interface-name>jakarta.jms.ConnectionFactory</interface-name>
                 <resource-adapter>jmsra</resource-adapter>
                 <user>admin</user>
                 <password>admin</password>
@@ -168,7 +168,7 @@
             <jms-connection-factory>
                 <description>component-scope resource defined in EJB DD</description>
                 <name>java:comp/env/HelloEJB_DD_JMSConnectionFactory</name>
-                <interface-name>javax.jms.ConnectionFactory</interface-name>
+                <interface-name>jakarta.jms.ConnectionFactory</interface-name>
                 <resource-adapter>jmsra</resource-adapter>
                 <user>admin</user>
                 <password>admin</password>
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/jms-connection-factory-definition/descriptor/web.xml b/appserver/tests/appserv-tests/devtests/connector/v3/jms-connection-factory-definition/descriptor/web.xml
index 70252b7..13528e5 100644
--- a/appserver/tests/appserv-tests/devtests/connector/v3/jms-connection-factory-definition/descriptor/web.xml
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/jms-connection-factory-definition/descriptor/web.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2018, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -37,7 +37,7 @@
     <jms-connection-factory>
         <description>global-scope resource to be modified by Web DD</description>
         <name>java:global/env/Servlet_ModByDD_JMSConnectionFactory</name>
-<!--        <interface-name>javax.jms.ConnectionFactory</interface-name>-->
+<!--        <interface-name>jakarta.jms.ConnectionFactory</interface-name>-->
         <resource-adapter>jmsra</resource-adapter>
         <user>admin</user>
         <password>admin</password>
@@ -51,7 +51,7 @@
     <jms-connection-factory>
         <description>global-scope resource defined in Web DD</description>
         <name>java:global/env/Web_DD_JMSConnectionFactory</name>
-        <interface-name>javax.jms.ConnectionFactory</interface-name>
+        <interface-name>jakarta.jms.ConnectionFactory</interface-name>
 <!--        <resource-adapter>jmsra</resource-adapter>-->
         <user>admin</user>
         <password>admin</password>
@@ -65,7 +65,7 @@
     <jms-connection-factory>
         <description>application-scope resource defined in Web DD</description>
         <name>java:app/env/Web_DD_JMSConnectionFactory</name>
-<!--        <interface-name>javax.jms.ConnectionFactory</interface-name>
+<!--        <interface-name>jakarta.jms.ConnectionFactory</interface-name>
         <resource-adapter>jmsra</resource-adapter>-->
         <user>admin</user>
         <password>admin</password>
@@ -79,7 +79,7 @@
     <jms-connection-factory>
         <description>module-scope resource defined in Web DD</description>
         <name>java:module/env/Web_DD_JMSConnectionFactory</name>
-        <interface-name>javax.jms.ConnectionFactory</interface-name>
+        <interface-name>jakarta.jms.ConnectionFactory</interface-name>
         <resource-adapter>jmsra</resource-adapter>
         <user>admin</user>
         <password>admin</password>
@@ -93,7 +93,7 @@
     <jms-connection-factory>
         <description>component-scope resource defined in Web DD</description>
         <name>java:comp/env/Web_DD_JMSConnectionFactory</name>
-        <interface-name>javax.jms.ConnectionFactory</interface-name>
+        <interface-name>jakarta.jms.ConnectionFactory</interface-name>
         <resource-adapter>jmsra</resource-adapter>
         <user>admin</user>
         <password>admin</password>
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/jms-connection-factory-definition/ejb/HelloEJB.java b/appserver/tests/appserv-tests/devtests/connector/v3/jms-connection-factory-definition/ejb/HelloEJB.java
index 0c6fe73..4cd44bd 100644
--- a/appserver/tests/appserv-tests/devtests/connector/v3/jms-connection-factory-definition/ejb/HelloEJB.java
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/jms-connection-factory-definition/ejb/HelloEJB.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -22,10 +22,10 @@
 import javax.annotation.PostConstruct;
 import javax.annotation.PreDestroy;
 import javax.ejb.Stateless;
-import javax.jms.Connection;
-import javax.jms.ConnectionFactory;
-import javax.jms.JMSConnectionFactoryDefinition;
-import javax.jms.JMSConnectionFactoryDefinitions;
+import jakarta.jms.Connection;
+import jakarta.jms.ConnectionFactory;
+import jakarta.jms.JMSConnectionFactoryDefinition;
+import jakarta.jms.JMSConnectionFactoryDefinitions;
 import javax.naming.InitialContext;
 
 @JMSConnectionFactoryDefinitions(
@@ -33,7 +33,7 @@
                 @JMSConnectionFactoryDefinition(
                         description = "global-scope resource defined by @JMSConnectionFactoryDefinition",
                         name = "java:global/env/HelloEJB_ModByDD_JMSConnectionFactory",
-                        interfaceName = "javax.jms.ConnectionFactory",
+                        interfaceName = "jakarta.jms.ConnectionFactory",
                         resourceAdapter = "jmsra",
                         user = "admin",
                         password = "admin",
@@ -44,7 +44,7 @@
                 @JMSConnectionFactoryDefinition(
                         description = "global-scope resource defined by @JMSConnectionFactoryDefinition",
                         name = "java:global/env/HelloEJB_Annotation_JMSConnectionFactory",
-                        interfaceName = "javax.jms.ConnectionFactory",
+                        interfaceName = "jakarta.jms.ConnectionFactory",
                         resourceAdapter = "jmsra",
                         user = "admin",
                         password = "admin",
@@ -55,7 +55,7 @@
                 @JMSConnectionFactoryDefinition(
                         description = "application-scope resource defined by @JMSConnectionFactoryDefinition",
                         name = "java:app/env/HelloEJB_Annotation_JMSConnectionFactory",
-                        interfaceName = "javax.jms.ConnectionFactory",
+                        interfaceName = "jakarta.jms.ConnectionFactory",
                         resourceAdapter = "jmsra",
                         user = "admin",
                         password = "admin",
@@ -66,7 +66,7 @@
                 @JMSConnectionFactoryDefinition(
                         description = "module-scope resource defined by @JMSConnectionFactoryDefinition",
                         name = "java:module/env/HelloEJB_Annotation_JMSConnectionFactory",
-                        interfaceName = "javax.jms.ConnectionFactory",
+                        interfaceName = "jakarta.jms.ConnectionFactory",
                         resourceAdapter = "jmsra",
                         user = "admin",
                         password = "admin",
@@ -77,7 +77,7 @@
                 @JMSConnectionFactoryDefinition(
                         description = "component-scope resource defined by @JMSConnectionFactoryDefinition",
                         name = "java:comp/env/HelloEJB_Annotation_JMSConnectionFactory",
-                        interfaceName = "javax.jms.ConnectionFactory",
+                        interfaceName = "jakarta.jms.ConnectionFactory",
                         resourceAdapter = "jmsra",
                         user = "admin",
                         password = "admin",
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/jms-connection-factory-definition/ejb/HelloStatefulEJB.java b/appserver/tests/appserv-tests/devtests/connector/v3/jms-connection-factory-definition/ejb/HelloStatefulEJB.java
index 0e3716c..58fea88 100644
--- a/appserver/tests/appserv-tests/devtests/connector/v3/jms-connection-factory-definition/ejb/HelloStatefulEJB.java
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/jms-connection-factory-definition/ejb/HelloStatefulEJB.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -22,10 +22,10 @@
 import javax.annotation.PostConstruct;
 import javax.annotation.PreDestroy;
 import javax.ejb.Stateful;
-import javax.jms.Connection;
-import javax.jms.ConnectionFactory;
-import javax.jms.JMSConnectionFactoryDefinition;
-import javax.jms.JMSConnectionFactoryDefinitions;
+import jakarta.jms.Connection;
+import jakarta.jms.ConnectionFactory;
+import jakarta.jms.JMSConnectionFactoryDefinition;
+import jakarta.jms.JMSConnectionFactoryDefinitions;
 import javax.naming.InitialContext;
 
 @JMSConnectionFactoryDefinitions(
@@ -33,7 +33,7 @@
                 @JMSConnectionFactoryDefinition(
                         description = "global-scope resource defined by @JMSConnectionFactoryDefinition",
                         name = "java:global/env/HelloStatefulEJB_ModByDD_JMSConnectionFactory",
-                        interfaceName = "javax.jms.ConnectionFactory",
+                        interfaceName = "jakarta.jms.ConnectionFactory",
                         resourceAdapter = "jmsra",
                         user = "admin",
                         password = "admin",
@@ -44,7 +44,7 @@
                 @JMSConnectionFactoryDefinition(
                         description = "global-scope resource defined by @JMSConnectionFactoryDefinition",
                         name = "java:global/env/HelloStatefulEJB_Annotation_JMSConnectionFactory",
-                        interfaceName = "javax.jms.ConnectionFactory",
+                        interfaceName = "jakarta.jms.ConnectionFactory",
                         resourceAdapter = "jmsra",
                         user = "admin",
                         password = "admin",
@@ -55,7 +55,7 @@
                 @JMSConnectionFactoryDefinition(
                         description = "application-scope resource defined by @JMSConnectionFactoryDefinition",
                         name = "java:app/env/HelloStatefulEJB_Annotation_JMSConnectionFactory",
-                        interfaceName = "javax.jms.ConnectionFactory",
+                        interfaceName = "jakarta.jms.ConnectionFactory",
                         resourceAdapter = "jmsra",
                         user = "admin",
                         password = "admin",
@@ -66,7 +66,7 @@
                 @JMSConnectionFactoryDefinition(
                         description = "module-scope resource defined by @JMSConnectionFactoryDefinition",
                         name = "java:module/env/HelloStatefulEJB_Annotation_JMSConnectionFactory",
-                        interfaceName = "javax.jms.ConnectionFactory",
+                        interfaceName = "jakarta.jms.ConnectionFactory",
                         resourceAdapter = "jmsra",
                         user = "admin",
                         password = "admin",
@@ -77,7 +77,7 @@
                 @JMSConnectionFactoryDefinition(
                         description = "component-scope resource defined by @JMSConnectionFactoryDefinition",
                         name = "java:comp/env/HelloStatefulEJB_Annotation_JMSConnectionFactory",
-                        interfaceName = "javax.jms.ConnectionFactory",
+                        interfaceName = "jakarta.jms.ConnectionFactory",
                         resourceAdapter = "jmsra",
                         user = "admin",
                         password = "admin",
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/jms-connection-factory-definition/servlet/Servlet.java b/appserver/tests/appserv-tests/devtests/connector/v3/jms-connection-factory-definition/servlet/Servlet.java
index 046eb86..ded7bb0 100644
--- a/appserver/tests/appserv-tests/devtests/connector/v3/jms-connection-factory-definition/servlet/Servlet.java
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/jms-connection-factory-definition/servlet/Servlet.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -24,10 +24,10 @@
 import javax.annotation.Resource;
 import javax.ejb.EJB;
 import javax.ejb.EJBs;
-import javax.jms.Connection;
-import javax.jms.ConnectionFactory;
-import javax.jms.JMSConnectionFactoryDefinition;
-import javax.jms.JMSConnectionFactoryDefinitions;
+import jakarta.jms.Connection;
+import jakarta.jms.ConnectionFactory;
+import jakarta.jms.JMSConnectionFactoryDefinition;
+import jakarta.jms.JMSConnectionFactoryDefinitions;
 import javax.naming.InitialContext;
 import javax.servlet.ServletConfig;
 import javax.servlet.ServletException;
@@ -48,7 +48,7 @@
                 @JMSConnectionFactoryDefinition(
                         description = "global-scope resource defined by @JMSConnectionFactoryDefinition",
                         name = "java:global/env/Servlet_ModByDD_JMSConnectionFactory",
-                        interfaceName = "javax.jms.ConnectionFactory",
+                        interfaceName = "jakarta.jms.ConnectionFactory",
                         resourceAdapter = "jmsra",
                         user = "admin",
                         password = "admin",
@@ -59,7 +59,7 @@
                 @JMSConnectionFactoryDefinition(
                         description = "global-scope resource defined by @JMSConnectionFactoryDefinition",
                         name = "java:global/env/Servlet_JMSConnectionFactory",
-                        interfaceName = "javax.jms.ConnectionFactory",
+                        interfaceName = "jakarta.jms.ConnectionFactory",
                         resourceAdapter = "jmsra",
                         user = "admin",
                         password = "admin",
@@ -70,7 +70,7 @@
                 @JMSConnectionFactoryDefinition(
                         description = "application-scope resource defined by @JMSConnectionFactoryDefinition",
                         name = "java:app/env/Servlet_JMSConnectionFactory",
-                        interfaceName = "javax.jms.ConnectionFactory",
+                        interfaceName = "jakarta.jms.ConnectionFactory",
 //                        resourceAdapter = "jmsra",
                         user = "admin",
                         password = "admin",
@@ -81,7 +81,7 @@
                 @JMSConnectionFactoryDefinition(
                         description = "module-scope resource defined by @JMSConnectionFactoryDefinition",
                         name = "java:module/env/Servlet_JMSConnectionFactory",
-//                        interfaceName = "javax.jms.ConnectionFactory",
+//                        interfaceName = "jakarta.jms.ConnectionFactory",
                         resourceAdapter = "jmsra",
                         user = "admin",
                         password = "admin",
@@ -92,7 +92,7 @@
                 @JMSConnectionFactoryDefinition(
                         description = "component-scope resource defined by @JMSConnectionFactoryDefinition",
                         name = "java:comp/env/Servlet_JMSConnectionFactory",
-//                        interfaceName = "javax.jms.ConnectionFactory",
+//                        interfaceName = "jakarta.jms.ConnectionFactory",
 //                        resourceAdapter = "jmsra",
                         user = "admin",
                         password = "admin",
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/client/Client.java b/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/client/Client.java
index 4107ec8..9c89a71 100644
--- a/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -24,9 +24,9 @@
 import java.net.HttpURLConnection;
 import java.net.URL;
 
-import javax.jms.Destination;
-import javax.jms.JMSDestinationDefinition;
-import javax.jms.JMSDestinationDefinitions;
+import jakarta.jms.Destination;
+import jakarta.jms.JMSDestinationDefinition;
+import jakarta.jms.JMSDestinationDefinitions;
 import javax.naming.InitialContext;
 
 @JMSDestinationDefinitions(
@@ -34,7 +34,7 @@
                 @JMSDestinationDefinition(
                         description = "global-scope resource defined by @JMSDestinationDefinition",
                         name = "java:global/env/Appclient_ModByDD_JMSDestination",
-                        interfaceName = "javax.jms.Queue",
+                        interfaceName = "jakarta.jms.Queue",
                         resourceAdapter = "jmsra",
                         destinationName = "myPhysicalQueue"
                 ),
@@ -42,7 +42,7 @@
                 @JMSDestinationDefinition(
                         description = "global-scope resource defined by @JMSDestinationDefinition",
                         name = "java:global/env/Appclient_Annotation_JMSDestination",
-                        interfaceName = "javax.jms.Queue",
+                        interfaceName = "jakarta.jms.Queue",
                         resourceAdapter = "jmsra",
                         destinationName = "myPhysicalQueue"
                 ),
@@ -50,7 +50,7 @@
                 @JMSDestinationDefinition(
                         description = "application-scope resource defined by @JMSDestinationDefinition",
                         name = "java:app/env/Appclient_Annotation_JMSDestination",
-                        interfaceName = "javax.jms.Topic",
+                        interfaceName = "jakarta.jms.Topic",
                         resourceAdapter = "jmsra",
                         destinationName = "myPhysicalTopic"
                 ),
@@ -58,7 +58,7 @@
                 @JMSDestinationDefinition(
                         description = "module-scope resource defined by @JMSDestinationDefinition",
                         name = "java:module/env/Appclient_Annotation_JMSDestination",
-                        interfaceName = "javax.jms.Topic",
+                        interfaceName = "jakarta.jms.Topic",
                         resourceAdapter = "jmsra",
                         destinationName = "myPhysicalTopic"
                 ),
@@ -66,7 +66,7 @@
                 @JMSDestinationDefinition(
                         description = "component-scope resource defined by @JMSDestinationDefinition",
                         name = "java:comp/env/Appclient_Annotation_JMSDestination",
-                        interfaceName = "javax.jms.Queue",
+                        interfaceName = "jakarta.jms.Queue",
                         resourceAdapter = "jmsra",
                         destinationName = "myPhysicalQueue"
                 )
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/descriptor/application-client.xml b/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/descriptor/application-client.xml
index e7a0fe4..fd57bd8 100644
--- a/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/descriptor/application-client.xml
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/descriptor/application-client.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -26,7 +26,7 @@
     <jms-destination>
         <description>global-scope resource to be modified by Appclient DD</description>
         <name>java:global/env/Appclient_ModByDD_JMSDestination</name>
-        <interface-name>javax.jms.Topic</interface-name>
+        <interface-name>jakarta.jms.Topic</interface-name>
         <resource-adapter>jmsra</resource-adapter>
         <destination-name>myPhysicalTopic</destination-name>
     </jms-destination>
@@ -34,7 +34,7 @@
     <jms-destination>
         <description>global-scope resource defined in Appclient DD</description>
         <name>java:global/env/Appclient_DD_JMSDestination</name>
-        <interface-name>javax.jms.Queue</interface-name>
+        <interface-name>jakarta.jms.Queue</interface-name>
         <resource-adapter>jmsra</resource-adapter>
         <destination-name>myPhysicalQueue</destination-name>
     </jms-destination>
@@ -42,7 +42,7 @@
     <jms-destination>
         <description>application-scope resource defined in Appclient DD</description>
         <name>java:app/env/Appclient_DD_JMSDestination</name>
-        <interface-name>javax.jms.Topic</interface-name>
+        <interface-name>jakarta.jms.Topic</interface-name>
         <resource-adapter>jmsra</resource-adapter>
         <destination-name>myPhysicalTopic</destination-name>
     </jms-destination>
@@ -50,7 +50,7 @@
     <jms-destination>
         <description>module-scope resource defined in Appclient DD</description>
         <name>java:module/env/Appclient_DD_JMSDestination</name>
-        <interface-name>javax.jms.Topic</interface-name>
+        <interface-name>jakarta.jms.Topic</interface-name>
         <resource-adapter>jmsra</resource-adapter>
         <destination-name>myPhysicalTopic</destination-name>
     </jms-destination>
@@ -58,7 +58,7 @@
     <jms-destination>
         <description>component-scope resource defined in Appclient DD</description>
         <name>java:comp/env/Appclient_DD_JMSDestination</name>
-        <interface-name>javax.jms.Queue</interface-name>
+        <interface-name>jakarta.jms.Queue</interface-name>
         <resource-adapter>jmsra</resource-adapter>
         <destination-name>myPhysicalQueue</destination-name>
     </jms-destination>
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/descriptor/application.xml b/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/descriptor/application.xml
index af64a84..39fe68b 100644
--- a/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/descriptor/application.xml
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/descriptor/application.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -38,7 +38,7 @@
     <jms-destination>
         <description>global-scope resource defined in Application DD</description>
         <name>java:global/env/Application_DD_JMSDestination</name>
-        <interface-name>javax.jms.Queue</interface-name>
+        <interface-name>jakarta.jms.Queue</interface-name>
         <resource-adapter>jmsra</resource-adapter>
         <destination-name>myPhysicalQueue</destination-name>
     </jms-destination>
@@ -46,7 +46,7 @@
     <jms-destination>
         <description>application-scope resource defined in Application DD</description>
         <name>java:app/env/Application_DD_JMSDestination</name>
-        <interface-name>javax.jms.Topic</interface-name>
+        <interface-name>jakarta.jms.Topic</interface-name>
         <resource-adapter>jmsra</resource-adapter>
         <destination-name>myPhysicalTopic</destination-name>
     </jms-destination>
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/descriptor/ejb-jar.xml b/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/descriptor/ejb-jar.xml
index 5c30a28..5becdca 100644
--- a/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/descriptor/ejb-jar.xml
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/descriptor/ejb-jar.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8" standalone="no"?>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -34,7 +34,7 @@
             <jms-destination>
                 <description>global-scope resource to be modified by EJB DD</description>
                 <name>java:global/env/HelloStatefulEJB_ModByDD_JMSDestination</name>
-                <interface-name>javax.jms.Topic</interface-name>
+                <interface-name>jakarta.jms.Topic</interface-name>
                 <resource-adapter>jmsra</resource-adapter>
                 <destination-name>myPhysicalTopic</destination-name>
             </jms-destination>
@@ -42,7 +42,7 @@
             <jms-destination>
                 <description>global-scope resource defined in EJB DD</description>
                 <name>java:global/env/HelloStatefulEJB_DD_JMSDestination</name>
-                <interface-name>javax.jms.Queue</interface-name>
+                <interface-name>jakarta.jms.Queue</interface-name>
                 <resource-adapter>jmsra</resource-adapter>
                 <destination-name>myPhysicalQueue</destination-name>
             </jms-destination>
@@ -50,7 +50,7 @@
             <jms-destination>
                 <description>application-scope resource defined in EJB DD</description>
                 <name>java:app/env/HelloStatefulEJB_DD_JMSDestination</name>
-                <interface-name>javax.jms.Topic</interface-name>
+                <interface-name>jakarta.jms.Topic</interface-name>
                 <resource-adapter>jmsra</resource-adapter>
                 <destination-name>myPhysicalTopic</destination-name>
             </jms-destination>
@@ -58,7 +58,7 @@
             <jms-destination>
                 <description>module-scope resource defined in EJB DD</description>
                 <name>java:module/env/HelloStatefulEJB_DD_JMSDestination</name>
-                <interface-name>javax.jms.Topic</interface-name>
+                <interface-name>jakarta.jms.Topic</interface-name>
                 <resource-adapter>jmsra</resource-adapter>
                 <destination-name>myPhysicalTopic</destination-name>
             </jms-destination>
@@ -66,7 +66,7 @@
             <jms-destination>
                 <description>component-scope resource defined in EJB DD</description>
                 <name>java:comp/env/HelloStatefulEJB_DD_JMSDestination</name>
-                <interface-name>javax.jms.Queue</interface-name>
+                <interface-name>jakarta.jms.Queue</interface-name>
                 <resource-adapter>jmsra</resource-adapter>
                 <destination-name>myPhysicalQueue</destination-name>
             </jms-destination>
@@ -82,7 +82,7 @@
             <jms-destination>
                 <description>global-scope resource to be modified by EJB DD</description>
                 <name>java:global/env/HelloEJB_ModByDD_JMSDestination</name>
-                <interface-name>javax.jms.Topic</interface-name>
+                <interface-name>jakarta.jms.Topic</interface-name>
                 <resource-adapter>jmsra</resource-adapter>
                 <destination-name>myPhysicalTopic</destination-name>
             </jms-destination>
@@ -90,7 +90,7 @@
             <jms-destination>
                 <description>global-scope resource defined in EJB DD</description>
                 <name>java:global/env/HelloEJB_DD_JMSDestination</name>
-                <interface-name>javax.jms.Queue</interface-name>
+                <interface-name>jakarta.jms.Queue</interface-name>
                 <resource-adapter>jmsra</resource-adapter>
                 <destination-name>myPhysicalQueue</destination-name>
             </jms-destination>
@@ -98,7 +98,7 @@
             <jms-destination>
                 <description>application-scope resource defined in EJB DD</description>
                 <name>java:app/env/HelloEJB_DD_JMSDestination</name>
-                <interface-name>javax.jms.Topic</interface-name>
+                <interface-name>jakarta.jms.Topic</interface-name>
                 <resource-adapter>jmsra</resource-adapter>
                 <destination-name>myPhysicalTopic</destination-name>
             </jms-destination>
@@ -106,7 +106,7 @@
             <jms-destination>
                 <description>module-scope resource defined in EJB DD</description>
                 <name>java:module/env/HelloEJB_DD_JMSDestination</name>
-                <interface-name>javax.jms.Topic</interface-name>
+                <interface-name>jakarta.jms.Topic</interface-name>
                 <resource-adapter>jmsra</resource-adapter>
                 <destination-name>myPhysicalTopic</destination-name>
             </jms-destination>
@@ -114,7 +114,7 @@
             <jms-destination>
                 <description>component-scope resource defined in EJB DD</description>
                 <name>java:comp/env/HelloEJB_DD_JMSDestination</name>
-                <interface-name>javax.jms.Queue</interface-name>
+                <interface-name>jakarta.jms.Queue</interface-name>
                 <resource-adapter>jmsra</resource-adapter>
                 <destination-name>myPhysicalQueue</destination-name>
             </jms-destination>
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/descriptor/ut-application-client.xml b/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/descriptor/ut-application-client.xml
index 612c1ab..69aba02 100644
--- a/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/descriptor/ut-application-client.xml
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/descriptor/ut-application-client.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -26,7 +26,7 @@
     <jms-destination>
         <description>global-scope jms destination defined in UT Appclient DD</description>
         <name>java:global/env/UT_Appclient_DD_JMSDestination</name>
-        <class-name>javax.jms.Queue</class-name>
+        <class-name>jakarta.jms.Queue</class-name>
         <resource-adapter>jmsra</resource-adapter>
         <destination-name>myPhysicalQueue</destination-name>
     </jms-destination>
@@ -34,7 +34,7 @@
     <jms-destination>
         <description>application-scope jms destination defined in UT Appclient DD</description>
         <name>java:app/env/UT_Appclient_DD_JMSDestination</name>
-        <class-name>javax.jms.Topic</class-name>
+        <class-name>jakarta.jms.Topic</class-name>
         <resource-adapter>jmsra</resource-adapter>
         <destination-name>myPhysicalTopic</destination-name>
     </jms-destination>
@@ -42,7 +42,7 @@
     <jms-destination>
         <description>module-scope jms destination defined in UT Appclient DD</description>
         <name>java:module/env/UT_Appclient_DD_JMSDestination</name>
-        <class-name>javax.jms.Topic</class-name>
+        <class-name>jakarta.jms.Topic</class-name>
         <resource-adapter>jmsra</resource-adapter>
         <destination-name>myPhysicalTopic</destination-name>
     </jms-destination>
@@ -50,7 +50,7 @@
     <jms-destination>
         <description>component-scope jms destination defined in UT Appclient DD</description>
         <name>java:comp/env/UT_Appclient_DD_JMSDestination</name>
-        <class-name>javax.jms.Queue</class-name>
+        <class-name>jakarta.jms.Queue</class-name>
         <resource-adapter>jmsra</resource-adapter>
         <destination-name>myPhysicalQueue</destination-name>
     </jms-destination>
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/descriptor/ut-application.xml b/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/descriptor/ut-application.xml
index 7cb640b..257140f 100644
--- a/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/descriptor/ut-application.xml
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/descriptor/ut-application.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -30,7 +30,7 @@
     <jms-destination>
         <description>global-scope jms destination defined in UT Application DD</description>
         <name>java:global/env/UT_Application_DD_JMSDestination</name>
-        <class-name>javax.jms.Queue</class-name>
+        <class-name>jakarta.jms.Queue</class-name>
         <resource-adapter>jmsra</resource-adapter>
         <destination-name>myPhysicalQueue</destination-name>
     </jms-destination>
@@ -38,7 +38,7 @@
     <jms-destination>
         <description>application-scope jms destination defined in UT Application DD</description>
         <name>java:app/env/UT_Application_DD_JMSDestination</name>
-        <class-name>javax.jms.Topic</class-name>
+        <class-name>jakarta.jms.Topic</class-name>
         <resource-adapter>jmsra</resource-adapter>
         <destination-name>myPhysicalTopic</destination-name>
      </jms-destination>
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/descriptor/ut-entity-ejb-jar.xml b/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/descriptor/ut-entity-ejb-jar.xml
index 7635338..65b7fa4 100644
--- a/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/descriptor/ut-entity-ejb-jar.xml
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/descriptor/ut-entity-ejb-jar.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8" standalone="no"?>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -35,7 +35,7 @@
             <jms-destination>
                 <description>global-scope jms destination defined in UT Entity EJB DD</description>
                 <name>java:global/env/UT_Entity_DD_JMSDestination</name>
-                <class-name>javax.jms.Queue</class-name>
+                <class-name>jakarta.jms.Queue</class-name>
                 <resource-adapter>jmsra</resource-adapter>
                 <destination-name>myPhysicalQueue</destination-name>
             </jms-destination>
@@ -43,7 +43,7 @@
             <jms-destination>
                 <description>application-scope jms destination defined in UT Entity EJB DD</description>
                 <name>java:app/env/UT_Entity_DD_JMSDestination</name>
-                <class-name>javax.jms.Topic</class-name>
+                <class-name>jakarta.jms.Topic</class-name>
                 <resource-adapter>jmsra</resource-adapter>
                 <destination-name>myPhysicalTopic</destination-name>
             </jms-destination>
@@ -51,7 +51,7 @@
             <jms-destination>
                 <description>module-scope jms destination defined in UT Entity EJB DD</description>
                 <name>java:module/env/UT_Entity_DD_JMSDestination</name>
-                <class-name>javax.jms.Topic</class-name>
+                <class-name>jakarta.jms.Topic</class-name>
                 <resource-adapter>jmsra</resource-adapter>
                 <destination-name>myPhysicalTopic</destination-name>
             </jms-destination>
@@ -59,7 +59,7 @@
             <jms-destination>
                 <description>component-scope jms destination defined in UT Entity EJB DD</description>
                 <name>java:comp/env/UT_Entity_DD_JMSDestination</name>
-                <class-name>javax.jms.Queue</class-name>
+                <class-name>jakarta.jms.Queue</class-name>
                 <resource-adapter>jmsra</resource-adapter>
                 <destination-name>myPhysicalQueue</destination-name>
             </jms-destination>
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/descriptor/ut-interceptor-ejb-jar.xml b/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/descriptor/ut-interceptor-ejb-jar.xml
index b168755..73a1d6f 100644
--- a/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/descriptor/ut-interceptor-ejb-jar.xml
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/descriptor/ut-interceptor-ejb-jar.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8" standalone="no"?>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -31,7 +31,7 @@
             <jms-destination>
                 <description>global-scope jms destination defined in UT Interceptor EJB DD</description>
                 <name>java:global/env/UT_Interceptor_DD_JMSDestination</name>
-                <class-name>javax.jms.Queue</class-name>
+                <class-name>jakarta.jms.Queue</class-name>
                 <resource-adapter>jmsra</resource-adapter>
                 <destination-name>myPhysicalQueue</destination-name>
             </jms-destination>
@@ -39,7 +39,7 @@
             <jms-destination>
                 <description>application-scope jms destination defined in UT Interceptor EJB DD</description>
                 <name>java:app/env/UT_Interceptor_DD_JMSDestination</name>
-                <class-name>javax.jms.Topic</class-name>
+                <class-name>jakarta.jms.Topic</class-name>
                 <resource-adapter>jmsra</resource-adapter>
                 <destination-name>myPhysicalTopic</destination-name>
             </jms-destination>
@@ -47,7 +47,7 @@
             <jms-destination>
                 <description>module-scope jms destination defined in UT Interceptor EJB DD</description>
                 <name>java:module/env/UT_Interceptor_DD_JMSDestination</name>
-                <class-name>javax.jms.Topic</class-name>
+                <class-name>jakarta.jms.Topic</class-name>
                 <resource-adapter>jmsra</resource-adapter>
                 <destination-name>myPhysicalTopic</destination-name>
             </jms-destination>
@@ -55,7 +55,7 @@
             <jms-destination>
                 <description>component-scope jms destination defined in UT Interceptor EJB DD</description>
                 <name>java:comp/env/UT_Interceptor_DD_JMSDestination</name>
-                <class-name>javax.jms.Queue</class-name>
+                <class-name>jakarta.jms.Queue</class-name>
                 <resource-adapter>jmsra</resource-adapter>
                 <destination-name>myPhysicalQueue</destination-name>
             </jms-destination>
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/descriptor/ut-mdb-ejb-jar.xml b/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/descriptor/ut-mdb-ejb-jar.xml
index 71e1aed..26a61c8 100644
--- a/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/descriptor/ut-mdb-ejb-jar.xml
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/descriptor/ut-mdb-ejb-jar.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8" standalone="no"?>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -33,7 +33,7 @@
             <jms-destination>
                 <description>global-scope jms destination defined in UT MDB EJB DD</description>
                 <name>java:global/env/UT_MDB_DD_JMSDestination</name>
-                <class-name>javax.jms.Queue</class-name>
+                <class-name>jakarta.jms.Queue</class-name>
                 <resource-adapter>jmsra</resource-adapter>
                 <destination-name>myPhysicalQueue</destination-name>
             </jms-destination>
@@ -41,7 +41,7 @@
             <jms-destination>
                 <description>application-scope jms destination defined in UT MDB EJB DD</description>
                 <name>java:app/env/UT_MDB_DD_JMSDestination</name>
-                <class-name>javax.jms.Topic</class-name>
+                <class-name>jakarta.jms.Topic</class-name>
                 <resource-adapter>jmsra</resource-adapter>
                 <destination-name>myPhysicalTopic</destination-name>
             </jms-destination>
@@ -49,7 +49,7 @@
             <jms-destination>
                 <description>module-scope jms destination defined in UT MDB EJB DD</description>
                 <name>java:module/env/UT_MDB_DD_JMSDestination</name>
-                <class-name>javax.jms.Topic</class-name>
+                <class-name>jakarta.jms.Topic</class-name>
                 <resource-adapter>jmsra</resource-adapter>
                 <destination-name>myPhysicalTopic</destination-name>
             </jms-destination>
@@ -57,7 +57,7 @@
             <jms-destination>
                 <description>component-scope jms destination defined in UT MDB EJB DD</description>
                 <name>java:comp/env/UT_MDB_DD_JMSDestination</name>
-                <class-name>javax.jms.Queue</class-name>
+                <class-name>jakarta.jms.Queue</class-name>
                 <resource-adapter>jmsra</resource-adapter>
                 <destination-name>myPhysicalQueue</destination-name>
             </jms-destination>
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/descriptor/ut-session-ejb-jar.xml b/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/descriptor/ut-session-ejb-jar.xml
index 419f97e..0d38ba1 100644
--- a/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/descriptor/ut-session-ejb-jar.xml
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/descriptor/ut-session-ejb-jar.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8" standalone="no"?>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -34,7 +34,7 @@
             <jms-destination>
                 <description>global-scope jms destination defined in UT Session EJB DD</description>
                 <name>java:global/env/UT_HelloStatefulEJB_DD_JMSDestination</name>
-                <class-name>javax.jms.Queue</class-name>
+                <class-name>jakarta.jms.Queue</class-name>
                 <resource-adapter>jmsra</resource-adapter>
                 <destination-name>myPhysicalQueue</destination-name>
             </jms-destination>
@@ -42,7 +42,7 @@
             <jms-destination>
                 <description>application-scope jms destination defined in UT Session EJB DD</description>
                 <name>java:app/env/UT_HelloStatefulEJB_DD_JMSDestination</name>
-                <class-name>javax.jms.Topic</class-name>
+                <class-name>jakarta.jms.Topic</class-name>
                 <resource-adapter>jmsra</resource-adapter>
                 <destination-name>myPhysicalTopic</destination-name>
             </jms-destination>
@@ -50,7 +50,7 @@
             <jms-destination>
                 <description>module-scope jms destination defined in UT Session EJB DD</description>
                 <name>java:module/env/UT_HelloStatefulEJB_DD_JMSDestination</name>
-                <class-name>javax.jms.Topic</class-name>
+                <class-name>jakarta.jms.Topic</class-name>
                 <resource-adapter>jmsra</resource-adapter>
                 <destination-name>myPhysicalTopic</destination-name>
             </jms-destination>
@@ -58,7 +58,7 @@
             <jms-destination>
                 <description>component-scope jms destination defined in UT Session EJB DD</description>
                 <name>java:comp/env/UT_HelloStatefulEJB_DD_JMSDestination</name>
-                <class-name>javax.jms.Queue</class-name>
+                <class-name>jakarta.jms.Queue</class-name>
                 <resource-adapter>jmsra</resource-adapter>
                 <destination-name>myPhysicalQueue</destination-name>
             </jms-destination>
@@ -74,7 +74,7 @@
             <jms-destination>
                 <description>global-scope jms destination defined in UT Session EJB DD</description>
                 <name>java:global/env/UT_HelloEJB_DD_JMSDestination</name>
-                <class-name>javax.jms.Queue</class-name>
+                <class-name>jakarta.jms.Queue</class-name>
                 <resource-adapter>jmsra</resource-adapter>
                 <destination-name>myPhysicalQueue</destination-name>
             </jms-destination>
@@ -82,7 +82,7 @@
             <jms-destination>
                 <description>application-scope jms destination defined in UT Session EJB DD</description>
                 <name>java:app/env/UT_HelloEJB_DD_JMSDestination</name>
-                <class-name>javax.jms.Topic</class-name>
+                <class-name>jakarta.jms.Topic</class-name>
                 <resource-adapter>jmsra</resource-adapter>
                 <destination-name>myPhysicalTopic</destination-name>
             </jms-destination>
@@ -90,7 +90,7 @@
             <jms-destination>
                 <description>module-scope jms destination defined in UT Session EJB DD</description>
                 <name>java:module/env/UT_HelloEJB_DD_JMSDestination</name>
-                <class-name>javax.jms.Topic</class-name>
+                <class-name>jakarta.jms.Topic</class-name>
                 <resource-adapter>jmsra</resource-adapter>
                 <destination-name>myPhysicalTopic</destination-name>
             </jms-destination>
@@ -98,7 +98,7 @@
             <jms-destination>
                 <description>component-scope jms destination defined in UT Session EJB DD</description>
                 <name>java:comp/env/UT_HelloEJB_DD_JMSDestination</name>
-                <class-name>javax.jms.Queue</class-name>
+                <class-name>jakarta.jms.Queue</class-name>
                 <resource-adapter>jmsra</resource-adapter>
                 <destination-name>myPhysicalQueue</destination-name>
             </jms-destination>
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/descriptor/ut-web.xml b/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/descriptor/ut-web.xml
index c62a2d9..722ae42 100644
--- a/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/descriptor/ut-web.xml
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/descriptor/ut-web.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -38,7 +38,7 @@
     <jms-destination>
         <description>global-scope jms destination defined in UT Web DD</description>
         <name>java:global/env/UT_Web_DD_JMSDestination</name>
-        <class-name>javax.jms.Queue</class-name>
+        <class-name>jakarta.jms.Queue</class-name>
         <resource-adapter>jmsra</resource-adapter>
         <destination-name>myPhysicalQueue</destination-name>
     </jms-destination>
@@ -46,7 +46,7 @@
     <jms-destination>
         <description>application-scope jms destination defined in UT Web DD</description>
         <name>java:app/env/UT_Web_DD_JMSDestination</name>
-        <class-name>javax.jms.Topic</class-name>
+        <class-name>jakarta.jms.Topic</class-name>
         <resource-adapter>jmsra</resource-adapter>
         <destination-name>myPhysicalTopic</destination-name>
     </jms-destination>
@@ -54,7 +54,7 @@
     <jms-destination>
         <description>module-scope jms destination defined in UT Web DD</description>
         <name>java:module/env/UT_Web_DD_JMSDestination</name>
-        <class-name>javax.jms.Topic</class-name>
+        <class-name>jakarta.jms.Topic</class-name>
         <resource-adapter>jmsra</resource-adapter>
         <destination-name>myPhysicalTopic</destination-name>
     </jms-destination>
@@ -62,7 +62,7 @@
     <jms-destination>
         <description>component-scope jms destination defined in UT Web DD</description>
         <name>java:comp/env/UT_Web_DD_JMSDestination</name>
-        <class-name>javax.jms.Queue</class-name>
+        <class-name>jakarta.jms.Queue</class-name>
         <resource-adapter>jmsra</resource-adapter>
         <destination-name>myPhysicalQueue</destination-name>
     </jms-destination>
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/descriptor/web.xml b/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/descriptor/web.xml
index 1ffaf0c..e9d8dd1 100644
--- a/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/descriptor/web.xml
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/descriptor/web.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2018, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -37,7 +37,7 @@
     <jms-destination>
         <description>global-scope resource to be modified by Web DD</description>
         <name>java:global/env/Servlet_ModByDD_JMSDestination</name>
-        <interface-name>javax.jms.Topic</interface-name>
+        <interface-name>jakarta.jms.Topic</interface-name>
         <resource-adapter>jmsra</resource-adapter>
         <destination-name>myPhysicalTopic</destination-name>
     </jms-destination>
@@ -45,7 +45,7 @@
     <jms-destination>
         <description>global-scope resource defined in Web DD</description>
         <name>java:global/env/Web_DD_JMSDestination</name>
-        <interface-name>javax.jms.Queue</interface-name>
+        <interface-name>jakarta.jms.Queue</interface-name>
         <resource-adapter>jmsra</resource-adapter>
         <destination-name>myPhysicalQueue</destination-name>
     </jms-destination>
@@ -53,7 +53,7 @@
     <jms-destination>
         <description>application-scope resource defined in Web DD</description>
         <name>java:app/env/Web_DD_JMSDestination</name>
-        <interface-name>javax.jms.Topic</interface-name>
+        <interface-name>jakarta.jms.Topic</interface-name>
 <!--        <resource-adapter>jmsra</resource-adapter> -->
         <destination-name>myPhysicalTopic</destination-name>
     </jms-destination>
@@ -61,7 +61,7 @@
     <jms-destination>
         <description>module-scope resource defined in Web DD</description>
         <name>java:module/env/Web_DD_JMSDestination</name>
-        <interface-name>javax.jms.Topic</interface-name>
+        <interface-name>jakarta.jms.Topic</interface-name>
         <resource-adapter>jmsra</resource-adapter>
         <destination-name>myPhysicalTopic</destination-name>
     </jms-destination>
@@ -69,7 +69,7 @@
     <jms-destination>
         <description>component-scope resource defined in Web DD</description>
         <name>java:comp/env/Web_DD_JMSDestination</name>
-        <interface-name>javax.jms.Queue</interface-name>
+        <interface-name>jakarta.jms.Queue</interface-name>
         <resource-adapter>jmsra</resource-adapter>
         <destination-name>myPhysicalQueue</destination-name>
     </jms-destination>
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/ejb/HelloEJB.java b/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/ejb/HelloEJB.java
index 79c2cc2..615a1a9 100644
--- a/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/ejb/HelloEJB.java
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/ejb/HelloEJB.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -18,9 +18,9 @@
 
 import javax.annotation.PostConstruct;
 import javax.ejb.Stateless;
-import javax.jms.Destination;
-import javax.jms.JMSDestinationDefinition;
-import javax.jms.JMSDestinationDefinitions;
+import jakarta.jms.Destination;
+import jakarta.jms.JMSDestinationDefinition;
+import jakarta.jms.JMSDestinationDefinitions;
 import javax.naming.InitialContext;
 
 @JMSDestinationDefinitions(
@@ -28,7 +28,7 @@
                 @JMSDestinationDefinition(
                         description = "global-scope resource defined by @JMSDestinationDefinition",
                         name = "java:global/env/HelloEJB_ModByDD_JMSDestination",
-                        interfaceName = "javax.jms.Queue",
+                        interfaceName = "jakarta.jms.Queue",
                         resourceAdapter = "jmsra",
                         destinationName = "myPhysicalQueue"
                 ),
@@ -36,7 +36,7 @@
                 @JMSDestinationDefinition(
                         description = "global-scope resource defined by @JMSDestinationDefinition",
                         name = "java:global/env/HelloEJB_Annotation_JMSDestination",
-                        interfaceName = "javax.jms.Queue",
+                        interfaceName = "jakarta.jms.Queue",
                         resourceAdapter = "jmsra",
                         destinationName = "myPhysicalQueue"
                 ),
@@ -44,7 +44,7 @@
                 @JMSDestinationDefinition(
                         description = "application-scope resource defined by @JMSDestinationDefinition",
                         name = "java:app/env/HelloEJB_Annotation_JMSDestination",
-                        interfaceName = "javax.jms.Topic",
+                        interfaceName = "jakarta.jms.Topic",
                         resourceAdapter = "jmsra",
                         destinationName = "myPhysicalTopic"
                 ),
@@ -52,7 +52,7 @@
                 @JMSDestinationDefinition(
                         description = "module-scope resource defined by @JMSDestinationDefinition",
                         name = "java:module/env/HelloEJB_Annotation_JMSDestination",
-                        interfaceName = "javax.jms.Topic",
+                        interfaceName = "jakarta.jms.Topic",
                         resourceAdapter = "jmsra",
                         destinationName = "myPhysicalTopic"
                 ),
@@ -60,7 +60,7 @@
                 @JMSDestinationDefinition(
                         description = "component-scope resource defined by @JMSDestinationDefinition",
                         name = "java:comp/env/HelloEJB_Annotation_JMSDestination",
-                        interfaceName = "javax.jms.Queue",
+                        interfaceName = "jakarta.jms.Queue",
                         resourceAdapter = "jmsra",
                         destinationName = "myPhysicalQueue"
                 )
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/ejb/HelloStatefulEJB.java b/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/ejb/HelloStatefulEJB.java
index 4d6e2c4..d16ad2b 100644
--- a/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/ejb/HelloStatefulEJB.java
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/ejb/HelloStatefulEJB.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -18,9 +18,9 @@
 
 import javax.annotation.PostConstruct;
 import javax.ejb.Stateful;
-import javax.jms.Destination;
-import javax.jms.JMSDestinationDefinition;
-import javax.jms.JMSDestinationDefinitions;
+import jakarta.jms.Destination;
+import jakarta.jms.JMSDestinationDefinition;
+import jakarta.jms.JMSDestinationDefinitions;
 import javax.naming.InitialContext;
 
 @JMSDestinationDefinitions(
@@ -28,7 +28,7 @@
                 @JMSDestinationDefinition(
                         description = "global-scope resource defined by @JMSDestinationDefinition",
                         name = "java:global/env/HelloStatefulEJB_ModByDD_JMSDestination",
-                        interfaceName = "javax.jms.Queue",
+                        interfaceName = "jakarta.jms.Queue",
                         resourceAdapter = "jmsra",
                         destinationName = "myPhysicalQueue"
                 ),
@@ -36,7 +36,7 @@
                 @JMSDestinationDefinition(
                         description = "global-scope resource defined by @JMSDestinationDefinition",
                         name = "java:global/env/HelloStatefulEJB_Annotation_JMSDestination",
-                        interfaceName = "javax.jms.Queue",
+                        interfaceName = "jakarta.jms.Queue",
                         resourceAdapter = "jmsra",
                         destinationName = "myPhysicalQueue"
                 ),
@@ -44,7 +44,7 @@
                 @JMSDestinationDefinition(
                         description = "application-scope resource defined by @JMSDestinationDefinition",
                         name = "java:app/env/HelloStatefulEJB_Annotation_JMSDestination",
-                        interfaceName = "javax.jms.Topic",
+                        interfaceName = "jakarta.jms.Topic",
                         resourceAdapter = "jmsra",
                         destinationName = "myPhysicalTopic"
                 ),
@@ -52,7 +52,7 @@
                 @JMSDestinationDefinition(
                         description = "module-scope resource defined by @JMSDestinationDefinition",
                         name = "java:module/env/HelloStatefulEJB_Annotation_JMSDestination",
-                        interfaceName = "javax.jms.Topic",
+                        interfaceName = "jakarta.jms.Topic",
                         resourceAdapter = "jmsra",
                         destinationName = "myPhysicalTopic"
                 ),
@@ -60,7 +60,7 @@
                 @JMSDestinationDefinition(
                         description = "component-scope resource defined by @JMSDestinationDefinition",
                         name = "java:comp/env/HelloStatefulEJB_Annotation_JMSDestination",
-                        interfaceName = "javax.jms.Queue",
+                        interfaceName = "jakarta.jms.Queue",
                         resourceAdapter = "jmsra",
                         destinationName = "myPhysicalQueue"
                 )
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/servlet/Servlet.java b/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/servlet/Servlet.java
index efe1c23..775d2c7 100644
--- a/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/servlet/Servlet.java
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/servlet/Servlet.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -22,9 +22,9 @@
 import javax.annotation.Resource;
 import javax.ejb.EJB;
 import javax.ejb.EJBs;
-import javax.jms.Destination;
-import javax.jms.JMSDestinationDefinition;
-import javax.jms.JMSDestinationDefinitions;
+import jakarta.jms.Destination;
+import jakarta.jms.JMSDestinationDefinition;
+import jakarta.jms.JMSDestinationDefinitions;
 import javax.naming.InitialContext;
 import javax.servlet.ServletConfig;
 import javax.servlet.ServletException;
@@ -45,7 +45,7 @@
                 @JMSDestinationDefinition(
                         description = "global-scope resource defined by @JMSDestinationDefinition",
                         name = "java:global/env/Servlet_ModByDD_JMSDestination",
-                        interfaceName = "javax.jms.Queue",
+                        interfaceName = "jakarta.jms.Queue",
                         resourceAdapter = "jmsra",
                         destinationName = "myPhysicalQueue"
                 ),
@@ -53,7 +53,7 @@
                 @JMSDestinationDefinition(
                         description = "global-scope resource defined by @JMSDestinationDefinition",
                         name = "java:global/env/Servlet_JMSDestination",
-                        interfaceName = "javax.jms.Queue",
+                        interfaceName = "jakarta.jms.Queue",
                         resourceAdapter = "jmsra",
                         destinationName = "myPhysicalQueue"
                 ),
@@ -61,7 +61,7 @@
                 @JMSDestinationDefinition(
                         description = "application-scope resource defined by @JMSDestinationDefinition",
                         name = "java:app/env/Servlet_JMSDestination",
-                        interfaceName = "javax.jms.Topic",
+                        interfaceName = "jakarta.jms.Topic",
                         resourceAdapter = "jmsra",
                         destinationName = "myPhysicalTopic"
                 ),
@@ -69,7 +69,7 @@
                 @JMSDestinationDefinition(
                         description = "module-scope resource defined by @JMSDestinationDefinition",
                         name = "java:module/env/Servlet_JMSDestination",
-                        interfaceName = "javax.jms.Topic",
+                        interfaceName = "jakarta.jms.Topic",
 //                        resourceAdapter = "jmsra",
                         destinationName = "myPhysicalTopic"
                 ),
@@ -77,7 +77,7 @@
                 @JMSDestinationDefinition(
                         description = "component-scope resource defined by @JMSDestinationDefinition",
                         name = "java:comp/env/Servlet_JMSDestination",
-                        interfaceName = "javax.jms.Queue",
+                        interfaceName = "jakarta.jms.Queue",
 //                        resourceAdapter = "jmsra",
                         destinationName = "myPhysicalQueue"
                 )
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/ut/ArchiveTest.java b/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/ut/ArchiveTest.java
index 8ae02e6..a34da4f 100644
--- a/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/ut/ArchiveTest.java
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/ut/ArchiveTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2002, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2002, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -82,7 +82,7 @@
         desc = new JMSDestinationDefinitionDescriptor();
         desc.setDescription("global-scope jms destination defined in UT Application DD");
         desc.setName("java:global/env/UT_Application_DD_JMSDestination");
-        desc.setClassName("javax.jms.Queue");
+        desc.setClassName("jakarta.jms.Queue");
         desc.setResourceAdapter("jmsra");
         desc.setDestinationName("myPhysicalQueue");
         expectedJMSDDDs.put(desc.getName(), desc);
@@ -90,7 +90,7 @@
         desc = new JMSDestinationDefinitionDescriptor();
         desc.setDescription("application-scope jms destination defined in UT Application DD");
         desc.setName("java:app/env/UT_Application_DD_JMSDestination");
-        desc.setClassName("javax.jms.Topic");
+        desc.setClassName("jakarta.jms.Topic");
         desc.setResourceAdapter("jmsra");
         desc.setDestinationName("myPhysicalTopic");
         expectedJMSDDDs.put(desc.getName(), desc);
@@ -132,7 +132,7 @@
         desc = new JMSDestinationDefinitionDescriptor();
         desc.setDescription("global-scope resource to be modified by Appclient DD");
         desc.setName("java:global/env/Appclient_ModByDD_JMSDestination");
-        desc.setClassName("javax.jms.Topic");
+        desc.setClassName("jakarta.jms.Topic");
         desc.setResourceAdapter("jmsra");
         desc.setDestinationName("myPhysicalTopic");
         expectedJMSDDDs.put(desc.getName(), desc);
@@ -140,7 +140,7 @@
         desc = new JMSDestinationDefinitionDescriptor();
         desc.setDescription("global-scope resource defined by @JMSDestinationDefinition");
         desc.setName("java:global/env/Appclient_Annotation_JMSDestination");
-        desc.setClassName("javax.jms.Queue");
+        desc.setClassName("jakarta.jms.Queue");
         desc.setResourceAdapter("jmsra");
         desc.setDestinationName("myPhysicalQueue");
         expectedJMSDDDs.put(desc.getName(), desc);
@@ -148,7 +148,7 @@
         desc = new JMSDestinationDefinitionDescriptor();
         desc.setDescription("application-scope resource defined by @JMSDestinationDefinition");
         desc.setName("java:app/env/Appclient_Annotation_JMSDestination");
-        desc.setClassName("javax.jms.Topic");
+        desc.setClassName("jakarta.jms.Topic");
         desc.setResourceAdapter("jmsra");
         desc.setDestinationName("myPhysicalTopic");
         expectedJMSDDDs.put(desc.getName(), desc);
@@ -156,7 +156,7 @@
         desc = new JMSDestinationDefinitionDescriptor();
         desc.setDescription("module-scope resource defined by @JMSDestinationDefinition");
         desc.setName("java:module/env/Appclient_Annotation_JMSDestination");
-        desc.setClassName("javax.jms.Topic");
+        desc.setClassName("jakarta.jms.Topic");
         desc.setResourceAdapter("jmsra");
         desc.setDestinationName("myPhysicalTopic");
         expectedJMSDDDs.put(desc.getName(), desc);
@@ -164,7 +164,7 @@
         desc = new JMSDestinationDefinitionDescriptor();
         desc.setDescription("component-scope resource defined by @JMSDestinationDefinition");
         desc.setName("java:comp/env/Appclient_Annotation_JMSDestination");
-        desc.setClassName("javax.jms.Queue");
+        desc.setClassName("jakarta.jms.Queue");
         desc.setResourceAdapter("jmsra");
         desc.setDestinationName("myPhysicalQueue");
         expectedJMSDDDs.put(desc.getName(), desc);
@@ -172,7 +172,7 @@
         desc = new JMSDestinationDefinitionDescriptor();
         desc.setDescription("global-scope resource defined in Appclient DD");
         desc.setName("java:global/env/Appclient_DD_JMSDestination");
-        desc.setClassName("javax.jms.Queue");
+        desc.setClassName("jakarta.jms.Queue");
         desc.setResourceAdapter("jmsra");
         desc.setDestinationName("myPhysicalQueue");
         expectedJMSDDDs.put(desc.getName(), desc);
@@ -180,7 +180,7 @@
         desc = new JMSDestinationDefinitionDescriptor();
         desc.setDescription("application-scope resource defined in Appclient DD");
         desc.setName("java:app/env/Appclient_DD_JMSDestination");
-        desc.setClassName("javax.jms.Topic");
+        desc.setClassName("jakarta.jms.Topic");
         desc.setResourceAdapter("jmsra");
         desc.setDestinationName("myPhysicalTopic");
         expectedJMSDDDs.put(desc.getName(), desc);
@@ -188,7 +188,7 @@
         desc = new JMSDestinationDefinitionDescriptor();
         desc.setDescription("module-scope resource defined in Appclient DD");
         desc.setName("java:module/env/Appclient_DD_JMSDestination");
-        desc.setClassName("javax.jms.Topic");
+        desc.setClassName("jakarta.jms.Topic");
         desc.setResourceAdapter("jmsra");
         desc.setDestinationName("myPhysicalTopic");
         expectedJMSDDDs.put(desc.getName(), desc);
@@ -196,7 +196,7 @@
         desc = new JMSDestinationDefinitionDescriptor();
         desc.setDescription("component-scope resource defined in Appclient DD");
         desc.setName("java:comp/env/Appclient_DD_JMSDestination");
-        desc.setClassName("javax.jms.Queue");
+        desc.setClassName("jakarta.jms.Queue");
         desc.setResourceAdapter("jmsra");
         desc.setDestinationName("myPhysicalQueue");
         expectedJMSDDDs.put(desc.getName(), desc);
@@ -238,7 +238,7 @@
         desc = new JMSDestinationDefinitionDescriptor();
         desc.setDescription("global-scope resource to be modified by Web DD");
         desc.setName("java:global/env/Servlet_ModByDD_JMSDestination");
-        desc.setClassName("javax.jms.Topic");
+        desc.setClassName("jakarta.jms.Topic");
         desc.setResourceAdapter("jmsra");
         desc.setDestinationName("myPhysicalTopic");
         expectedJMSDDDs.put(desc.getName(), desc);
@@ -246,7 +246,7 @@
         desc = new JMSDestinationDefinitionDescriptor();
         desc.setDescription("global-scope resource defined by @JMSDestinationDefinition");
         desc.setName("java:global/env/Servlet_JMSDestination");
-        desc.setClassName("javax.jms.Queue");
+        desc.setClassName("jakarta.jms.Queue");
         desc.setResourceAdapter("jmsra");
         desc.setDestinationName("myPhysicalQueue");
         expectedJMSDDDs.put(desc.getName(), desc);
@@ -254,7 +254,7 @@
         desc = new JMSDestinationDefinitionDescriptor();
         desc.setDescription("application-scope resource defined by @JMSDestinationDefinition");
         desc.setName("java:app/env/Servlet_JMSDestination");
-        desc.setClassName("javax.jms.Topic");
+        desc.setClassName("jakarta.jms.Topic");
         desc.setResourceAdapter("jmsra");
         desc.setDestinationName("myPhysicalTopic");
         expectedJMSDDDs.put(desc.getName(), desc);
@@ -262,7 +262,7 @@
         desc = new JMSDestinationDefinitionDescriptor();
         desc.setDescription("module-scope resource defined by @JMSDestinationDefinition");
         desc.setName("java:module/env/Servlet_JMSDestination");
-        desc.setClassName("javax.jms.Topic");
+        desc.setClassName("jakarta.jms.Topic");
         desc.setResourceAdapter("jmsra");
         desc.setDestinationName("myPhysicalTopic");
         expectedJMSDDDs.put(desc.getName(), desc);
@@ -270,7 +270,7 @@
         desc = new JMSDestinationDefinitionDescriptor();
         desc.setDescription("component-scope resource defined by @JMSDestinationDefinition");
         desc.setName("java:comp/env/Servlet_JMSDestination");
-        desc.setClassName("javax.jms.Queue");
+        desc.setClassName("jakarta.jms.Queue");
         desc.setResourceAdapter("jmsra");
         desc.setDestinationName("myPhysicalQueue");
         expectedJMSDDDs.put(desc.getName(), desc);
@@ -278,7 +278,7 @@
         desc = new JMSDestinationDefinitionDescriptor();
         desc.setDescription("global-scope resource defined in Web DD");
         desc.setName("java:global/env/Web_DD_JMSDestination");
-        desc.setClassName("javax.jms.Queue");
+        desc.setClassName("jakarta.jms.Queue");
         desc.setResourceAdapter("jmsra");
         desc.setDestinationName("myPhysicalQueue");
         expectedJMSDDDs.put(desc.getName(), desc);
@@ -286,7 +286,7 @@
         desc = new JMSDestinationDefinitionDescriptor();
         desc.setDescription("application-scope resource defined in Web DD");
         desc.setName("java:app/env/Web_DD_JMSDestination");
-        desc.setClassName("javax.jms.Topic");
+        desc.setClassName("jakarta.jms.Topic");
         desc.setResourceAdapter("jmsra");
         desc.setDestinationName("myPhysicalTopic");
         expectedJMSDDDs.put(desc.getName(), desc);
@@ -294,7 +294,7 @@
         desc = new JMSDestinationDefinitionDescriptor();
         desc.setDescription("module-scope resource defined in Web DD");
         desc.setName("java:module/env/Web_DD_JMSDestination");
-        desc.setClassName("javax.jms.Topic");
+        desc.setClassName("jakarta.jms.Topic");
         desc.setResourceAdapter("jmsra");
         desc.setDestinationName("myPhysicalTopic");
         expectedJMSDDDs.put(desc.getName(), desc);
@@ -302,7 +302,7 @@
         desc = new JMSDestinationDefinitionDescriptor();
         desc.setDescription("component-scope resource defined in Web DD");
         desc.setName("java:comp/env/Web_DD_JMSDestination");
-        desc.setClassName("javax.jms.Queue");
+        desc.setClassName("jakarta.jms.Queue");
         desc.setResourceAdapter("jmsra");
         desc.setDestinationName("myPhysicalQueue");
         expectedJMSDDDs.put(desc.getName(), desc);
@@ -350,7 +350,7 @@
             desc = new JMSDestinationDefinitionDescriptor();
             desc.setDescription("global-scope resource to be modified by EJB DD");
             desc.setName("java:global/env/HelloStatefulEJB_ModByDD_JMSDestination");
-            desc.setClassName("javax.jms.Topic");
+            desc.setClassName("jakarta.jms.Topic");
             desc.setResourceAdapter("jmsra");
             desc.setDestinationName("myPhysicalTopic");
             expectedJMSDDDs.put(desc.getName(), desc);
@@ -358,7 +358,7 @@
             desc = new JMSDestinationDefinitionDescriptor();
             desc.setDescription("global-scope resource defined in EJB DD");
             desc.setName("java:global/env/HelloStatefulEJB_DD_JMSDestination");
-            desc.setClassName("javax.jms.Queue");
+            desc.setClassName("jakarta.jms.Queue");
             desc.setResourceAdapter("jmsra");
             desc.setDestinationName("myPhysicalQueue");
             expectedJMSDDDs.put(desc.getName(), desc);
@@ -366,7 +366,7 @@
             desc = new JMSDestinationDefinitionDescriptor();
             desc.setDescription("application-scope resource defined in EJB DD");
             desc.setName("java:app/env/HelloStatefulEJB_DD_JMSDestination");
-            desc.setClassName("javax.jms.Topic");
+            desc.setClassName("jakarta.jms.Topic");
             desc.setResourceAdapter("jmsra");
             desc.setDestinationName("myPhysicalTopic");
             expectedJMSDDDs.put(desc.getName(), desc);
@@ -374,7 +374,7 @@
             desc = new JMSDestinationDefinitionDescriptor();
             desc.setDescription("module-scope resource defined in EJB DD");
             desc.setName("java:module/env/HelloStatefulEJB_DD_JMSDestination");
-            desc.setClassName("javax.jms.Topic");
+            desc.setClassName("jakarta.jms.Topic");
             desc.setResourceAdapter("jmsra");
             desc.setDestinationName("myPhysicalTopic");
             expectedJMSDDDs.put(desc.getName(), desc);
@@ -382,7 +382,7 @@
             desc = new JMSDestinationDefinitionDescriptor();
             desc.setDescription("component-scope resource defined in EJB DD");
             desc.setName("java:comp/env/HelloStatefulEJB_DD_JMSDestination");
-            desc.setClassName("javax.jms.Queue");
+            desc.setClassName("jakarta.jms.Queue");
             desc.setResourceAdapter("jmsra");
             desc.setDestinationName("myPhysicalQueue");
             expectedJMSDDDs.put(desc.getName(), desc);
@@ -393,7 +393,7 @@
             desc = new JMSDestinationDefinitionDescriptor();
             desc.setDescription("global-scope resource to be modified by EJB DD");
             desc.setName("java:global/env/HelloEJB_ModByDD_JMSDestination");
-            desc.setClassName("javax.jms.Topic");
+            desc.setClassName("jakarta.jms.Topic");
             desc.setResourceAdapter("jmsra");
             desc.setDestinationName("myPhysicalTopic");
             expectedJMSDDDs.put(desc.getName(), desc);
@@ -401,7 +401,7 @@
             desc = new JMSDestinationDefinitionDescriptor();
             desc.setDescription("global-scope resource defined in EJB DD");
             desc.setName("java:global/env/HelloEJB_DD_JMSDestination");
-            desc.setClassName("javax.jms.Queue");
+            desc.setClassName("jakarta.jms.Queue");
             desc.setResourceAdapter("jmsra");
             desc.setDestinationName("myPhysicalQueue");
             expectedJMSDDDs.put(desc.getName(), desc);
@@ -409,7 +409,7 @@
             desc = new JMSDestinationDefinitionDescriptor();
             desc.setDescription("application-scope resource defined in EJB DD");
             desc.setName("java:app/env/HelloEJB_DD_JMSDestination");
-            desc.setClassName("javax.jms.Topic");
+            desc.setClassName("jakarta.jms.Topic");
             desc.setResourceAdapter("jmsra");
             desc.setDestinationName("myPhysicalTopic");
             expectedJMSDDDs.put(desc.getName(), desc);
@@ -417,7 +417,7 @@
             desc = new JMSDestinationDefinitionDescriptor();
             desc.setDescription("module-scope resource defined in EJB DD");
             desc.setName("java:module/env/HelloEJB_DD_JMSDestination");
-            desc.setClassName("javax.jms.Topic");
+            desc.setClassName("jakarta.jms.Topic");
             desc.setResourceAdapter("jmsra");
             desc.setDestinationName("myPhysicalTopic");
             expectedJMSDDDs.put(desc.getName(), desc);
@@ -425,7 +425,7 @@
             desc = new JMSDestinationDefinitionDescriptor();
             desc.setDescription("component-scope resource defined in EJB DD");
             desc.setName("java:comp/env/HelloEJB_DD_JMSDestination");
-            desc.setClassName("javax.jms.Queue");
+            desc.setClassName("jakarta.jms.Queue");
             desc.setResourceAdapter("jmsra");
             desc.setDestinationName("myPhysicalQueue");
             expectedJMSDDDs.put(desc.getName(), desc);
@@ -436,7 +436,7 @@
             desc = new JMSDestinationDefinitionDescriptor();
             desc.setDescription("global-scope resource defined by @JMSDestinationDefinition");
             desc.setName("java:global/env/HelloStatefulEJB_Annotation_JMSDestination");
-            desc.setClassName("javax.jms.Queue");
+            desc.setClassName("jakarta.jms.Queue");
             desc.setResourceAdapter("jmsra");
             desc.setDestinationName("myPhysicalQueue");
             expectedJMSDDDs.put(desc.getName(), desc);
@@ -444,7 +444,7 @@
             desc = new JMSDestinationDefinitionDescriptor();
             desc.setDescription("application-scope resource defined by @JMSDestinationDefinition");
             desc.setName("java:app/env/HelloStatefulEJB_Annotation_JMSDestination");
-            desc.setClassName("javax.jms.Topic");
+            desc.setClassName("jakarta.jms.Topic");
             desc.setResourceAdapter("jmsra");
             desc.setDestinationName("myPhysicalTopic");
             expectedJMSDDDs.put(desc.getName(), desc);
@@ -452,7 +452,7 @@
             desc = new JMSDestinationDefinitionDescriptor();
             desc.setDescription("module-scope resource defined by @JMSDestinationDefinition");
             desc.setName("java:module/env/HelloStatefulEJB_Annotation_JMSDestination");
-            desc.setClassName("javax.jms.Topic");
+            desc.setClassName("jakarta.jms.Topic");
             desc.setResourceAdapter("jmsra");
             desc.setDestinationName("myPhysicalTopic");
             expectedJMSDDDs.put(desc.getName(), desc);
@@ -460,7 +460,7 @@
             desc = new JMSDestinationDefinitionDescriptor();
             desc.setDescription("component-scope resource defined by @JMSDestinationDefinition");
             desc.setName("java:comp/env/HelloStatefulEJB_Annotation_JMSDestination");
-            desc.setClassName("javax.jms.Queue");
+            desc.setClassName("jakarta.jms.Queue");
             desc.setResourceAdapter("jmsra");
             desc.setDestinationName("myPhysicalQueue");
             expectedJMSDDDs.put(desc.getName(), desc);
@@ -471,7 +471,7 @@
             desc = new JMSDestinationDefinitionDescriptor();
             desc.setDescription("global-scope resource defined by @JMSDestinationDefinition");
             desc.setName("java:global/env/HelloEJB_Annotation_JMSDestination");
-            desc.setClassName("javax.jms.Queue");
+            desc.setClassName("jakarta.jms.Queue");
             desc.setResourceAdapter("jmsra");
             desc.setDestinationName("myPhysicalQueue");
             expectedJMSDDDs.put(desc.getName(), desc);
@@ -479,7 +479,7 @@
             desc = new JMSDestinationDefinitionDescriptor();
             desc.setDescription("application-scope resource defined by @JMSDestinationDefinition");
             desc.setName("java:app/env/HelloEJB_Annotation_JMSDestination");
-            desc.setClassName("javax.jms.Topic");
+            desc.setClassName("jakarta.jms.Topic");
             desc.setResourceAdapter("jmsra");
             desc.setDestinationName("myPhysicalTopic");
             expectedJMSDDDs.put(desc.getName(), desc);
@@ -487,7 +487,7 @@
             desc = new JMSDestinationDefinitionDescriptor();
             desc.setDescription("module-scope resource defined by @JMSDestinationDefinition");
             desc.setName("java:module/env/HelloEJB_Annotation_JMSDestination");
-            desc.setClassName("javax.jms.Topic");
+            desc.setClassName("jakarta.jms.Topic");
             desc.setResourceAdapter("jmsra");
             desc.setDestinationName("myPhysicalTopic");
             expectedJMSDDDs.put(desc.getName(), desc);
@@ -495,7 +495,7 @@
             desc = new JMSDestinationDefinitionDescriptor();
             desc.setDescription("component-scope resource defined by @JMSDestinationDefinition");
             desc.setName("java:comp/env/HelloEJB_Annotation_JMSDestination");
-            desc.setClassName("javax.jms.Queue");
+            desc.setClassName("jakarta.jms.Queue");
             desc.setResourceAdapter("jmsra");
             desc.setDestinationName("myPhysicalQueue");
             expectedJMSDDDs.put(desc.getName(), desc);
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/ut/DDTest.java b/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/ut/DDTest.java
index 9f44f0c..7d66304 100644
--- a/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/ut/DDTest.java
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/jms-destination-definition/ut/DDTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2002, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2002, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -70,7 +70,7 @@
             desc = new JMSDestinationDefinitionDescriptor();
             desc.setDescription("global-scope jms destination defined in UT Application DD");
             desc.setName("java:global/env/UT_Application_DD_JMSDestination");
-            desc.setClassName("javax.jms.Queue");
+            desc.setClassName("jakarta.jms.Queue");
             desc.setResourceAdapter("jmsra");
             desc.setDestinationName("myPhysicalQueue");
             expectedJMSDDDs.put(desc.getName(), desc);
@@ -78,7 +78,7 @@
             desc = new JMSDestinationDefinitionDescriptor();
             desc.setDescription("application-scope jms destination defined in UT Application DD");
             desc.setName("java:app/env/UT_Application_DD_JMSDestination");
-            desc.setClassName("javax.jms.Topic");
+            desc.setClassName("jakarta.jms.Topic");
             desc.setResourceAdapter("jmsra");
             desc.setDestinationName("myPhysicalTopic");
             expectedJMSDDDs.put(desc.getName(), desc);
@@ -115,7 +115,7 @@
             desc = new JMSDestinationDefinitionDescriptor();
             desc.setDescription("global-scope jms destination defined in UT Appclient DD");
             desc.setName("java:global/env/UT_Appclient_DD_JMSDestination");
-            desc.setClassName("javax.jms.Queue");
+            desc.setClassName("jakarta.jms.Queue");
             desc.setResourceAdapter("jmsra");
             desc.setDestinationName("myPhysicalQueue");
             expectedJMSDDDs.put(desc.getName(), desc);
@@ -123,7 +123,7 @@
             desc = new JMSDestinationDefinitionDescriptor();
             desc.setDescription("application-scope jms destination defined in UT Appclient DD");
             desc.setName("java:app/env/UT_Appclient_DD_JMSDestination");
-            desc.setClassName("javax.jms.Topic");
+            desc.setClassName("jakarta.jms.Topic");
             desc.setResourceAdapter("jmsra");
             desc.setDestinationName("myPhysicalTopic");
             expectedJMSDDDs.put(desc.getName(), desc);
@@ -131,7 +131,7 @@
             desc = new JMSDestinationDefinitionDescriptor();
             desc.setDescription("module-scope jms destination defined in UT Appclient DD");
             desc.setName("java:module/env/UT_Appclient_DD_JMSDestination");
-            desc.setClassName("javax.jms.Topic");
+            desc.setClassName("jakarta.jms.Topic");
             desc.setResourceAdapter("jmsra");
             desc.setDestinationName("myPhysicalTopic");
             expectedJMSDDDs.put(desc.getName(), desc);
@@ -139,7 +139,7 @@
             desc = new JMSDestinationDefinitionDescriptor();
             desc.setDescription("component-scope jms destination defined in UT Appclient DD");
             desc.setName("java:comp/env/UT_Appclient_DD_JMSDestination");
-            desc.setClassName("javax.jms.Queue");
+            desc.setClassName("jakarta.jms.Queue");
             desc.setResourceAdapter("jmsra");
             desc.setDestinationName("myPhysicalQueue");
             expectedJMSDDDs.put(desc.getName(), desc);
@@ -201,7 +201,7 @@
         desc = new JMSDestinationDefinitionDescriptor();
         desc.setDescription("global-scope jms destination defined in UT Session EJB DD");
         desc.setName("java:global/env/UT_HelloStatefulEJB_DD_JMSDestination");
-        desc.setClassName("javax.jms.Queue");
+        desc.setClassName("jakarta.jms.Queue");
         desc.setResourceAdapter("jmsra");
         desc.setDestinationName("myPhysicalQueue");
         expectedJMSDDDs.put(desc.getName(), desc);
@@ -209,7 +209,7 @@
         desc = new JMSDestinationDefinitionDescriptor();
         desc.setDescription("application-scope jms destination defined in UT Session EJB DD");
         desc.setName("java:app/env/UT_HelloStatefulEJB_DD_JMSDestination");
-        desc.setClassName("javax.jms.Topic");
+        desc.setClassName("jakarta.jms.Topic");
         desc.setResourceAdapter("jmsra");
         desc.setDestinationName("myPhysicalTopic");
         expectedJMSDDDs.put(desc.getName(), desc);
@@ -217,7 +217,7 @@
         desc = new JMSDestinationDefinitionDescriptor();
         desc.setDescription("module-scope jms destination defined in UT Session EJB DD");
         desc.setName("java:module/env/UT_HelloStatefulEJB_DD_JMSDestination");
-        desc.setClassName("javax.jms.Topic");
+        desc.setClassName("jakarta.jms.Topic");
         desc.setResourceAdapter("jmsra");
         desc.setDestinationName("myPhysicalTopic");
         expectedJMSDDDs.put(desc.getName(), desc);
@@ -225,7 +225,7 @@
         desc = new JMSDestinationDefinitionDescriptor();
         desc.setDescription("component-scope jms destination defined in UT Session EJB DD");
         desc.setName("java:comp/env/UT_HelloStatefulEJB_DD_JMSDestination");
-        desc.setClassName("javax.jms.Queue");
+        desc.setClassName("jakarta.jms.Queue");
         desc.setResourceAdapter("jmsra");
         desc.setDestinationName("myPhysicalQueue");
         expectedJMSDDDs.put(desc.getName(), desc);
@@ -240,7 +240,7 @@
         desc = new JMSDestinationDefinitionDescriptor();
         desc.setDescription("global-scope jms destination defined in UT Session EJB DD");
         desc.setName("java:global/env/UT_HelloEJB_DD_JMSDestination");
-        desc.setClassName("javax.jms.Queue");
+        desc.setClassName("jakarta.jms.Queue");
         desc.setResourceAdapter("jmsra");
         desc.setDestinationName("myPhysicalQueue");
         expectedJMSDDDs.put(desc.getName(), desc);
@@ -248,7 +248,7 @@
         desc = new JMSDestinationDefinitionDescriptor();
         desc.setDescription("application-scope jms destination defined in UT Session EJB DD");
         desc.setName("java:app/env/UT_HelloEJB_DD_JMSDestination");
-        desc.setClassName("javax.jms.Topic");
+        desc.setClassName("jakarta.jms.Topic");
         desc.setResourceAdapter("jmsra");
         desc.setDestinationName("myPhysicalTopic");
         expectedJMSDDDs.put(desc.getName(), desc);
@@ -256,7 +256,7 @@
         desc = new JMSDestinationDefinitionDescriptor();
         desc.setDescription("module-scope jms destination defined in UT Session EJB DD");
         desc.setName("java:module/env/UT_HelloEJB_DD_JMSDestination");
-        desc.setClassName("javax.jms.Topic");
+        desc.setClassName("jakarta.jms.Topic");
         desc.setResourceAdapter("jmsra");
         desc.setDestinationName("myPhysicalTopic");
         expectedJMSDDDs.put(desc.getName(), desc);
@@ -264,7 +264,7 @@
         desc = new JMSDestinationDefinitionDescriptor();
         desc.setDescription("component-scope jms destination defined in UT Session EJB DD");
         desc.setName("java:comp/env/UT_HelloEJB_DD_JMSDestination");
-        desc.setClassName("javax.jms.Queue");
+        desc.setClassName("jakarta.jms.Queue");
         desc.setResourceAdapter("jmsra");
         desc.setDestinationName("myPhysicalQueue");
         expectedJMSDDDs.put(desc.getName(), desc);
@@ -292,7 +292,7 @@
                 desc = new JMSDestinationDefinitionDescriptor();
                 desc.setDescription("global-scope jms destination defined in UT Entity EJB DD");
                 desc.setName("java:global/env/UT_Entity_DD_JMSDestination");
-                desc.setClassName("javax.jms.Queue");
+                desc.setClassName("jakarta.jms.Queue");
                 desc.setResourceAdapter("jmsra");
                 desc.setDestinationName("myPhysicalQueue");
                 expectedJMSDDDs.put(desc.getName(), desc);
@@ -300,7 +300,7 @@
                 desc = new JMSDestinationDefinitionDescriptor();
                 desc.setDescription("application-scope jms destination defined in UT Entity EJB DD");
                 desc.setName("java:app/env/UT_Entity_DD_JMSDestination");
-                desc.setClassName("javax.jms.Topic");
+                desc.setClassName("jakarta.jms.Topic");
                 desc.setResourceAdapter("jmsra");
                 desc.setDestinationName("myPhysicalTopic");
                 expectedJMSDDDs.put(desc.getName(), desc);
@@ -308,7 +308,7 @@
                 desc = new JMSDestinationDefinitionDescriptor();
                 desc.setDescription("module-scope jms destination defined in UT Entity EJB DD");
                 desc.setName("java:module/env/UT_Entity_DD_JMSDestination");
-                desc.setClassName("javax.jms.Topic");
+                desc.setClassName("jakarta.jms.Topic");
                 desc.setResourceAdapter("jmsra");
                 desc.setDestinationName("myPhysicalTopic");
                 expectedJMSDDDs.put(desc.getName(), desc);
@@ -316,7 +316,7 @@
                 desc = new JMSDestinationDefinitionDescriptor();
                 desc.setDescription("component-scope jms destination defined in UT Entity EJB DD");
                 desc.setName("java:comp/env/UT_Entity_DD_JMSDestination");
-                desc.setClassName("javax.jms.Queue");
+                desc.setClassName("jakarta.jms.Queue");
                 desc.setResourceAdapter("jmsra");
                 desc.setDestinationName("myPhysicalQueue");
                 expectedJMSDDDs.put(desc.getName(), desc);
@@ -356,7 +356,7 @@
                 desc = new JMSDestinationDefinitionDescriptor();
                 desc.setDescription("global-scope jms destination defined in UT MDB EJB DD");
                 desc.setName("java:global/env/UT_MDB_DD_JMSDestination");
-                desc.setClassName("javax.jms.Queue");
+                desc.setClassName("jakarta.jms.Queue");
                 desc.setResourceAdapter("jmsra");
                 desc.setDestinationName("myPhysicalQueue");
                 expectedJMSDDDs.put(desc.getName(), desc);
@@ -364,7 +364,7 @@
                 desc = new JMSDestinationDefinitionDescriptor();
                 desc.setDescription("application-scope jms destination defined in UT MDB EJB DD");
                 desc.setName("java:app/env/UT_MDB_DD_JMSDestination");
-                desc.setClassName("javax.jms.Topic");
+                desc.setClassName("jakarta.jms.Topic");
                 desc.setResourceAdapter("jmsra");
                 desc.setDestinationName("myPhysicalTopic");
                 expectedJMSDDDs.put(desc.getName(), desc);
@@ -372,7 +372,7 @@
                 desc = new JMSDestinationDefinitionDescriptor();
                 desc.setDescription("module-scope jms destination defined in UT MDB EJB DD");
                 desc.setName("java:module/env/UT_MDB_DD_JMSDestination");
-                desc.setClassName("javax.jms.Topic");
+                desc.setClassName("jakarta.jms.Topic");
                 desc.setResourceAdapter("jmsra");
                 desc.setDestinationName("myPhysicalTopic");
                 expectedJMSDDDs.put(desc.getName(), desc);
@@ -380,7 +380,7 @@
                 desc = new JMSDestinationDefinitionDescriptor();
                 desc.setDescription("component-scope jms destination defined in UT MDB EJB DD");
                 desc.setName("java:comp/env/UT_MDB_DD_JMSDestination");
-                desc.setClassName("javax.jms.Queue");
+                desc.setClassName("jakarta.jms.Queue");
                 desc.setResourceAdapter("jmsra");
                 desc.setDestinationName("myPhysicalQueue");
                 expectedJMSDDDs.put(desc.getName(), desc);
@@ -420,7 +420,7 @@
                 desc = new JMSDestinationDefinitionDescriptor();
                 desc.setDescription("global-scope jms destination defined in UT Interceptor EJB DD");
                 desc.setName("java:global/env/UT_Interceptor_DD_JMSDestination");
-                desc.setClassName("javax.jms.Queue");
+                desc.setClassName("jakarta.jms.Queue");
                 desc.setResourceAdapter("jmsra");
                 desc.setDestinationName("myPhysicalQueue");
                 expectedJMSDDDs.put(desc.getName(), desc);
@@ -428,7 +428,7 @@
                 desc = new JMSDestinationDefinitionDescriptor();
                 desc.setDescription("application-scope jms destination defined in UT Interceptor EJB DD");
                 desc.setName("java:app/env/UT_Interceptor_DD_JMSDestination");
-                desc.setClassName("javax.jms.Topic");
+                desc.setClassName("jakarta.jms.Topic");
                 desc.setResourceAdapter("jmsra");
                 desc.setDestinationName("myPhysicalTopic");
                 expectedJMSDDDs.put(desc.getName(), desc);
@@ -436,7 +436,7 @@
                 desc = new JMSDestinationDefinitionDescriptor();
                 desc.setDescription("module-scope jms destination defined in UT Interceptor EJB DD");
                 desc.setName("java:module/env/UT_Interceptor_DD_JMSDestination");
-                desc.setClassName("javax.jms.Topic");
+                desc.setClassName("jakarta.jms.Topic");
                 desc.setResourceAdapter("jmsra");
                 desc.setDestinationName("myPhysicalTopic");
                 expectedJMSDDDs.put(desc.getName(), desc);
@@ -444,7 +444,7 @@
                 desc = new JMSDestinationDefinitionDescriptor();
                 desc.setDescription("component-scope jms destination defined in UT Interceptor EJB DD");
                 desc.setName("java:comp/env/UT_Interceptor_DD_JMSDestination");
-                desc.setClassName("javax.jms.Queue");
+                desc.setClassName("jakarta.jms.Queue");
                 desc.setResourceAdapter("jmsra");
                 desc.setDestinationName("myPhysicalQueue");
                 expectedJMSDDDs.put(desc.getName(), desc);
@@ -483,7 +483,7 @@
             desc = new JMSDestinationDefinitionDescriptor();
             desc.setDescription("global-scope jms destination defined in UT Web DD");
             desc.setName("java:global/env/UT_Web_DD_JMSDestination");
-            desc.setClassName("javax.jms.Queue");
+            desc.setClassName("jakarta.jms.Queue");
             desc.setResourceAdapter("jmsra");
             desc.setDestinationName("myPhysicalQueue");
             expectedJMSDDDs.put(desc.getName(), desc);
@@ -491,7 +491,7 @@
             desc = new JMSDestinationDefinitionDescriptor();
             desc.setDescription("application-scope jms destination defined in UT Web DD");
             desc.setName("java:app/env/UT_Web_DD_JMSDestination");
-            desc.setClassName("javax.jms.Topic");
+            desc.setClassName("jakarta.jms.Topic");
             desc.setResourceAdapter("jmsra");
             desc.setDestinationName("myPhysicalTopic");
             expectedJMSDDDs.put(desc.getName(), desc);
@@ -499,7 +499,7 @@
             desc = new JMSDestinationDefinitionDescriptor();
             desc.setDescription("module-scope jms destination defined in UT Web DD");
             desc.setName("java:module/env/UT_Web_DD_JMSDestination");
-            desc.setClassName("javax.jms.Topic");
+            desc.setClassName("jakarta.jms.Topic");
             desc.setResourceAdapter("jmsra");
             desc.setDestinationName("myPhysicalTopic");
             expectedJMSDDDs.put(desc.getName(), desc);
@@ -507,7 +507,7 @@
             desc = new JMSDestinationDefinitionDescriptor();
             desc.setDescription("component-scope jms destination defined in UT Web DD");
             desc.setName("java:comp/env/UT_Web_DD_JMSDestination");
-            desc.setClassName("javax.jms.Queue");
+            desc.setClassName("jakarta.jms.Queue");
             desc.setResourceAdapter("jmsra");
             desc.setDestinationName("myPhysicalQueue");
             expectedJMSDDDs.put(desc.getName(), desc);
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/multiple-resources-app-module-scoped/app/src/mdb/MyMessageBean.java b/appserver/tests/appserv-tests/devtests/connector/v3/multiple-resources-app-module-scoped/app/src/mdb/MyMessageBean.java
index a5c3e06..d6950b7 100755
--- a/appserver/tests/appserv-tests/devtests/connector/v3/multiple-resources-app-module-scoped/app/src/mdb/MyMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/multiple-resources-app-module-scoped/app/src/mdb/MyMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2001, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,13 +19,11 @@
 import connector.MyMessageListener;
 import javax.ejb.*;
 import javax.naming.*;
-import java.io.*;
-import java.rmi.RemoteException;
 import javax.servlet.*;
 import javax.servlet.http.*;
 import java.sql.*;
 import javax.sql.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.transaction.*;
 
 
@@ -63,7 +61,7 @@
     /**
      * onMessage method, declared as public (but not final or 
      * static), with a return type of void, and with one argument
-     * of type javax.jms.Message.
+     * of type jakarta.jms.Message.
      *
      * Casts the incoming Message to a TextMessage and displays 
      * the text.
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/multiple-resources.xml/app/src/mdb/MyMessageBean.java b/appserver/tests/appserv-tests/devtests/connector/v3/multiple-resources.xml/app/src/mdb/MyMessageBean.java
index a5c3e06..03b61c6 100755
--- a/appserver/tests/appserv-tests/devtests/connector/v3/multiple-resources.xml/app/src/mdb/MyMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/multiple-resources.xml/app/src/mdb/MyMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2001, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,12 +20,11 @@
 import javax.ejb.*;
 import javax.naming.*;
 import java.io.*;
-import java.rmi.RemoteException;
 import javax.servlet.*;
 import javax.servlet.http.*;
 import java.sql.*;
 import javax.sql.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.transaction.*;
 
 
@@ -63,7 +62,7 @@
     /**
      * onMessage method, declared as public (but not final or 
      * static), with a return type of void, and with one argument
-     * of type javax.jms.Message.
+     * of type jakarta.jms.Message.
      *
      * Casts the incoming Message to a TextMessage and displays 
      * the text.
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/osgi-resources-test/META-INF/MANIFEST.MF b/appserver/tests/appserv-tests/devtests/connector/v3/osgi-resources-test/META-INF/MANIFEST.MF
index 58c3363..2ae0b1f 100644
--- a/appserver/tests/appserv-tests/devtests/connector/v3/osgi-resources-test/META-INF/MANIFEST.MF
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/osgi-resources-test/META-INF/MANIFEST.MF
@@ -21,5 +21,5 @@
 Bundle-Version: 3.1.0.SNAPSHOT
 Bundle-Activator: org.glassfish.osgi_resources_test.ResourcesTestActivator
 Bundle-License: https://glassfish.dev.java.net/nonav/public/CDDL+GPL.html
-Import-Package: javax.sql,org.osgi.framework;version="1.5",org.osgi.service.jdbc;version="1.0",org.glassfish.api,org.glassfish.internal.api,org.glassfish.hk2.api,javax.security.auth,org.glassfish.api.admin,org.jvnet.hk2.component,javax.jms
+Import-Package: javax.sql,org.osgi.framework;version="1.5",org.osgi.service.jdbc;version="1.0",org.glassfish.api,org.glassfish.internal.api,org.glassfish.hk2.api,javax.security.auth,org.glassfish.api.admin,org.jvnet.hk2.component,jakarta.jms
 Bundle-DocURL: https://glassfish.dev.java.net
diff --git a/appserver/tests/appserv-tests/devtests/connector/v3/osgi-resources-test/src/main/java/org/glassfish/osgi_resources_test/ResourcesTestActivator.java b/appserver/tests/appserv-tests/devtests/connector/v3/osgi-resources-test/src/main/java/org/glassfish/osgi_resources_test/ResourcesTestActivator.java
index 234c22e..72f367a 100644
--- a/appserver/tests/appserv-tests/devtests/connector/v3/osgi-resources-test/src/main/java/org/glassfish/osgi_resources_test/ResourcesTestActivator.java
+++ b/appserver/tests/appserv-tests/devtests/connector/v3/osgi-resources-test/src/main/java/org/glassfish/osgi_resources_test/ResourcesTestActivator.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2009, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2009, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -140,29 +140,29 @@
 
         testJdbcResources("(jndi-name=jdbc/test-resource-1)", true);
 
-        createJmsResource("jms/osgi.ConnectionFactory", "javax.jms.QueueConnectionFactory");
-        testJmsResources("(jndi-name=jms/osgi.ConnectionFactory)", javax.jms.QueueConnectionFactory.class, false, "-trial-1");
+        createJmsResource("jms/osgi.ConnectionFactory", "jakarta.jms.QueueConnectionFactory");
+        testJmsResources("(jndi-name=jms/osgi.ConnectionFactory)", jakarta.jms.QueueConnectionFactory.class, false, "-trial-1");
         deleteJmsResource("jms/osgi.ConnectionFactory");
         //test it again to avoid stale service references (Refer issue : GLASSFISH-15790)
-        testJmsResources("(jndi-name=jms/osgi.ConnectionFactory)", javax.jms.QueueConnectionFactory.class, true, "-trial-2");
+        testJmsResources("(jndi-name=jms/osgi.ConnectionFactory)", jakarta.jms.QueueConnectionFactory.class, true, "-trial-2");
 
         //test it again to avoid stale service references (Refer issue : GLASSFISH-15790)
-        createJmsResource("jms/osgi.ConnectionFactory", "javax.jms.QueueConnectionFactory");
-        testJmsResources("(jndi-name=jms/osgi.ConnectionFactory)", javax.jms.QueueConnectionFactory.class, false, "-trial-3");
+        createJmsResource("jms/osgi.ConnectionFactory", "jakarta.jms.QueueConnectionFactory");
+        testJmsResources("(jndi-name=jms/osgi.ConnectionFactory)", jakarta.jms.QueueConnectionFactory.class, false, "-trial-3");
         deleteJmsResource("jms/osgi.ConnectionFactory");
-        testJmsResources("(jndi-name=jms/osgi.ConnectionFactory)", javax.jms.QueueConnectionFactory.class, true, "-trial-4");
+        testJmsResources("(jndi-name=jms/osgi.ConnectionFactory)", jakarta.jms.QueueConnectionFactory.class, true, "-trial-4");
 
-        createJmsResource("jms/osgi.Admin.Object", "javax.jms.QueueConnectionFactory");
-        testJmsResources("(jndi-name=jms/osgi.Admin.Object)", javax.jms.QueueConnectionFactory.class, false, "-trial-1");
+        createJmsResource("jms/osgi.Admin.Object", "jakarta.jms.QueueConnectionFactory");
+        testJmsResources("(jndi-name=jms/osgi.Admin.Object)", jakarta.jms.QueueConnectionFactory.class, false, "-trial-1");
         deleteJmsResource("jms/osgi.Admin.Object");
         //test it again to avoid stale service references (Refer issue : GLASSFISH-15790)
-        testJmsResources("(jndi-name=jms/osgi.Admin.Object)", javax.jms.QueueConnectionFactory.class, true, "-trial-2");
+        testJmsResources("(jndi-name=jms/osgi.Admin.Object)", jakarta.jms.QueueConnectionFactory.class, true, "-trial-2");
 
-        createJmsResource("jms/osgi.Admin.Object", "javax.jms.Queue");
-        testJmsResources("(jndi-name=jms/osgi.Admin.Object)", javax.jms.Queue.class, false, "-trial-3");
+        createJmsResource("jms/osgi.Admin.Object", "jakarta.jms.Queue");
+        testJmsResources("(jndi-name=jms/osgi.Admin.Object)", jakarta.jms.Queue.class, false, "-trial-3");
         deleteJmsResource("jms/osgi.Admin.Object");
         //test it again to avoid stale service references (Refer issue : GLASSFISH-15790)
-        testJmsResources("(jndi-name=jms/osgi.Admin.Object)", javax.jms.Queue.class, true, "-trial-4");
+        testJmsResources("(jndi-name=jms/osgi.Admin.Object)", jakarta.jms.Queue.class, true, "-trial-4");
     }
 
     private void setAttribute(String nameValue) {
diff --git a/appserver/tests/appserv-tests/devtests/deployment/dol/validation/car/META-INF/application-client.xml b/appserver/tests/appserv-tests/devtests/deployment/dol/validation/car/META-INF/application-client.xml
index 7ced6d5..f83cdb2 100644
--- a/appserver/tests/appserv-tests/devtests/deployment/dol/validation/car/META-INF/application-client.xml
+++ b/appserver/tests/appserv-tests/devtests/deployment/dol/validation/car/META-INF/application-client.xml
@@ -2,7 +2,7 @@
 <!DOCTYPE application-client PUBLIC '-//Sun Microsystems, Inc.//DTD J2EE Application Client 1.3//EN' 'http://java.sun.com/dtd/application-client_1_3.dtd'>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -41,14 +41,14 @@
   <resource-ref>
     <description>jms resource ref</description>
     <res-ref-name>jms/QCFactory</res-ref-name>
-    <res-type>javax.jms.QueueConnectionFactory</res-type>
+    <res-type>jakarta.jms.QueueConnectionFactory</res-type>
     <res-auth>Container</res-auth>
     <res-sharing-scope>Shareable</res-sharing-scope>
   </resource-ref>
   <resource-env-ref>
     <description>jms resource env ref</description>
     <resource-env-ref-name>jms/SampleQueue</resource-env-ref-name>
-    <resource-env-ref-type>javax.jms.Queue</resource-env-ref-type>
+    <resource-env-ref-type>jakarta.jms.Queue</resource-env-ref-type>
   </resource-env-ref>
   <callback-handler>fooHandler</callback-handler>
 </application-client>
diff --git a/appserver/tests/appserv-tests/devtests/deployment/dol/validation/ear/car/META-INF/application-client.xml b/appserver/tests/appserv-tests/devtests/deployment/dol/validation/ear/car/META-INF/application-client.xml
index 803701a..799526c 100644
--- a/appserver/tests/appserv-tests/devtests/deployment/dol/validation/ear/car/META-INF/application-client.xml
+++ b/appserver/tests/appserv-tests/devtests/deployment/dol/validation/ear/car/META-INF/application-client.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -129,20 +129,20 @@
   <resource-ref>
     <description>jms resource ref</description>
     <res-ref-name>jms/QCFactory</res-ref-name>
-    <res-type>javax.jms.QueueConnectionFactory</res-type>
+    <res-type>jakarta.jms.QueueConnectionFactory</res-type>
     <res-auth>Container</res-auth>
     <res-sharing-scope>Shareable</res-sharing-scope>
   </resource-ref>
   <resource-env-ref>
     <description>jms resource env ref</description>
     <resource-env-ref-name>jms/SampleQueue</resource-env-ref-name>
-    <resource-env-ref-type>javax.jms.Queue</resource-env-ref-type>
+    <resource-env-ref-type>jakarta.jms.Queue</resource-env-ref-type>
   </resource-env-ref>
   <message-destination-ref>
      <description>test destination</description>
      <message-destination-ref-name>jms/topic_bmt
      </message-destination-ref-name>
-     <message-destination-type>javax.jms.Topic</message-destination-type>
+     <message-destination-type>jakarta.jms.Topic</message-destination-type>
      <message-destination-usage>Produces</message-destination-usage>
      <message-destination-link>topic_cmt</message-destination-link>
   </message-destination-ref>
diff --git a/appserver/tests/appserv-tests/devtests/deployment/dol/validation/ear/ejb/META-INF/ejb-jar.xml b/appserver/tests/appserv-tests/devtests/deployment/dol/validation/ear/ejb/META-INF/ejb-jar.xml
index 6a99d2f..f164ad2 100644
--- a/appserver/tests/appserv-tests/devtests/deployment/dol/validation/ear/ejb/META-INF/ejb-jar.xml
+++ b/appserver/tests/appserv-tests/devtests/deployment/dol/validation/ear/ejb/META-INF/ejb-jar.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -101,20 +101,20 @@
      <resource-ref>
       <description>jms resource ref</description>
       <res-ref-name>jms/opc/QueueConnectionFactory</res-ref-name>
-      <res-type>javax.jms.QueueConnectionFactory</res-type>
+      <res-type>jakarta.jms.QueueConnectionFactory</res-type>
       <res-auth>Container</res-auth>
       <res-sharing-scope>Shareable</res-sharing-scope>
      </resource-ref>
      <resource-env-ref>
       <description>jms resource env ref</description>
        <resource-env-ref-name>jms/opc/WorkFlowMgrQueue</resource-env-ref-name>
-       <resource-env-ref-type>javax.jms.Queue</resource-env-ref-type>
+       <resource-env-ref-type>jakarta.jms.Queue</resource-env-ref-type>
       </resource-env-ref>
       <message-destination-ref>
         <description>test destination</description>
         <message-destination-ref-name>jms/MyQueue
         </message-destination-ref-name>
-        <message-destination-type>javax.jms.Queue</message-destination-type>
+        <message-destination-type>jakarta.jms.Queue</message-destination-type>
         <message-destination-usage>Consumes</message-destination-usage>
         <message-destination-link>MsgBeanOutQueue</message-destination-link>
       </message-destination-ref>
@@ -179,19 +179,19 @@
      </ejb-local-ref>
      <resource-ref>
       <res-ref-name>jms/opc/QueueConnectionFactory</res-ref-name>
-      <res-type>javax.jms.QueueConnectionFactory</res-type>
+      <res-type>jakarta.jms.QueueConnectionFactory</res-type>
       <res-auth>Container</res-auth>
      <res-sharing-scope>Shareable</res-sharing-scope>
      </resource-ref>
      <resource-env-ref>
        <resource-env-ref-name>jms/opc/WorkFlowMgrQueue</resource-env-ref-name>
-       <resource-env-ref-type>javax.jms.Queue</resource-env-ref-type>
+       <resource-env-ref-type>jakarta.jms.Queue</resource-env-ref-type>
       </resource-env-ref>
       <message-destination-ref>
         <description>test destination</description>
         <message-destination-ref-name>jms/MyQueue
         </message-destination-ref-name>
-        <message-destination-type>javax.jms.Queue</message-destination-type>
+        <message-destination-type>jakarta.jms.Queue</message-destination-type>
         <message-destination-usage>Consumes</message-destination-usage>
         <message-destination-link>MsgBeanOutQueue</message-destination-link>
       </message-destination-ref>
@@ -264,9 +264,9 @@
       </icon>
       <ejb-name>SimpleMessageEJB</ejb-name>
       <ejb-class>com.sun.s1peqe.ejb.mdb.simple.ejb.SimpleMessageBean</ejb-class>
-      <messaging-type>javax.jms.MessageListener</messaging-type>
+      <messaging-type>jakarta.jms.MessageListener</messaging-type>
       <transaction-type>Bean</transaction-type>
-      <message-destination-type>javax.jms.Queue</message-destination-type>
+      <message-destination-type>jakarta.jms.Queue</message-destination-type>
       <message-destination-link>MsgBeanInQueue</message-destination-link>
       <activation-config>
         <activation-config-property>
@@ -306,23 +306,23 @@
       </ejb-local-ref>
       <resource-ref>
         <res-ref-name>jms/opc/QueueConnectionFactory</res-ref-name>
-        <res-type>javax.jms.QueueConnectionFactory</res-type>
+        <res-type>jakarta.jms.QueueConnectionFactory</res-type>
         <res-auth>Container</res-auth>
         <res-sharing-scope>Shareable</res-sharing-scope>
       </resource-ref>
       <resource-env-ref>
          <resource-env-ref-name>jms/opc/OrderFillerQueue</resource-env-ref-name>
-         <resource-env-ref-type>javax.jms.Queue</resource-env-ref-type>
+         <resource-env-ref-type>jakarta.jms.Queue</resource-env-ref-type>
       </resource-env-ref>
       <resource-env-ref>
          <resource-env-ref-name>jms/opc/CRMQueue</resource-env-ref-name>
-         <resource-env-ref-type>javax.jms.Queue</resource-env-ref-type>
+         <resource-env-ref-type>jakarta.jms.Queue</resource-env-ref-type>
       </resource-env-ref>
       <message-destination-ref>
         <description>test destination</description>
         <message-destination-ref-name>jms/MyQueue
         </message-destination-ref-name>
-        <message-destination-type>javax.jms.Queue</message-destination-type>
+        <message-destination-type>jakarta.jms.Queue</message-destination-type>
         <message-destination-usage>Consumes</message-destination-usage>
         <message-destination-link>MsgBeanOutQueue</message-destination-link>
       </message-destination-ref>
diff --git a/appserver/tests/appserv-tests/devtests/deployment/dol/validation/ear/war/WEB-INF/web.xml b/appserver/tests/appserv-tests/devtests/deployment/dol/validation/ear/war/WEB-INF/web.xml
index 7fc3575..a0e0306 100644
--- a/appserver/tests/appserv-tests/devtests/deployment/dol/validation/ear/war/WEB-INF/web.xml
+++ b/appserver/tests/appserv-tests/devtests/deployment/dol/validation/ear/war/WEB-INF/web.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -233,7 +233,7 @@
   <resource-env-ref>
     <description>resource env ref</description>
     <resource-env-ref-name>jms/opc/InvoiceTopic</resource-env-ref-name>
-    <resource-env-ref-type>javax.jms.Topic</resource-env-ref-type>
+    <resource-env-ref-type>jakarta.jms.Topic</resource-env-ref-type>
   </resource-env-ref>
   <resource-ref>
     <description>resource ref</description>
@@ -246,7 +246,7 @@
      <description>intra-war destination</description>
      <message-destination-ref-name>jms/MyQueue
      </message-destination-ref-name>
-     <message-destination-type>javax.jms.Queue</message-destination-type>
+     <message-destination-type>jakarta.jms.Queue</message-destination-type>
      <message-destination-usage>ConsumesProduces</message-destination-usage>
      <message-destination-link>WebQueue</message-destination-link>
   </message-destination-ref>
diff --git a/appserver/tests/appserv-tests/devtests/deployment/dol/validation/ejb/META-INF/ejb-jar.xml b/appserver/tests/appserv-tests/devtests/deployment/dol/validation/ejb/META-INF/ejb-jar.xml
index a5ea45d..42e76b5 100644
--- a/appserver/tests/appserv-tests/devtests/deployment/dol/validation/ejb/META-INF/ejb-jar.xml
+++ b/appserver/tests/appserv-tests/devtests/deployment/dol/validation/ejb/META-INF/ejb-jar.xml
@@ -2,7 +2,7 @@
 <!DOCTYPE ejb-jar PUBLIC '-//Sun Microsystems, Inc.//DTD Enterprise JavaBeans 2.0//EN' 'http://java.sun.com/dtd/ejb-jar_2_0.dtd'>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -66,14 +66,14 @@
      <resource-ref>
       <description>jms resource ref</description>
       <res-ref-name>jms/opc/QueueConnectionFactory</res-ref-name>
-      <res-type>javax.jms.QueueConnectionFactory</res-type>
+      <res-type>jakarta.jms.QueueConnectionFactory</res-type>
       <res-auth>Container</res-auth>
       <res-sharing-scope>Shareable</res-sharing-scope>
      </resource-ref>
      <resource-env-ref>
       <description>jms resource env ref</description>
        <resource-env-ref-name>jms/opc/WorkFlowMgrQueue</resource-env-ref-name>
-       <resource-env-ref-type>javax.jms.Queue</resource-env-ref-type>
+       <resource-env-ref-type>jakarta.jms.Queue</resource-env-ref-type>
       </resource-env-ref>
     </session>
     <entity>
@@ -135,13 +135,13 @@
       </security-identity>
      <resource-ref>
       <res-ref-name>jms/opc/QueueConnectionFactory</res-ref-name>
-      <res-type>javax.jms.QueueConnectionFactory</res-type>
+      <res-type>jakarta.jms.QueueConnectionFactory</res-type>
       <res-auth>Container</res-auth>
       <res-sharing-scope>Shareable</res-sharing-scope>
      </resource-ref>
      <resource-env-ref>
        <resource-env-ref-name>jms/opc/WorkFlowMgrQueue</resource-env-ref-name>
-       <resource-env-ref-type>javax.jms.Queue</resource-env-ref-type>
+       <resource-env-ref-type>jakarta.jms.Queue</resource-env-ref-type>
       </resource-env-ref>
       <query>
         <description>find all query</description>
@@ -203,7 +203,7 @@
       </message-selector>
       <acknowledge-mode>Auto-acknowledge</acknowledge-mode>
       <message-driven-destination>
-        <destination-type>javax.jms.Queue</destination-type>
+        <destination-type>jakarta.jms.Queue</destination-type>
         <subscription-durability>Durable</subscription-durability>
       </message-driven-destination>
       <env-entry>
@@ -223,17 +223,17 @@
       </security-identity>
       <resource-ref>
         <res-ref-name>jms/opc/QueueConnectionFactory</res-ref-name>
-        <res-type>javax.jms.QueueConnectionFactory</res-type>
+        <res-type>jakarta.jms.QueueConnectionFactory</res-type>
         <res-auth>Container</res-auth>
         <res-sharing-scope>Shareable</res-sharing-scope>
       </resource-ref>
       <resource-env-ref>
          <resource-env-ref-name>jms/opc/OrderFillerQueue</resource-env-ref-name>
-         <resource-env-ref-type>javax.jms.Queue</resource-env-ref-type>
+         <resource-env-ref-type>jakarta.jms.Queue</resource-env-ref-type>
       </resource-env-ref>
       <resource-env-ref>
          <resource-env-ref-name>jms/opc/CRMQueue</resource-env-ref-name>
-         <resource-env-ref-type>javax.jms.Queue</resource-env-ref-type>
+         <resource-env-ref-type>jakarta.jms.Queue</resource-env-ref-type>
       </resource-env-ref>
     </message-driven>
   </enterprise-beans>
diff --git a/appserver/tests/appserv-tests/devtests/deployment/dol/validation/war/WEB-INF/web.xml b/appserver/tests/appserv-tests/devtests/deployment/dol/validation/war/WEB-INF/web.xml
index 80d4dfe..f44b074 100644
--- a/appserver/tests/appserv-tests/devtests/deployment/dol/validation/war/WEB-INF/web.xml
+++ b/appserver/tests/appserv-tests/devtests/deployment/dol/validation/war/WEB-INF/web.xml
@@ -2,7 +2,7 @@
 <!DOCTYPE web-app PUBLIC '-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN' 'http://java.sun.com/j2ee/dtds/web-app_2_3.dtd'>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -118,7 +118,7 @@
   <resource-env-ref>
     <description>resource env ref</description>
     <resource-env-ref-name>jms/opc/InvoiceTopic</resource-env-ref-name>
-    <resource-env-ref-type>javax.jms.Topic</resource-env-ref-type>
+    <resource-env-ref-type>jakarta.jms.Topic</resource-env-ref-type>
   </resource-env-ref>
   <resource-ref>
     <description>resource ref</description>
diff --git a/appserver/tests/appserv-tests/devtests/deployment/ejb30/ear/mdb/webclient/build.xml b/appserver/tests/appserv-tests/devtests/deployment/ejb30/ear/mdb/webclient/build.xml
index 8de5757..ccfbe21 100644
--- a/appserver/tests/appserv-tests/devtests/deployment/ejb30/ear/mdb/webclient/build.xml
+++ b/appserver/tests/appserv-tests/devtests/deployment/ejb30/ear/mdb/webclient/build.xml
@@ -2,7 +2,7 @@
 <!DOCTYPE project [
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -129,19 +129,19 @@
 
     <target name="deploy.jms.queues" depends="prepare">
         <antcall target="common.create.jms.connection">
-            <param name="jms.factory.type" value="javax.jms.QueueConnectionFactory"/>
+            <param name="jms.factory.type" value="jakarta.jms.QueueConnectionFactory"/>
             <param name="jms.factory.name" value="jms/ejb_ejb30_hello_mdb_QCF"/>           
         </antcall>
         <antcall target="common.create.jms.resource">
             <param name="dest.type" value="queue"/>
             <param name="dest.name" value="ejb_ejb30_hello_mdb_InQueue"/>
-            <param name="res.type" value="javax.jms.Queue"/>
+            <param name="res.type" value="jakarta.jms.Queue"/>
             <param name="jms.resource.name" value="jms/ejb_ejb30_hello_mdb_InQueue"/>  
         </antcall>
         <antcall target="common.create.jms.resource">
             <param name="dest.type" value="queue"/>
             <param name="dest.name" value="ejb_ejb30_hello_mdb_OutQueue"/>
-            <param name="res.type" value="javax.jms.Queue"/>
+            <param name="res.type" value="jakarta.jms.Queue"/>
             <param name="jms.resource.name" value="jms/ejb_ejb30_hello_mdb_OutQueue"/>     
         </antcall>
     </target>
diff --git a/appserver/tests/appserv-tests/devtests/deployment/ejb30/ear/mdb/webclient/ejb/MessageBean.java b/appserver/tests/appserv-tests/devtests/deployment/ejb30/ear/mdb/webclient/ejb/MessageBean.java
index b09135b..1a51798 100644
--- a/appserver/tests/appserv-tests/devtests/deployment/ejb30/ear/mdb/webclient/ejb/MessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/deployment/ejb30/ear/mdb/webclient/ejb/MessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -23,20 +23,20 @@
 import javax.ejb.TransactionManagementType;
 import javax.ejb.ActivationConfigProperty;
 
-import javax.jms.MessageListener;
-import javax.jms.Message;
-import javax.jms.Queue;
-import javax.jms.QueueConnectionFactory;
-import javax.jms.QueueConnection;
-import javax.jms.QueueSession;
-import javax.jms.QueueSender;
-import javax.jms.TextMessage;
-import javax.jms.Session;
+import jakarta.jms.MessageListener;
+import jakarta.jms.Message;
+import jakarta.jms.Queue;
+import jakarta.jms.QueueConnectionFactory;
+import jakarta.jms.QueueConnection;
+import jakarta.jms.QueueSession;
+import jakarta.jms.QueueSender;
+import jakarta.jms.TextMessage;
+import jakarta.jms.Session;
 
 import javax.annotation.Resource;
 
 @TransactionManagement(TransactionManagementType.BEAN)
-@MessageDriven(activationConfig={ @ActivationConfigProperty(propertyName="destinationType", propertyValue="javax.jms.Queue") })
+@MessageDriven(activationConfig={ @ActivationConfigProperty(propertyName="destinationType", propertyValue="jakarta.jms.Queue") })
  public class MessageBean implements MessageListener {
 
     @EJB private Hello1 hello1;
diff --git a/appserver/tests/appserv-tests/devtests/deployment/ejb30/ear/mdb/webclient/servlet/Servlet.java b/appserver/tests/appserv-tests/devtests/deployment/ejb30/ear/mdb/webclient/servlet/Servlet.java
index 1cffb17..6a14010 100644
--- a/appserver/tests/appserv-tests/devtests/deployment/ejb30/ear/mdb/webclient/servlet/Servlet.java
+++ b/appserver/tests/appserv-tests/devtests/deployment/ejb30/ear/mdb/webclient/servlet/Servlet.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2005, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2005, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,7 +19,7 @@
 import java.io.*;
 import javax.servlet.*;
 import javax.servlet.http.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.annotation.Resource;
 
 public class Servlet extends HttpServlet {
@@ -28,10 +28,10 @@
     private QueueConnectionFactory queueConFactory;
     
     @Resource(name="MsgBeanQueue") 
-    private javax.jms.Queue msgBeanQueue;
+    private jakarta.jms.Queue msgBeanQueue;
     
     @Resource(name="ClientQueue")
-    private javax.jms.Queue clientQueue;
+    private jakarta.jms.Queue clientQueue;
     
     private QueueConnection queueCon;
     private QueueSession queueSession;
@@ -50,7 +50,7 @@
         log("init()...");
     }
 
-    public void sendMsgs(javax.jms.Queue queue, Message msg, int num) throws JMSException {
+    public void sendMsgs(jakarta.jms.Queue queue, Message msg, int num) throws JMSException {
         for(int i = 0; i < num; i++) {
             System.out.println("Sending message " + i + " to " + queue +
                                " at time " + System.currentTimeMillis());
@@ -94,7 +94,7 @@
 
             message.setBooleanProperty("flag", true);
             message.setIntProperty("num", 1);
-            sendMsgs((javax.jms.Queue) dest, message, numMessages);
+            sendMsgs((jakarta.jms.Queue) dest, message, numMessages);
 
             log("Waiting for queue message");
             Message recvdmessage = queueReceiver.receive(TIMEOUT);
diff --git a/appserver/tests/appserv-tests/devtests/deployment/ejb31/jndivalidation/ConflitedResourceEnvRef/ejbModule/META-INF/ejb-jar.xml b/appserver/tests/appserv-tests/devtests/deployment/ejb31/jndivalidation/ConflitedResourceEnvRef/ejbModule/META-INF/ejb-jar.xml
index 51a9fb7..58d4616 100644
--- a/appserver/tests/appserv-tests/devtests/deployment/ejb31/jndivalidation/ConflitedResourceEnvRef/ejbModule/META-INF/ejb-jar.xml
+++ b/appserver/tests/appserv-tests/devtests/deployment/ejb31/jndivalidation/ConflitedResourceEnvRef/ejbModule/META-INF/ejb-jar.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -29,7 +29,7 @@
 
 			<resource-env-ref>
 				<resource-env-ref-name>java:module/env/DupResourceEnvRef</resource-env-ref-name>
-				<resource-env-ref-type>javax.jms.Topic</resource-env-ref-type>
+				<resource-env-ref-type>jakarta.jms.Topic</resource-env-ref-type>
 			</resource-env-ref>
 		</session>
 		
@@ -39,7 +39,7 @@
 			<session-type>Stateless</session-type>
 			<resource-env-ref>
 				<resource-env-ref-name>java:module/env/DupResourceEnvRef</resource-env-ref-name>
-				<resource-env-ref-type>javax.jms.Queue</resource-env-ref-type>
+				<resource-env-ref-type>jakarta.jms.Queue</resource-env-ref-type>
 			</resource-env-ref>
 		</session>
 	</enterprise-beans>
diff --git a/appserver/tests/appserv-tests/devtests/deployment/ejb31/jndivalidation/ResourceRef/CorrectQueueRes/META-INF/ejb-jar.xml b/appserver/tests/appserv-tests/devtests/deployment/ejb31/jndivalidation/ResourceRef/CorrectQueueRes/META-INF/ejb-jar.xml
index e7bed77..61d0fac 100644
--- a/appserver/tests/appserv-tests/devtests/deployment/ejb31/jndivalidation/ResourceRef/CorrectQueueRes/META-INF/ejb-jar.xml
+++ b/appserver/tests/appserv-tests/devtests/deployment/ejb31/jndivalidation/ResourceRef/CorrectQueueRes/META-INF/ejb-jar.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -28,7 +28,7 @@
 			<session-type>Stateless</session-type>
 			<message-destination-ref>
 				<message-destination-ref-name>jms/MyQueue</message-destination-ref-name>
-				<message-destination-type>javax.jms.Queue</message-destination-type>
+				<message-destination-type>jakarta.jms.Queue</message-destination-type>
 				<message-destination-usage>Produces</message-destination-usage>
 				<message-destination-link>MyQueueLink</message-destination-link>
 			</message-destination-ref>
diff --git a/appserver/tests/appserv-tests/devtests/deployment/ejb31/jndivalidation/ResourceRef/CorrectQueueRes/build.xml b/appserver/tests/appserv-tests/devtests/deployment/ejb31/jndivalidation/ResourceRef/CorrectQueueRes/build.xml
index aeddcbc..233fc84 100644
--- a/appserver/tests/appserv-tests/devtests/deployment/ejb31/jndivalidation/ResourceRef/CorrectQueueRes/build.xml
+++ b/appserver/tests/appserv-tests/devtests/deployment/ejb31/jndivalidation/ResourceRef/CorrectQueueRes/build.xml
@@ -2,7 +2,7 @@
 <!DOCTYPE project [
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -52,7 +52,7 @@
         <antcall target="common.create.jms.resource">
             <param name="dest.type" value="queue"/>
             <param name="dest.name" value="deployment_jndivalidation_queue"/>
-            <param name="res.type" value="javax.jms.Queue"/>
+            <param name="res.type" value="jakarta.jms.Queue"/>
             <param name="jms.resource.name" value="jms/deployment_jndivalidation_queue"/>
         </antcall>
     </target>
diff --git a/appserver/tests/appserv-tests/devtests/deployment/ejb31/jndivalidation/ResourceRef/CorrectQueueRes/src/gf/Invoker.java b/appserver/tests/appserv-tests/devtests/deployment/ejb31/jndivalidation/ResourceRef/CorrectQueueRes/src/gf/Invoker.java
index bf9652a..3ce90de 100644
--- a/appserver/tests/appserv-tests/devtests/deployment/ejb31/jndivalidation/ResourceRef/CorrectQueueRes/src/gf/Invoker.java
+++ b/appserver/tests/appserv-tests/devtests/deployment/ejb31/jndivalidation/ResourceRef/CorrectQueueRes/src/gf/Invoker.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -18,8 +18,8 @@
 
 import javax.ejb.Stateless;
 import javax.annotation.Resource;
-import javax.jms.QueueConnectionFactory;
-import javax.jms.Queue;
+import jakarta.jms.QueueConnectionFactory;
+import jakarta.jms.Queue;
 
 @Stateless
 public class Invoker {
diff --git a/appserver/tests/appserv-tests/devtests/deployment/ejb31/jndivalidation/ResourceRef/DefaultResources/src/gf/TestServlet.java b/appserver/tests/appserv-tests/devtests/deployment/ejb31/jndivalidation/ResourceRef/DefaultResources/src/gf/TestServlet.java
index b8a3174..d5a9488 100644
--- a/appserver/tests/appserv-tests/devtests/deployment/ejb31/jndivalidation/ResourceRef/DefaultResources/src/gf/TestServlet.java
+++ b/appserver/tests/appserv-tests/devtests/deployment/ejb31/jndivalidation/ResourceRef/DefaultResources/src/gf/TestServlet.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -26,7 +26,7 @@
 import javax.enterprise.concurrent.ManagedScheduledExecutorService;
 import javax.enterprise.concurrent.ManagedThreadFactory;
 import javax.enterprise.inject.spi.BeanManager;
-import javax.jms.ConnectionFactory;
+import jakarta.jms.ConnectionFactory;
 import javax.sql.DataSource;
 import javax.transaction.UserTransaction;
 import javax.transaction.TransactionSynchronizationRegistry;
diff --git a/appserver/tests/appserv-tests/devtests/deployment/ejb31/jndivalidation/ResourceRef/ResInSameApp/build.xml b/appserver/tests/appserv-tests/devtests/deployment/ejb31/jndivalidation/ResourceRef/ResInSameApp/build.xml
index 80ae68f..6d47070 100644
--- a/appserver/tests/appserv-tests/devtests/deployment/ejb31/jndivalidation/ResourceRef/ResInSameApp/build.xml
+++ b/appserver/tests/appserv-tests/devtests/deployment/ejb31/jndivalidation/ResourceRef/ResInSameApp/build.xml
@@ -2,7 +2,7 @@
 <!DOCTYPE project [
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -51,7 +51,7 @@
         <antcall target="common.create.jms.resource">
             <param name="dest.type" value="queue"/>
             <param name="dest.name" value="deployment_jndivalidation_queue"/>
-            <param name="res.type" value="javax.jms.Queue"/>
+            <param name="res.type" value="jakarta.jms.Queue"/>
             <param name="jms.resource.name" value="jms/deployment_jndivalidation_queue"/>
         </antcall>
     </target>
diff --git a/appserver/tests/appserv-tests/devtests/deployment/ejb31/jndivalidation/ResourceRef/ResInSameApp/webModule/src/BarManagedBean.java b/appserver/tests/appserv-tests/devtests/deployment/ejb31/jndivalidation/ResourceRef/ResInSameApp/webModule/src/BarManagedBean.java
index 7f447fe..1718ea4 100644
--- a/appserver/tests/appserv-tests/devtests/deployment/ejb31/jndivalidation/ResourceRef/ResInSameApp/webModule/src/BarManagedBean.java
+++ b/appserver/tests/appserv-tests/devtests/deployment/ejb31/jndivalidation/ResourceRef/ResInSameApp/webModule/src/BarManagedBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package test.web;
 
 import javax.annotation.*;
-import javax.jms.Queue;
+import jakarta.jms.Queue;
 
 @ManagedBean("barmanagedbean")
 public class BarManagedBean {
diff --git a/appserver/tests/appserv-tests/devtests/deployment/ejb31/jndivalidation/ResourceRef/ResInSameApp/webModule/src/TestServlet.java b/appserver/tests/appserv-tests/devtests/deployment/ejb31/jndivalidation/ResourceRef/ResInSameApp/webModule/src/TestServlet.java
index 812d09f..9cbb075 100644
--- a/appserver/tests/appserv-tests/devtests/deployment/ejb31/jndivalidation/ResourceRef/ResInSameApp/webModule/src/TestServlet.java
+++ b/appserver/tests/appserv-tests/devtests/deployment/ejb31/jndivalidation/ResourceRef/ResInSameApp/webModule/src/TestServlet.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package test.web;
 
 import javax.annotation.Resource;
-import javax.jms.Queue;
+import jakarta.jms.Queue;
 
 public class TestServlet {
     @Resource
diff --git a/appserver/tests/appserv-tests/devtests/ejb/bmp/txtests/stateless/client/Client.java b/appserver/tests/appserv-tests/devtests/ejb/bmp/txtests/stateless/client/Client.java
index 75bc6a4..b1f91aa 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/bmp/txtests/stateless/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/ejb/bmp/txtests/stateless/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,14 +16,10 @@
 
 package com.sun.s1asdev.ejb.bmp.txtests.stateless.client;
 
-import java.util.ArrayList;
-
-import java.io.Serializable;
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.ejb.*;
 import javax.rmi.PortableRemoteObject;
-import java.rmi.NoSuchObjectException;
 
 import com.sun.s1asdev.ejb.bmp.txtests.stateless.ejb.SLSBHome;
 import com.sun.s1asdev.ejb.bmp.txtests.stateless.ejb.SLSB;
diff --git a/appserver/tests/appserv-tests/devtests/ejb/ee/methodcheckpoint/multi/client/Client.java b/appserver/tests/appserv-tests/devtests/ejb/ee/methodcheckpoint/multi/client/Client.java
index 3e1cfe9..2c55c94 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/ee/methodcheckpoint/multi/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/ejb/ee/methodcheckpoint/multi/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,18 +16,12 @@
 
 package com.sun.s1asdev.ejb.ee.methodcheckpoint.multi.client;
 
-import java.util.ArrayList;
-
-import java.io.Serializable;
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.ejb.*;
 import javax.rmi.PortableRemoteObject;
-import java.rmi.NoSuchObjectException;
-
 import com.sun.s1asdev.ejb.ee.ejb.SFSBHome;
 import com.sun.s1asdev.ejb.ee.ejb.SFSB;
-
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
 public class Client {
diff --git a/appserver/tests/appserv-tests/devtests/ejb/ee/methodcheckpoint/simple/client/Client.java b/appserver/tests/appserv-tests/devtests/ejb/ee/methodcheckpoint/simple/client/Client.java
index bdf278b..fdba62a 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/ee/methodcheckpoint/simple/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/ejb/ee/methodcheckpoint/simple/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,14 +16,10 @@
 
 package com.sun.s1asdev.ejb.ee.methodcheckpoint.simple.client;
 
-import java.util.ArrayList;
-
-import java.io.Serializable;
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.ejb.*;
 import javax.rmi.PortableRemoteObject;
-import java.rmi.NoSuchObjectException;
 
 import com.sun.s1asdev.ejb.ee.ejb.SFSBHome;
 import com.sun.s1asdev.ejb.ee.ejb.SFSB;
diff --git a/appserver/tests/appserv-tests/devtests/ejb/ee/txcheckpoint/bmtcmttx/client/Client.java b/appserver/tests/appserv-tests/devtests/ejb/ee/txcheckpoint/bmtcmttx/client/Client.java
index 5e1db68..a601ace 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/ee/txcheckpoint/bmtcmttx/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/ejb/ee/txcheckpoint/bmtcmttx/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,14 +16,10 @@
 
 package com.sun.s1asdev.ejb.ee.client;
 
-import java.util.ArrayList;
-
-import java.io.Serializable;
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.ejb.*;
 import javax.rmi.PortableRemoteObject;
-import java.rmi.NoSuchObjectException;
 
 import com.sun.s1asdev.ejb.ee.ejb.BMTSessionHome;
 import com.sun.s1asdev.ejb.ee.ejb.BMTSession;
diff --git a/appserver/tests/appserv-tests/devtests/ejb/ee/txcheckpoint/bmttx/client/Client.java b/appserver/tests/appserv-tests/devtests/ejb/ee/txcheckpoint/bmttx/client/Client.java
index a8716af..2c85d8b 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/ee/txcheckpoint/bmttx/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/ejb/ee/txcheckpoint/bmttx/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,14 +16,10 @@
 
 package com.sun.s1asdev.ejb.ee.client;
 
-import java.util.ArrayList;
-
-import java.io.Serializable;
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.ejb.*;
 import javax.rmi.PortableRemoteObject;
-import java.rmi.NoSuchObjectException;
 
 import com.sun.s1asdev.ejb.ee.ejb.BMTSessionHome;
 import com.sun.s1asdev.ejb.ee.ejb.BMTSession;
diff --git a/appserver/tests/appserv-tests/devtests/ejb/ee/txcheckpoint/simpletx/client/Client.java b/appserver/tests/appserv-tests/devtests/ejb/ee/txcheckpoint/simpletx/client/Client.java
index 3367b1b..7b60351 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/ee/txcheckpoint/simpletx/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/ejb/ee/txcheckpoint/simpletx/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,14 +16,10 @@
 
 package com.sun.s1asdev.ejb.ee.txcheckpoint.simpletx.client;
 
-import java.util.ArrayList;
-
-import java.io.Serializable;
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.ejb.*;
 import javax.rmi.PortableRemoteObject;
-import java.rmi.NoSuchObjectException;
 
 import com.sun.s1asdev.ejb.ee.txcheckpoint.simpletx.ejb.SFSBHome;
 import com.sun.s1asdev.ejb.ee.txcheckpoint.simpletx.ejb.SFSB;
diff --git a/appserver/tests/appserv-tests/devtests/ejb/ejb30/hello/mdb/build.xml b/appserver/tests/appserv-tests/devtests/ejb/ejb30/hello/mdb/build.xml
index 1ccf60b..bac2cf0 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/ejb30/hello/mdb/build.xml
+++ b/appserver/tests/appserv-tests/devtests/ejb/ejb30/hello/mdb/build.xml
@@ -2,7 +2,7 @@
 <!DOCTYPE project [
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -79,7 +79,7 @@
     <target name="run_standaloneclient" depends="init-common">
        <java  fork="on" 
               failonerror="true"
-              classpath="${env.S1AS_HOME}/lib/javaee.jar:${env.S1AS_HOME}/modules/javax.jms.jar:${env.S1AS_HOME}/lib/gf-client.jar:${build.classes.dir}:${env.APS_HOME}/lib/reporter.jar"
+              classpath="${env.S1AS_HOME}/lib/javaee.jar:${env.S1AS_HOME}/modules/jakarta.jms-api.jar:${env.S1AS_HOME}/lib/gf-client.jar:${build.classes.dir}:${env.APS_HOME}/lib/reporter.jar"
               classname="${simple.client}">
         </java>
     </target>
diff --git a/appserver/tests/appserv-tests/devtests/ejb/ejb30/hello/mdb/client/Client.java b/appserver/tests/appserv-tests/devtests/ejb/ejb30/hello/mdb/client/Client.java
index cadbb45..e984db3 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/ejb30/hello/mdb/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/ejb/ejb30/hello/mdb/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2002, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2002, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,7 +19,7 @@
 import java.io.*;
 import java.util.*;
 import javax.ejb.EJBHome;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.annotation.Resource;
 import javax.naming.InitialContext;
 
@@ -47,10 +47,10 @@
     private static QueueConnectionFactory queueConFactory;
 
     @Resource(name="MsgBeanQueue", mappedName="jms/ejb_ejb30_hello_mdb_InQueue")
-    private static javax.jms.Queue msgBeanQueue;
+    private static jakarta.jms.Queue msgBeanQueue;
 
     @Resource(name="ClientQueue", mappedName="foo")
-    private static javax.jms.Queue clientQueue;
+    private static jakarta.jms.Queue clientQueue;
 
     private QueueConnection queueCon;
     private QueueSession queueSession;
@@ -73,9 +73,9 @@
 
 		System.out.println("Java SE mode...");
 		InitialContext ic = new InitialContext();
-		queueConFactory = (javax.jms.QueueConnectionFactory) ic.lookup("jms/ejb_ejb30_hello_mdb_QCF");
-		msgBeanQueue = (javax.jms.Queue) ic.lookup("jms/ejb_ejb30_hello_mdb_InQueue");
-		clientQueue = (javax.jms.Queue) ic.lookup("jms/ejb_ejb30_hello_mdb_OutQueue");
+		queueConFactory = (jakarta.jms.QueueConnectionFactory) ic.lookup("jms/ejb_ejb30_hello_mdb_QCF");
+		msgBeanQueue = (jakarta.jms.Queue) ic.lookup("jms/ejb_ejb30_hello_mdb_InQueue");
+		clientQueue = (jakarta.jms.Queue) ic.lookup("jms/ejb_ejb30_hello_mdb_OutQueue");
 		
 	    }
 
@@ -116,7 +116,7 @@
         }
     }
 
-    public void sendMsgs(javax.jms.Queue queue, Message msg, int num) 
+    public void sendMsgs(jakarta.jms.Queue queue, Message msg, int num) 
         throws JMSException {
         for(int i = 0; i < num; i++) {
             System.out.println("Sending message " + i + " to " + queue + 
@@ -136,7 +136,7 @@
 
         message.setBooleanProperty("flag", true);
         message.setIntProperty("num", 2);
-        sendMsgs((javax.jms.Queue) dest, message, num);
+        sendMsgs((jakarta.jms.Queue) dest, message, num);
 
         System.out.println("Waiting for queue message");
         Message recvdmessage = queueReceiver.receive(TIMEOUT);
diff --git a/appserver/tests/appserv-tests/devtests/ejb/ejb30/hello/mdb/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/ejb/ejb30/hello/mdb/create_resources.asadmin
index 95b9e9b..26deb7e 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/ejb30/hello/mdb/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/ejb/ejb30/hello/mdb/create_resources.asadmin
@@ -1,5 +1,5 @@
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/ejb_ejb30_hello_mdb_QCF
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/ejb_ejb30_hello_mdb_QCF
 create-jmsdest --desttype queue ejb_ejb30_hello_mdb_InQueue 
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=ejb_ejb30_hello_mdb_InQueue jms/ejb_ejb30_hello_mdb_InQueue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=ejb_ejb30_hello_mdb_InQueue jms/ejb_ejb30_hello_mdb_InQueue
 create-jmsdest --desttype queue ejb_ejb30_hello_mdb_OutQueue 
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=ejb_ejb30_hello_mdb_OutQueue jms/ejb_ejb30_hello_mdb_OutQueue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=ejb_ejb30_hello_mdb_OutQueue jms/ejb_ejb30_hello_mdb_OutQueue
diff --git a/appserver/tests/appserv-tests/devtests/ejb/ejb30/hello/mdb/ejb/MessageBean.java b/appserver/tests/appserv-tests/devtests/ejb/ejb30/hello/mdb/ejb/MessageBean.java
index fb58b6c..988a0c1 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/ejb30/hello/mdb/ejb/MessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/ejb/ejb30/hello/mdb/ejb/MessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -24,15 +24,15 @@
 import javax.ejb.TransactionManagementType;
 import javax.ejb.ActivationConfigProperty;
 
-import javax.jms.MessageListener;
-import javax.jms.Message;
-import javax.jms.Queue;
-import javax.jms.QueueConnectionFactory;
-import javax.jms.QueueConnection;
-import javax.jms.QueueSession;
-import javax.jms.QueueSender;
-import javax.jms.TextMessage;
-import javax.jms.Session;
+import jakarta.jms.MessageListener;
+import jakarta.jms.Message;
+import jakarta.jms.Queue;
+import jakarta.jms.QueueConnectionFactory;
+import jakarta.jms.QueueConnection;
+import jakarta.jms.QueueSession;
+import jakarta.jms.QueueSender;
+import jakarta.jms.TextMessage;
+import jakarta.jms.Session;
 
 import javax.annotation.Resource;
 
diff --git a/appserver/tests/appserv-tests/devtests/ejb/ejb30/hello/mdb2/client/Client.java b/appserver/tests/appserv-tests/devtests/ejb/ejb30/hello/mdb2/client/Client.java
index 2b1096f..30d312d 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/ejb30/hello/mdb2/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/ejb/ejb30/hello/mdb2/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2002, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2002, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,11 +16,8 @@
 
 package com.sun.s1asdev.ejb.ejb30.hello.mdb2.client;
 
-import java.io.*;
-import java.util.*;
-import javax.ejb.EJBHome;
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.annotation.Resource;
 
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
@@ -50,7 +47,7 @@
     private QueueSession queueSession;
     private QueueSender queueSender;
     private QueueReceiver queueReceiver;
-    private javax.jms.Queue clientQueue;
+    private jakarta.jms.Queue clientQueue;
 
 
     private int numMessages = 2;
@@ -85,7 +82,7 @@
         // Producer will be specified when actual msg is sent.
         queueSender = queueSession.createSender(null);        
 
-        clientQueue = (javax.jms.Queue)
+        clientQueue = (jakarta.jms.Queue)
 	    context.lookup("java:comp/env/jms/MsgBeanClientQueue");
 
         queueReceiver = queueSession.createReceiver(clientQueue);
@@ -104,7 +101,7 @@
         }
     }
 
-    public void sendMsgs(javax.jms.Queue queue, Message msg, int num) 
+    public void sendMsgs(jakarta.jms.Queue queue, Message msg, int num) 
         throws JMSException {
         for(int i = 0; i < num; i++) {
             System.out.println("Sending message " + i + " to " + queue + 
@@ -124,7 +121,7 @@
 
         message.setBooleanProperty("flag", true);
         message.setIntProperty("num", 2);
-        sendMsgs((javax.jms.Queue) dest, message, num);
+        sendMsgs((jakarta.jms.Queue) dest, message, num);
 
         System.out.println("Waiting for queue message");
         Message recvdmessage = queueReceiver.receive(TIMEOUT);
diff --git a/appserver/tests/appserv-tests/devtests/ejb/ejb30/hello/mdb2/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/ejb/ejb30/hello/mdb2/create_resources.asadmin
index e724192..017cfc3 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/ejb30/hello/mdb2/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/ejb/ejb30/hello/mdb2/create_resources.asadmin
@@ -1,5 +1,5 @@
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/ejb_ejb30_hello_mdb2_QCF
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/ejb_ejb30_hello_mdb2_QCF
 create-jmsdest --desttype queue ejb_ejb30_hello_mdb2_InQueue 
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=ejb_ejb30_hello_mdb2_InQueue jms/ejb_ejb30_hello_mdb2_InQueue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=ejb_ejb30_hello_mdb2_InQueue jms/ejb_ejb30_hello_mdb2_InQueue
 create-jmsdest --desttype queue ejb_ejb30_hello_mdb2_OutQueue 
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=ejb_ejb30_hello_mdb2_OutQueue jms/ejb_ejb30_hello_mdb2_OutQueue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=ejb_ejb30_hello_mdb2_OutQueue jms/ejb_ejb30_hello_mdb2_OutQueue
diff --git a/appserver/tests/appserv-tests/devtests/ejb/ejb30/hello/mdb2/descriptor/application-client.xml b/appserver/tests/appserv-tests/devtests/ejb/ejb30/hello/mdb2/descriptor/application-client.xml
index d9e1f04..cc8c650 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/ejb30/hello/mdb2/descriptor/application-client.xml
+++ b/appserver/tests/appserv-tests/devtests/ejb/ejb30/hello/mdb2/descriptor/application-client.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -23,7 +23,7 @@
      <description>test destination</description>
      <message-destination-ref-name>jms/MsgBeanQueue
      </message-destination-ref-name>
-     <message-destination-type>javax.jms.Queue</message-destination-type>
+     <message-destination-type>jakarta.jms.Queue</message-destination-type>
      <message-destination-usage>Produces</message-destination-usage>
      <message-destination-link>MsgBeanInQueue</message-destination-link>
   </message-destination-ref>
@@ -31,7 +31,7 @@
      <description>test destination</description>
      <message-destination-ref-name>jms/MsgBeanClientQueue
      </message-destination-ref-name>
-     <message-destination-type>javax.jms.Queue</message-destination-type>
+     <message-destination-type>jakarta.jms.Queue</message-destination-type>
      <message-destination-usage>Consumes</message-destination-usage>
      <message-destination-link>MsgBeanOutQueue</message-destination-link>
   </message-destination-ref>
diff --git a/appserver/tests/appserv-tests/devtests/ejb/ejb30/hello/mdb2/descriptor/ejb-jar.xml b/appserver/tests/appserv-tests/devtests/ejb/ejb30/hello/mdb2/descriptor/ejb-jar.xml
index 2e9816c..b14a8c7 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/ejb30/hello/mdb2/descriptor/ejb-jar.xml
+++ b/appserver/tests/appserv-tests/devtests/ejb/ejb30/hello/mdb2/descriptor/ejb-jar.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -23,9 +23,9 @@
     <message-driven>
       <display-name>MDB1</display-name>
       <ejb-name>MessageBean</ejb-name>
-      <messaging-type>javax.jms.MessageListener</messaging-type>
+      <messaging-type>jakarta.jms.MessageListener</messaging-type>
       <transaction-type>Container</transaction-type>
-      <message-destination-type>javax.jms.Queue</message-destination-type>
+      <message-destination-type>jakarta.jms.Queue</message-destination-type>
       <message-destination-link>MsgBeanInQueue</message-destination-link>
       <env-entry>
          <env-entry-name>com.sun.s1asdev.ejb.ejb30.hello.mdb2.MessageBean/stringValue1</env-entry-name>
@@ -59,7 +59,7 @@
         <description>test destination</description>
         <message-destination-ref-name>jms/ClientQueue
         </message-destination-ref-name>
-        <message-destination-type>javax.jms.Queue</message-destination-type>
+        <message-destination-type>jakarta.jms.Queue</message-destination-type>
         <message-destination-usage>Produces</message-destination-usage>
         <message-destination-link>MsgBeanOutQueue</message-destination-link>
       </message-destination-ref>
diff --git a/appserver/tests/appserv-tests/devtests/ejb/ejb30/hello/mdb2/ejb/MessageBean.java b/appserver/tests/appserv-tests/devtests/ejb/ejb30/hello/mdb2/ejb/MessageBean.java
index cbff219..c963a3d 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/ejb30/hello/mdb2/ejb/MessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/ejb/ejb30/hello/mdb2/ejb/MessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -31,15 +31,15 @@
 
 import javax.naming.InitialContext;
 
-import javax.jms.MessageListener;
-import javax.jms.Message;
-import javax.jms.Queue;
-import javax.jms.QueueConnectionFactory;
-import javax.jms.QueueConnection;
-import javax.jms.QueueSession;
-import javax.jms.QueueSender;
-import javax.jms.TextMessage;
-import javax.jms.Session;
+import jakarta.jms.MessageListener;
+import jakarta.jms.Message;
+import jakarta.jms.Queue;
+import jakarta.jms.QueueConnectionFactory;
+import jakarta.jms.QueueConnection;
+import jakarta.jms.QueueSession;
+import jakarta.jms.QueueSender;
+import jakarta.jms.TextMessage;
+import jakarta.jms.Session;
 import javax.transaction.TransactionManager;
 import javax.transaction.Status;
 import javax.annotation.Resource;
diff --git a/appserver/tests/appserv-tests/devtests/ejb/ejb30/interceptors/mdb/client/Client.java b/appserver/tests/appserv-tests/devtests/ejb/ejb30/interceptors/mdb/client/Client.java
index def4ef5..b87e715 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/ejb30/interceptors/mdb/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/ejb/ejb30/interceptors/mdb/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2002, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2002, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,7 +20,7 @@
 import java.util.*;
 import javax.ejb.EJBHome;
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 
 
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
@@ -47,7 +47,7 @@
     private QueueSession queueSession;
     private QueueSender queueSender;
     private QueueReceiver queueReceiver;
-    private javax.jms.Queue clientQueue;
+    private jakarta.jms.Queue clientQueue;
 
 
     private int numMessages = 2;
@@ -89,7 +89,7 @@
         // Producer will be specified when actual msg is sent.
         queueSender = queueSession.createSender(null);        
 
-        clientQueue = (javax.jms.Queue)
+        clientQueue = (jakarta.jms.Queue)
             context.lookup("java:comp/env/jms/MsgBeanClientQueue");
 
         queueReceiver = queueSession.createReceiver(clientQueue);
@@ -108,7 +108,7 @@
         }
     }
 
-    public void sendMsgs(javax.jms.Queue queue, Message msg, int num) 
+    public void sendMsgs(jakarta.jms.Queue queue, Message msg, int num) 
         throws JMSException {
         for(int i = 0; i < num; i++) {
             System.out.println("Sending message " + i + " to " + queue + 
@@ -128,7 +128,7 @@
 
         message.setBooleanProperty("flag", true);
         message.setIntProperty("num", 2);
-        sendMsgs((javax.jms.Queue) dest, message, num);
+        sendMsgs((jakarta.jms.Queue) dest, message, num);
 
         System.out.println("Waiting for queue message");
         Message recvdmessage = queueReceiver.receive(TIMEOUT);
diff --git a/appserver/tests/appserv-tests/devtests/ejb/ejb30/interceptors/mdb/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/ejb/ejb30/interceptors/mdb/create_resources.asadmin
index 0408a21..fe3bfd9 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/ejb30/interceptors/mdb/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/ejb/ejb30/interceptors/mdb/create_resources.asadmin
@@ -1,11 +1,11 @@
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/ejb_ejb30_interceptors_mdb_QCF
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/ejb_ejb30_interceptors_mdb_QCF
 
 
 create-jmsdest --desttype queue ejb_ejb30_interceptors_mdb_InQueue 
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=ejb_ejb30_interceptors_mdb_InQueue jms/ejb_ejb30_interceptors_mdb_InQueue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=ejb_ejb30_interceptors_mdb_InQueue jms/ejb_ejb30_interceptors_mdb_InQueue
 
 
 create-jmsdest --desttype queue ejb_ejb30_interceptors_mdb_OutQueue 
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=ejb_ejb30_interceptors_mdb_OutQueue jms/ejb_ejb30_interceptors_mdb_OutQueue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=ejb_ejb30_interceptors_mdb_OutQueue jms/ejb_ejb30_interceptors_mdb_OutQueue
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/ejb/ejb30/interceptors/mdb/descriptor/application-client.xml b/appserver/tests/appserv-tests/devtests/ejb/ejb30/interceptors/mdb/descriptor/application-client.xml
index a05e320..412fa13 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/ejb30/interceptors/mdb/descriptor/application-client.xml
+++ b/appserver/tests/appserv-tests/devtests/ejb/ejb30/interceptors/mdb/descriptor/application-client.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -21,7 +21,7 @@
   <display-name>ejb-ejb30-interceptors-mdbClient</display-name>
   <resource-ref>
     <res-ref-name>FooCF</res-ref-name>
-    <res-type>javax.jms.QueueConnectionFactory</res-type>
+    <res-type>jakarta.jms.QueueConnectionFactory</res-type>
     <res-auth>Container</res-auth>
     <res-sharing-scope>Shareable</res-sharing-scope>
   </resource-ref>
@@ -29,7 +29,7 @@
      <description>test destination</description>
      <message-destination-ref-name>jms/MsgBeanQueue
      </message-destination-ref-name>
-     <message-destination-type>javax.jms.Queue</message-destination-type>
+     <message-destination-type>jakarta.jms.Queue</message-destination-type>
      <message-destination-usage>Produces</message-destination-usage>
      <message-destination-link>MsgBeanInQueue</message-destination-link>
   </message-destination-ref>
@@ -37,7 +37,7 @@
      <description>test destination</description>
      <message-destination-ref-name>jms/MsgBeanClientQueue
      </message-destination-ref-name>
-     <message-destination-type>javax.jms.Queue</message-destination-type>
+     <message-destination-type>jakarta.jms.Queue</message-destination-type>
      <message-destination-usage>Consumes</message-destination-usage>
      <message-destination-link>MsgBeanOutQueue</message-destination-link>
   </message-destination-ref>
diff --git a/appserver/tests/appserv-tests/devtests/ejb/ejb30/interceptors/mdb/descriptor/ejb-jar.xml b/appserver/tests/appserv-tests/devtests/ejb/ejb30/interceptors/mdb/descriptor/ejb-jar.xml
index 23bc8c2..d3b4592 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/ejb30/interceptors/mdb/descriptor/ejb-jar.xml
+++ b/appserver/tests/appserv-tests/devtests/ejb/ejb30/interceptors/mdb/descriptor/ejb-jar.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -24,14 +24,14 @@
       <display-name>MDB1</display-name>
       <ejb-name>MessageBean</ejb-name>
       <ejb-class>com.sun.s1asdev.ejb.ejb30.interceptors.mdb.MessageBean</ejb-class>
-      <messaging-type>javax.jms.MessageListener</messaging-type>
+      <messaging-type>jakarta.jms.MessageListener</messaging-type>
       <transaction-type>Bean</transaction-type>
-      <message-destination-type>javax.jms.Queue</message-destination-type>
+      <message-destination-type>jakarta.jms.Queue</message-destination-type>
       <message-destination-link>MsgBeanInQueue</message-destination-link>
       <resource-ref>
         <description>description</description>
         <res-ref-name>jms/MyQueueConnectionFactory</res-ref-name>
-        <res-type>javax.jms.QueueConnectionFactory</res-type>
+        <res-type>jakarta.jms.QueueConnectionFactory</res-type>
         <res-auth>Container</res-auth>
         <res-sharing-scope>Shareable</res-sharing-scope>
       </resource-ref>
@@ -39,7 +39,7 @@
         <description>test destination</description>
         <message-destination-ref-name>jms/ClientQueue
         </message-destination-ref-name>
-        <message-destination-type>javax.jms.Queue</message-destination-type>
+        <message-destination-type>jakarta.jms.Queue</message-destination-type>
         <message-destination-usage>Produces</message-destination-usage>
         <message-destination-link>MsgBeanOutQueue</message-destination-link>
       </message-destination-ref>
diff --git a/appserver/tests/appserv-tests/devtests/ejb/ejb30/interceptors/mdb/ejb/MessageBean.java b/appserver/tests/appserv-tests/devtests/ejb/ejb30/interceptors/mdb/ejb/MessageBean.java
index f45016d..748a6a0 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/ejb30/interceptors/mdb/ejb/MessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/ejb/ejb30/interceptors/mdb/ejb/MessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -23,15 +23,15 @@
 
 import javax.naming.InitialContext;
 
-import javax.jms.MessageListener;
-import javax.jms.Message;
-import javax.jms.Queue;
-import javax.jms.QueueConnectionFactory;
-import javax.jms.QueueConnection;
-import javax.jms.QueueSession;
-import javax.jms.QueueSender;
-import javax.jms.TextMessage;
-import javax.jms.Session;
+import jakarta.jms.MessageListener;
+import jakarta.jms.Message;
+import jakarta.jms.Queue;
+import jakarta.jms.QueueConnectionFactory;
+import jakarta.jms.QueueConnection;
+import jakarta.jms.QueueSession;
+import jakarta.jms.QueueSender;
+import jakarta.jms.TextMessage;
+import jakarta.jms.Session;
 import javax.interceptor.ExcludeClassInterceptors;
 import javax.interceptor.ExcludeDefaultInterceptors;
 import javax.interceptor.Interceptors;
diff --git a/appserver/tests/appserv-tests/devtests/ejb/ejb31/embedded/mdb/build.xml b/appserver/tests/appserv-tests/devtests/ejb/ejb31/embedded/mdb/build.xml
index 81ff5a4..9d809ae 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/ejb31/embedded/mdb/build.xml
+++ b/appserver/tests/appserv-tests/devtests/ejb/ejb31/embedded/mdb/build.xml
@@ -2,7 +2,7 @@
 <!DOCTYPE project [
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -67,7 +67,7 @@
           <arg line="--user ${admin.user} --host ${admin.host} --port ${admin.port} --echo=true --terse=true"/>
           <arg line="create-jms-resource"/>
           <arg line="--restype"/>
-          <arg line="javax.jms.QueueConnectionFactory"/>
+          <arg line="jakarta.jms.QueueConnectionFactory"/>
           <arg line="jms/ejb_mdb_QCF"/>
         </exec>
 
@@ -83,7 +83,7 @@
           <arg line="--user ${admin.user} --host ${admin.host} --port ${admin.port} --echo=true --terse=true"/>
           <arg line="create-jms-resource"/>
           <arg line="--restype"/>
-          <arg line="javax.jms.Queue"/>
+          <arg line="jakarta.jms.Queue"/>
           <arg line="--property"/>
           <arg line="imqDestinationName=ejb_mdb_Queue"/>
           <arg line="jms/ejb_mdb_Queue"/>
diff --git a/appserver/tests/appserv-tests/devtests/ejb/ejb31/embedded/mdb/ejb/SimpleEjb.java b/appserver/tests/appserv-tests/devtests/ejb/ejb31/embedded/mdb/ejb/SimpleEjb.java
index 78550e1..fd417cf 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/ejb31/embedded/mdb/ejb/SimpleEjb.java
+++ b/appserver/tests/appserv-tests/devtests/ejb/ejb31/embedded/mdb/ejb/SimpleEjb.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.tests.ejb.mdb;
 
 import javax.ejb.Singleton;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.annotation.Resource;
 
 
diff --git a/appserver/tests/appserv-tests/devtests/ejb/ejb31/embedded/mdb/ejb/SimpleMDB.java b/appserver/tests/appserv-tests/devtests/ejb/ejb31/embedded/mdb/ejb/SimpleMDB.java
index f916b08..86bc71d 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/ejb31/embedded/mdb/ejb/SimpleMDB.java
+++ b/appserver/tests/appserv-tests/devtests/ejb/ejb31/embedded/mdb/ejb/SimpleMDB.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -22,7 +22,7 @@
 package org.glassfish.tests.ejb.mdb;
 
 import javax.ejb.*;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/ejb/ejb31/timer31/mdb/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/ejb/ejb31/timer31/mdb/create_resources.asadmin
index 0a3c444..d9b3eb9 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/ejb31/timer31/mdb/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/ejb/ejb31/timer31/mdb/create_resources.asadmin
@@ -1,2 +1,2 @@
 create-jmsdest --desttype queue ejb_ejb31_timer31_mdb_InQueue 
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=ejb_ejb31_timer31_mdb_InQueue jms/ejb_ejb31_timer31_mdb_InQueue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=ejb_ejb31_timer31_mdb_InQueue jms/ejb_ejb31_timer31_mdb_InQueue
diff --git a/appserver/tests/appserv-tests/devtests/ejb/ejb31/timer31/mdb/ejb/MessageBean.java b/appserver/tests/appserv-tests/devtests/ejb/ejb31/timer31/mdb/ejb/MessageBean.java
index 71e3bc1..22173a5 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/ejb31/timer31/mdb/ejb/MessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/ejb/ejb31/timer31/mdb/ejb/MessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -26,8 +26,8 @@
 
 import javax.annotation.Resource;
 import javax.ejb.MessageDrivenContext;
-import javax.jms.MessageListener;
-import javax.jms.Message;
+import jakarta.jms.MessageListener;
+import jakarta.jms.Message;
 import javax.annotation.PostConstruct;
 import javax.annotation.PreDestroy;
 import javax.annotation.security.*;
diff --git a/appserver/tests/appserv-tests/devtests/ejb/ejb31/timer31/nonpersistenttimer/client/Client.java b/appserver/tests/appserv-tests/devtests/ejb/ejb31/timer31/nonpersistenttimer/client/Client.java
index 285d61d..8842704 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/ejb31/timer31/nonpersistenttimer/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/ejb/ejb31/timer31/nonpersistenttimer/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,16 +16,8 @@
 
 package com.sun.s1asdev.timer31.nonpersistenttimer.client;
 
-import java.io.Serializable;
-import java.rmi.NoSuchObjectException;
-import java.util.Date;
-import java.util.Properties;
-import java.util.Set;
-
 import javax.ejb.*;
-//import javax.jms.*;
 import javax.naming.*;
-import javax.rmi.PortableRemoteObject;
 
 import com.sun.s1asdev.ejb31.timer.nonpersistenttimer.StatefulWrapper;
 
diff --git a/appserver/tests/appserv-tests/devtests/ejb/ejb31/timer31/nonpersistenttimer/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/ejb/ejb31/timer31/nonpersistenttimer/create_resources.asadmin
index f248737..8ed3b14 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/ejb31/timer31/nonpersistenttimer/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/ejb/ejb31/timer31/nonpersistenttimer/create_resources.asadmin
@@ -1,10 +1,10 @@
-create-jms-resource --restype javax.jms.QueueConnectionFactory  jms/ejb_timer_nonpersistenttimer_QCF
-create-jms-resource --restype javax.jms.TopicConnectionFactory  jms/ejb_timer_nonpersistenttimer_TCF
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory  jms/ejb_timer_nonpersistenttimer_QCF
+create-jms-resource --restype jakarta.jms.TopicConnectionFactory  jms/ejb_timer_nonpersistenttimer_TCF
 
-create-jms-resource --restype javax.jms.Queue --enabled=true --property imqDestinationName=ejb_timer_nonpersistenttimer_queue jms/ejb_timer_nonpersistenttimer_queue
-create-jms-resource --restype javax.jms.Topic --enabled=true --property imqDestinationName=ejb_timer_nonpersistenttimer_topic jms/ejb_timer_nonpersistenttimer_topic
-create-jms-resource --restype javax.jms.Queue --enabled=true --property imqDestinationName=ejb_timer_nonpersistenttimer_mdb_cmt jms/ejb_timer_nonpersistenttimer_mdb_cmt
-create-jms-resource --restype javax.jms.Queue --enabled=true --property imqDestinationName=ejb_timer_nonpersistenttimer_mdb_bmt jms/ejb_timer_nonpersistenttimer_mdb_bmt
+create-jms-resource --restype jakarta.jms.Queue --enabled=true --property imqDestinationName=ejb_timer_nonpersistenttimer_queue jms/ejb_timer_nonpersistenttimer_queue
+create-jms-resource --restype jakarta.jms.Topic --enabled=true --property imqDestinationName=ejb_timer_nonpersistenttimer_topic jms/ejb_timer_nonpersistenttimer_topic
+create-jms-resource --restype jakarta.jms.Queue --enabled=true --property imqDestinationName=ejb_timer_nonpersistenttimer_mdb_cmt jms/ejb_timer_nonpersistenttimer_mdb_cmt
+create-jms-resource --restype jakarta.jms.Queue --enabled=true --property imqDestinationName=ejb_timer_nonpersistenttimer_mdb_bmt jms/ejb_timer_nonpersistenttimer_mdb_bmt
 
 create-jmsdest --desttype queue ejb_timer_nonpersistenttimer_queue
 create-jmsdest --desttype topic ejb_timer_nonpersistenttimer_topic
diff --git a/appserver/tests/appserv-tests/devtests/ejb/ejb31/timer31/nonpersistenttimer/descriptor/ejb-jar.xml b/appserver/tests/appserv-tests/devtests/ejb/ejb31/timer31/nonpersistenttimer/descriptor/ejb-jar.xml
index f5fbff3..114168e 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/ejb31/timer31/nonpersistenttimer/descriptor/ejb-jar.xml
+++ b/appserver/tests/appserv-tests/devtests/ejb/ejb31/timer31/nonpersistenttimer/descriptor/ejb-jar.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -24,9 +24,9 @@
     <message-driven>
       <ejb-name>msgbean_BMT</ejb-name>
       <ejb-class>com.sun.s1asdev.ejb31.timer.nonpersistenttimer.MessageDrivenEJB</ejb-class>
-      <messaging-type>javax.jms.MessageListener</messaging-type>
+      <messaging-type>jakarta.jms.MessageListener</messaging-type>
       <transaction-type>Bean</transaction-type>
-      <message-destination-type>javax.jms.Queue</message-destination-type>
+      <message-destination-type>jakarta.jms.Queue</message-destination-type>
       <message-destination-link>TimerMDBQueue_BMT</message-destination-link>
       <env-entry>
         <env-entry-name>txmode</env-entry-name>
@@ -36,14 +36,14 @@
       <resource-ref>
         <description>description</description>
         <res-ref-name>jms/MyQueueConnectionFactory</res-ref-name>
-        <res-type>javax.jms.QueueConnectionFactory</res-type>
+        <res-type>jakarta.jms.QueueConnectionFactory</res-type>
         <res-auth>Container</res-auth>
         <res-sharing-scope>Shareable</res-sharing-scope>
       </resource-ref>
       <message-destination-ref>       
         <description>timertest destination</description>
         <message-destination-ref-name>jms/MyQueue</message-destination-ref-name>
-        <message-destination-type>javax.jms.Queue</message-destination-type>
+        <message-destination-type>jakarta.jms.Queue</message-destination-type>
         <message-destination-usage>ConsumesProduces</message-destination-usage>
         <message-destination-link>TimerQueue</message-destination-link>
       </message-destination-ref>
@@ -51,9 +51,9 @@
     <message-driven>
       <ejb-name>msgbean_CMT</ejb-name>
       <ejb-class>com.sun.s1asdev.ejb31.timer.nonpersistenttimer.MessageDrivenEJB</ejb-class>
-      <messaging-type>javax.jms.MessageListener</messaging-type>
+      <messaging-type>jakarta.jms.MessageListener</messaging-type>
       <transaction-type>Container</transaction-type>
-      <message-destination-type>javax.jms.Queue</message-destination-type>
+      <message-destination-type>jakarta.jms.Queue</message-destination-type>
       <message-destination-link>TimerMDBQueue_CMT</message-destination-link>
       <env-entry>
         <env-entry-name>txmode</env-entry-name>
@@ -63,14 +63,14 @@
       <resource-ref>
         <description>description</description>
         <res-ref-name>jms/MyQueueConnectionFactory</res-ref-name>
-        <res-type>javax.jms.QueueConnectionFactory</res-type>
+        <res-type>jakarta.jms.QueueConnectionFactory</res-type>
         <res-auth>Container</res-auth>
         <res-sharing-scope>Shareable</res-sharing-scope>
       </resource-ref>
       <message-destination-ref>       
         <description>timertest destination</description>
         <message-destination-ref-name>jms/MyQueue</message-destination-ref-name>
-        <message-destination-type>javax.jms.Queue</message-destination-type>
+        <message-destination-type>jakarta.jms.Queue</message-destination-type>
         <message-destination-usage>ConsumesProduces</message-destination-usage>
         <message-destination-link>TimerQueue</message-destination-link>
       </message-destination-ref>
@@ -92,14 +92,14 @@
       <resource-ref>
         <description>description</description>
         <res-ref-name>jms/MyQueueConnectionFactory</res-ref-name>
-        <res-type>javax.jms.QueueConnectionFactory</res-type>
+        <res-type>jakarta.jms.QueueConnectionFactory</res-type>
         <res-auth>Container</res-auth>
         <res-sharing-scope>Shareable</res-sharing-scope>
       </resource-ref>
       <message-destination-ref>       
         <description>timertest destination</description>
         <message-destination-ref-name>jms/MyQueue</message-destination-ref-name>
-        <message-destination-type>javax.jms.Queue</message-destination-type>
+        <message-destination-type>jakarta.jms.Queue</message-destination-type>
         <message-destination-usage>ConsumesProduces</message-destination-usage>
         <message-destination-link>TimerQueue</message-destination-link>
       </message-destination-ref>
@@ -124,14 +124,14 @@
       <resource-ref>
         <description>description</description>
         <res-ref-name>jms/MyQueueConnectionFactory</res-ref-name>
-        <res-type>javax.jms.QueueConnectionFactory</res-type>
+        <res-type>jakarta.jms.QueueConnectionFactory</res-type>
         <res-auth>Container</res-auth>
         <res-sharing-scope>Shareable</res-sharing-scope>
       </resource-ref>
       <message-destination-ref>       
         <description>timertest destination</description>
         <message-destination-ref-name>jms/MyQueue</message-destination-ref-name>
-        <message-destination-type>javax.jms.Queue</message-destination-type>
+        <message-destination-type>jakarta.jms.Queue</message-destination-type>
         <message-destination-usage>ConsumesProduces</message-destination-usage>
         <message-destination-link>TimerQueue</message-destination-link>
       </message-destination-ref>
@@ -156,14 +156,14 @@
       <resource-ref>
         <description>description</description>
         <res-ref-name>jms/MyQueueConnectionFactory</res-ref-name>
-        <res-type>javax.jms.QueueConnectionFactory</res-type>
+        <res-type>jakarta.jms.QueueConnectionFactory</res-type>
         <res-auth>Container</res-auth>
         <res-sharing-scope>Shareable</res-sharing-scope>
       </resource-ref>
       <message-destination-ref>       
         <description>timertest destination</description>
         <message-destination-ref-name>jms/MyQueue</message-destination-ref-name>
-        <message-destination-type>javax.jms.Queue</message-destination-type>
+        <message-destination-type>jakarta.jms.Queue</message-destination-type>
         <message-destination-usage>ConsumesProduces</message-destination-usage>
         <message-destination-link>TimerQueue</message-destination-link>
       </message-destination-ref>
@@ -211,7 +211,7 @@
         <ejb-name>msgbean_CMT</ejb-name>
         <method-name>onMessage</method-name>
         <method-params>
-          <method-param>javax.jms.Message</method-param>
+          <method-param>jakarta.jms.Message</method-param>
         </method-params>
       </method>
       <trans-attribute>Required</trans-attribute>
diff --git a/appserver/tests/appserv-tests/devtests/ejb/ejb31/timer31/nonpersistenttimer/ejb/MessageDrivenEJB.java b/appserver/tests/appserv-tests/devtests/ejb/ejb31/timer31/nonpersistenttimer/ejb/MessageDrivenEJB.java
index 7a1248d..7145510 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/ejb31/timer31/nonpersistenttimer/ejb/MessageDrivenEJB.java
+++ b/appserver/tests/appserv-tests/devtests/ejb/ejb31/timer31/nonpersistenttimer/ejb/MessageDrivenEJB.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,9 +16,8 @@
 
 package com.sun.s1asdev.ejb31.timer.nonpersistenttimer;
 
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.ejb.*;
-import java.io.Serializable;
 
 public class MessageDrivenEJB extends TimerStuffImpl 
     implements MessageDrivenBean, TimedObject, MessageListener {
diff --git a/appserver/tests/appserv-tests/devtests/ejb/ejb31/timer31/nonpersistenttimer/ejb/StatefulWrapperImpl.java b/appserver/tests/appserv-tests/devtests/ejb/ejb31/timer31/nonpersistenttimer/ejb/StatefulWrapperImpl.java
index ec604d7..62fdeee 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/ejb31/timer31/nonpersistenttimer/ejb/StatefulWrapperImpl.java
+++ b/appserver/tests/appserv-tests/devtests/ejb/ejb31/timer31/nonpersistenttimer/ejb/StatefulWrapperImpl.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,14 +16,8 @@
 
 package com.sun.s1asdev.ejb31.timer.nonpersistenttimer;
 
-import java.io.Serializable;
-import java.rmi.NoSuchObjectException;
 import java.util.Date;
-import java.util.Properties;
-import java.util.Set;
-
 import javax.ejb.*;
-//import javax.jms.*;
 import javax.naming.*;
 import javax.rmi.PortableRemoteObject;
 
diff --git a/appserver/tests/appserv-tests/devtests/ejb/ejb31/timer31/nonpersistenttimer/ejb/TimerStuffImpl.java b/appserver/tests/appserv-tests/devtests/ejb/ejb31/timer31/nonpersistenttimer/ejb/TimerStuffImpl.java
index 49970f5..25345e3 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/ejb31/timer31/nonpersistenttimer/ejb/TimerStuffImpl.java
+++ b/appserver/tests/appserv-tests/devtests/ejb/ejb31/timer31/nonpersistenttimer/ejb/TimerStuffImpl.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -24,14 +24,13 @@
 import java.util.Collection;
 import java.util.Iterator;
 import javax.ejb.*;
-import javax.jms.JMSException;
-import javax.jms.QueueConnectionFactory;
-import javax.jms.QueueConnection;
-import javax.jms.Queue;
-import javax.jms.QueueSession;
-import javax.jms.QueueSender;
-import javax.jms.QueueReceiver;
-import javax.jms.TextMessage;
+import jakarta.jms.QueueConnectionFactory;
+import jakarta.jms.QueueConnection;
+import jakarta.jms.Queue;
+import jakarta.jms.QueueSession;
+import jakarta.jms.QueueSender;
+import jakarta.jms.QueueReceiver;
+import jakarta.jms.TextMessage;
 
 public class TimerStuffImpl implements TimerStuff {
     
diff --git a/appserver/tests/appserv-tests/devtests/ejb/ejb31/timer31/reschedule_after_failures/client/Client.java b/appserver/tests/appserv-tests/devtests/ejb/ejb31/timer31/reschedule_after_failures/client/Client.java
index 7fdd9a4..8cc0c2f 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/ejb31/timer31/reschedule_after_failures/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/ejb/ejb31/timer31/reschedule_after_failures/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,19 +16,9 @@
 
 package com.sun.s1asdev.timer31.reschedule_after_failures.client;
 
-import java.io.Serializable;
-import java.rmi.NoSuchObjectException;
-import java.util.Date;
-import java.util.Properties;
-import java.util.Set;
-
 import javax.ejb.*;
-//import javax.jms.*;
 import javax.naming.*;
-import javax.rmi.PortableRemoteObject;
-
 import com.sun.s1asdev.ejb31.timer.reschedule_after_failures.Stles;
-
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
 public class Client {
diff --git a/appserver/tests/appserv-tests/devtests/ejb/ejb31/timer31/schedule_ann/client/Client.java b/appserver/tests/appserv-tests/devtests/ejb/ejb31/timer31/schedule_ann/client/Client.java
index a30a861..dd653f9 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/ejb31/timer31/schedule_ann/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/ejb/ejb31/timer31/schedule_ann/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,19 +16,9 @@
 
 package com.sun.s1asdev.timer31.schedule_ann.client;
 
-import java.io.Serializable;
-import java.rmi.NoSuchObjectException;
-import java.util.Date;
-import java.util.Properties;
-import java.util.Set;
-
 import javax.ejb.*;
-//import javax.jms.*;
 import javax.naming.*;
-import javax.rmi.PortableRemoteObject;
-
 import com.sun.s1asdev.ejb31.timer.schedule_ann.Stles;
-
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
 public class Client {
diff --git a/appserver/tests/appserv-tests/devtests/ejb/ejb31/timer31/schedule_exp/client/Client.java b/appserver/tests/appserv-tests/devtests/ejb/ejb31/timer31/schedule_exp/client/Client.java
index e1da741..9e24248 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/ejb31/timer31/schedule_exp/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/ejb/ejb31/timer31/schedule_exp/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,16 +16,8 @@
 
 package com.sun.s1asdev.timer31.schedule_exp.client;
 
-import java.io.Serializable;
-import java.rmi.NoSuchObjectException;
-import java.util.Date;
-import java.util.Properties;
-import java.util.Set;
-
 import javax.ejb.*;
-//import javax.jms.*;
 import javax.naming.*;
-import javax.rmi.PortableRemoteObject;
 
 import com.sun.s1asdev.ejb31.timer.schedule_exp.Stles;
 
diff --git a/appserver/tests/appserv-tests/devtests/ejb/jms/jmsejb/client/Client.java b/appserver/tests/appserv-tests/devtests/ejb/jms/jmsejb/client/Client.java
index 9803c57..589c4f3 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/jms/jmsejb/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/ejb/jms/jmsejb/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,15 +16,9 @@
 
 package com.sun.s1asdev.ejb.jms.jmsejb.client;
 
-import java.io.*;
-import java.util.*;
-import javax.ejb.EJBHome;
 import javax.naming.*;
 import javax.rmi.PortableRemoteObject;
-import org.omg.CORBA.ORB;
-import java.sql.*;
-import javax.sql.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import com.sun.s1asdev.ejb.jms.jmsejb.HelloHome;
 import com.sun.s1asdev.ejb.jms.jmsejb.Hello;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
diff --git a/appserver/tests/appserv-tests/devtests/ejb/jms/jmsejb/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/ejb/jms/jmsejb/create_resources.asadmin
index 703ac91..7a706aa 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/jms/jmsejb/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/ejb/jms/jmsejb/create_resources.asadmin
@@ -1,7 +1,7 @@
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/ejb_jms_jmsejb_QCF
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/ejb_jms_jmsejb_QCF
 
 create-jmsdest --desttype queue ejb_jms_jmsejb_Queue
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=ejb_jms_jmsejb_Queue jms/ejb_jms_jmsejb_Queue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=ejb_jms_jmsejb_Queue jms/ejb_jms_jmsejb_Queue
 
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/ejb/jms/jmsejb/descriptor/ejb-jar.xml b/appserver/tests/appserv-tests/devtests/ejb/jms/jmsejb/descriptor/ejb-jar.xml
index ae23eab..44cbebc 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/jms/jmsejb/descriptor/ejb-jar.xml
+++ b/appserver/tests/appserv-tests/devtests/ejb/jms/jmsejb/descriptor/ejb-jar.xml
@@ -2,7 +2,7 @@
 <!DOCTYPE ejb-jar PUBLIC "-//Sun Microsystems, Inc.//DTD Enterprise JavaBeans 2.0//EN" "http://java.sun.com/dtd/ejb-jar_2_0.dtd">
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -55,13 +55,13 @@
       <resource-ref>
         <description>description</description>
         <res-ref-name>jms/MyQueueConnectionFactory</res-ref-name>
-        <res-type>javax.jms.QueueConnectionFactory</res-type>
+        <res-type>jakarta.jms.QueueConnectionFactory</res-type>
         <res-auth>Bean</res-auth>
         <res-sharing-scope>Shareable</res-sharing-scope>
       </resource-ref>
       <resource-env-ref>
         <resource-env-ref-name>jms/QueueName</resource-env-ref-name>
-        <resource-env-ref-type>javax.jms.Queue</resource-env-ref-type>
+        <resource-env-ref-type>jakarta.jms.Queue</resource-env-ref-type>
       </resource-env-ref>
     </session>
     <session>
@@ -98,13 +98,13 @@
       <resource-ref>
         <description>description</description>
         <res-ref-name>jms/MyQueueConnectionFactory</res-ref-name>
-        <res-type>javax.jms.QueueConnectionFactory</res-type>
+        <res-type>jakarta.jms.QueueConnectionFactory</res-type>
         <res-auth>Bean</res-auth>
         <res-sharing-scope>Shareable</res-sharing-scope>
       </resource-ref>
       <resource-env-ref>
         <resource-env-ref-name>jms/QueueName</resource-env-ref-name>
-        <resource-env-ref-type>javax.jms.Queue</resource-env-ref-type>
+        <resource-env-ref-type>jakarta.jms.Queue</resource-env-ref-type>
       </resource-env-ref>
     </session>
   </enterprise-beans>
diff --git a/appserver/tests/appserv-tests/devtests/ejb/jms/jmsejb/ejb/HelloBean.java b/appserver/tests/appserv-tests/devtests/ejb/jms/jmsejb/ejb/HelloBean.java
index aae0335..f3ad6a9 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/jms/jmsejb/ejb/HelloBean.java
+++ b/appserver/tests/appserv-tests/devtests/ejb/jms/jmsejb/ejb/HelloBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,15 +16,12 @@
 
 package com.sun.s1asdev.ejb.jms.jmsejb;
 
-import java.util.Enumeration;
-import java.io.Serializable;
 import java.rmi.RemoteException; 
 import javax.ejb.SessionBean;
 import javax.ejb.SessionContext;
 import javax.ejb.EJBException;
 import javax.naming.*;
-import javax.jms.*;
-import javax.transaction.UserTransaction;
+import jakarta.jms.*;
 
 public class HelloBean implements SessionBean {
     private String str;
@@ -86,11 +83,11 @@
                 session.commit();
                 throw new java.lang.IllegalStateException
                     ("Didn't get session.commit exception");
-            } catch(javax.jms.TransactionInProgressException tipe) {
+            } catch(jakarta.jms.TransactionInProgressException tipe) {
                 System.out.println
                     ("Successfully got tx in progress excep " +
                      "after calling session.commit in a global tx");
-            } catch(javax.jms.JMSException jmse) {
+            } catch(jakarta.jms.JMSException jmse) {
                 System.out.println
                     ("Got JMSException - it's also ok - " +
                      "after calling session.commit in a global tx");
@@ -110,7 +107,7 @@
                 session.commit();
                 throw new JMSException
                     ("Didn't get session.commit exception");
-            } catch(javax.jms.JMSException jmse) {
+            } catch(jakarta.jms.JMSException jmse) {
                 System.out.println("Successfully got session.commit " +
                                    "exception in ejb");
             }
@@ -119,7 +116,7 @@
                 session.rollback();
                 throw new JMSException
                     ("Didn't get session.rollback exception");
-            } catch(javax.jms.JMSException jmse) {
+            } catch(jakarta.jms.JMSException jmse) {
                 System.out.println("Successfully got session.rollback " +
                                    "exception in ejb");
             }
@@ -148,11 +145,11 @@
                         session.createObjectMessage();
                         throw new JMSException
                             ("Didn't get expected illegal state exception");
-                    } catch(javax.jms.IllegalStateException j1) {
+                    } catch(jakarta.jms.IllegalStateException j1) {
                         System.out.println
                             ("Successfully got illegal state exception " +
                              "when calling session method after close");
-                    } catch(javax.jms.JMSException j2) {
+                    } catch(jakarta.jms.JMSException j2) {
                         throw new JMSException("Got wrong jmsexception");
                     }
                     
@@ -160,11 +157,11 @@
                         session.getMessageListener();
                         throw new JMSException
                             ("Didn't get expected illegal state exception");
-                    } catch(javax.jms.IllegalStateException j3) {
+                    } catch(jakarta.jms.IllegalStateException j3) {
                         System.out.println
                             ("Successfully got illegal state exception " +
                              "when calling session method after close");
-                    } catch(javax.jms.JMSException j4) {
+                    } catch(jakarta.jms.JMSException j4) {
                         throw new JMSException("Got wrong jmsexception");
                     }
                 }
diff --git a/appserver/tests/appserv-tests/devtests/ejb/jms/jmsejb2/client/Client.java b/appserver/tests/appserv-tests/devtests/ejb/jms/jmsejb2/client/Client.java
index 91d3712..d298129 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/jms/jmsejb2/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/ejb/jms/jmsejb2/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,15 +16,9 @@
 
 package com.sun.s1asdev.ejb.jms.jmsejb2.client;
 
-import java.io.*;
-import java.util.*;
-import javax.ejb.EJBHome;
 import javax.naming.*;
 import javax.rmi.PortableRemoteObject;
-import org.omg.CORBA.ORB;
-import java.sql.*;
-import javax.sql.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import com.sun.s1asdev.ejb.jms.jmsejb2.HelloHome;
 import com.sun.s1asdev.ejb.jms.jmsejb2.Hello;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
diff --git a/appserver/tests/appserv-tests/devtests/ejb/jms/jmsejb2/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/ejb/jms/jmsejb2/create_resources.asadmin
index 0f5080f..6417c84 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/jms/jmsejb2/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/ejb/jms/jmsejb2/create_resources.asadmin
@@ -1,7 +1,7 @@
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/ejb_jms_jmsejb2_QCF
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/ejb_jms_jmsejb2_QCF
 
 create-jmsdest --desttype queue ejb_jms_jmsejb2_Queue
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=ejb_jms_jmsejb2_Queue jms/ejb_jms_jmsejb2_Queue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=ejb_jms_jmsejb2_Queue jms/ejb_jms_jmsejb2_Queue
 
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/ejb/jms/jmsejb2/descriptor/ejb-jar.xml b/appserver/tests/appserv-tests/devtests/ejb/jms/jmsejb2/descriptor/ejb-jar.xml
index 5f608de..545ae5e 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/jms/jmsejb2/descriptor/ejb-jar.xml
+++ b/appserver/tests/appserv-tests/devtests/ejb/jms/jmsejb2/descriptor/ejb-jar.xml
@@ -2,7 +2,7 @@
 <!DOCTYPE ejb-jar PUBLIC "-//Sun Microsystems, Inc.//DTD Enterprise JavaBeans 2.0//EN" "http://java.sun.com/dtd/ejb-jar_2_0.dtd">
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -35,13 +35,13 @@
       <resource-ref>
         <description>description</description>
         <res-ref-name>jms/MyQueueConnectionFactory</res-ref-name>
-        <res-type>javax.jms.QueueConnectionFactory</res-type>
+        <res-type>jakarta.jms.QueueConnectionFactory</res-type>
         <res-auth>Container</res-auth>
         <res-sharing-scope>Shareable</res-sharing-scope>
       </resource-ref>
       <resource-env-ref>
         <resource-env-ref-name>jms/QueueName</resource-env-ref-name>
-        <resource-env-ref-type>javax.jms.Queue</resource-env-ref-type>
+        <resource-env-ref-type>jakarta.jms.Queue</resource-env-ref-type>
       </resource-env-ref>
     </session>
   </enterprise-beans>
diff --git a/appserver/tests/appserv-tests/devtests/ejb/jms/jmsejb2/ejb/HelloBean.java b/appserver/tests/appserv-tests/devtests/ejb/jms/jmsejb2/ejb/HelloBean.java
index 806ef65..d8522bd 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/jms/jmsejb2/ejb/HelloBean.java
+++ b/appserver/tests/appserv-tests/devtests/ejb/jms/jmsejb2/ejb/HelloBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,15 +16,12 @@
 
 package com.sun.s1asdev.ejb.jms.jmsejb2;
 
-import java.util.Enumeration;
-import java.io.Serializable;
 import java.rmi.RemoteException; 
 import javax.ejb.SessionBean;
 import javax.ejb.SessionContext;
 import javax.ejb.EJBException;
 import javax.naming.*;
-import javax.jms.*;
-import javax.transaction.UserTransaction;
+import jakarta.jms.*;
 
 public class HelloBean implements SessionBean {
     private String str;
diff --git a/appserver/tests/appserv-tests/devtests/ejb/mdb/cmt/client/Client.java b/appserver/tests/appserv-tests/devtests/ejb/mdb/cmt/client/Client.java
index 5f9b798..5c42b13 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/mdb/cmt/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/ejb/mdb/cmt/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2002, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2002, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,7 +20,7 @@
 import java.util.*;
 import javax.ejb.EJBHome;
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
@@ -43,7 +43,7 @@
     private QueueSession queueSession;
     private QueueSender queueSender;
     private QueueReceiver queueReceiver;
-    private javax.jms.Queue clientQueue;
+    private jakarta.jms.Queue clientQueue;
 
     private TopicConnection topicCon;
     private TopicSession topicSession;
@@ -114,7 +114,7 @@
         }
     }
 
-    public void sendMsgs(javax.jms.Queue queue, Message msg, int num) 
+    public void sendMsgs(jakarta.jms.Queue queue, Message msg, int num) 
         throws JMSException {
         for(int i = 0; i < num; i++) {
             System.out.println("Sending message " + i + " to " + queue + 
@@ -143,7 +143,7 @@
         //        Message message = topicSession.createTextMessage(destName);
         message.setBooleanProperty("flag", true);
         message.setIntProperty("num", 2);
-        sendMsgs((javax.jms.Queue) dest, message, num);
+        sendMsgs((jakarta.jms.Queue) dest, message, num);
     }
 }
 
diff --git a/appserver/tests/appserv-tests/devtests/ejb/mdb/cmt/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/ejb/mdb/cmt/create_resources.asadmin
index 0f83e41..7e3e7e0 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/mdb/cmt/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/ejb/mdb/cmt/create_resources.asadmin
@@ -1,5 +1,5 @@
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/ejb_mdb_cmt_QCF
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/ejb_mdb_cmt_QCF
 create-jmsdest --desttype queue ejb_mdb_cmt_InQueue 
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=ejb_mdb_cmt_InQueue jms/ejb_mdb_cmt_InQueue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=ejb_mdb_cmt_InQueue jms/ejb_mdb_cmt_InQueue
 create-jmsdest --desttype queue ejb_mdb_cmt_OutQueue 
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=ejb_mdb_cmt_OutQueue jms/ejb_mdb_cmt_OutQueue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=ejb_mdb_cmt_OutQueue jms/ejb_mdb_cmt_OutQueue
diff --git a/appserver/tests/appserv-tests/devtests/ejb/mdb/cmt/descriptor/application-client.xml b/appserver/tests/appserv-tests/devtests/ejb/mdb/cmt/descriptor/application-client.xml
index a564a30..f9c4405 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/mdb/cmt/descriptor/application-client.xml
+++ b/appserver/tests/appserv-tests/devtests/ejb/mdb/cmt/descriptor/application-client.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -21,7 +21,7 @@
   <display-name>ejb-mdb-cmtClient</display-name>
   <resource-ref>
     <res-ref-name>FooCF</res-ref-name>
-    <res-type>javax.jms.QueueConnectionFactory</res-type>
+    <res-type>jakarta.jms.QueueConnectionFactory</res-type>
     <res-auth>Container</res-auth>
     <res-sharing-scope>Shareable</res-sharing-scope>
   </resource-ref>
@@ -29,7 +29,7 @@
      <description>test destination</description>
      <message-destination-ref-name>jms/MsgBeanQueue
      </message-destination-ref-name>
-     <message-destination-type>javax.jms.Queue</message-destination-type>
+     <message-destination-type>jakarta.jms.Queue</message-destination-type>
      <message-destination-usage>Produces</message-destination-usage>
      <message-destination-link>MsgBeanInQueue</message-destination-link>
   </message-destination-ref>
@@ -37,7 +37,7 @@
      <description>test explicit reference to another .jar msg dest</description>
      <message-destination-ref-name>jms/testref
      </message-destination-ref-name>
-     <message-destination-type>javax.jms.Queue</message-destination-type>
+     <message-destination-type>jakarta.jms.Queue</message-destination-type>
      <message-destination-usage>Produces</message-destination-usage>
      <message-destination-link>ejb-mdb-cmt-ejb.jar#MsgBeanInQueue
      </message-destination-link>
diff --git a/appserver/tests/appserv-tests/devtests/ejb/mdb/cmt/descriptor/ejb-jar.xml b/appserver/tests/appserv-tests/devtests/ejb/mdb/cmt/descriptor/ejb-jar.xml
index 7da3842..13843d9 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/mdb/cmt/descriptor/ejb-jar.xml
+++ b/appserver/tests/appserv-tests/devtests/ejb/mdb/cmt/descriptor/ejb-jar.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -24,14 +24,14 @@
       <display-name>MDB1</display-name>
       <ejb-name>MDB1</ejb-name>
       <ejb-class>com.sun.s1asdev.ejb.mdb.cmt.MessageBean</ejb-class>
-      <messaging-type>javax.jms.MessageListener</messaging-type>
+      <messaging-type>jakarta.jms.MessageListener</messaging-type>
       <transaction-type>Container</transaction-type>
-      <message-destination-type>javax.jms.Queue</message-destination-type>
+      <message-destination-type>jakarta.jms.Queue</message-destination-type>
       <message-destination-link>MsgBeanInQueue</message-destination-link>
       <resource-ref>
         <description>description</description>
         <res-ref-name>jms/MyQueueConnectionFactory</res-ref-name>
-        <res-type>javax.jms.QueueConnectionFactory</res-type>
+        <res-type>jakarta.jms.QueueConnectionFactory</res-type>
         <res-auth>Container</res-auth>
         <res-sharing-scope>Shareable</res-sharing-scope>
       </resource-ref>
@@ -39,7 +39,7 @@
         <description>test destination</description>
         <message-destination-ref-name>jms/MyQueue
         </message-destination-ref-name>
-        <message-destination-type>javax.jms.Queue</message-destination-type>
+        <message-destination-type>jakarta.jms.Queue</message-destination-type>
         <message-destination-usage>Consumes</message-destination-usage>
         <message-destination-link>MsgBeanOutQueue</message-destination-link>
       </message-destination-ref>
@@ -54,7 +54,7 @@
         <ejb-name>MDB1</ejb-name>
         <method-name>onMessage</method-name>
         <method-params>
-          <method-param>javax.jms.Message</method-param>
+          <method-param>jakarta.jms.Message</method-param>
         </method-params>
       </method>
       <trans-attribute>Required</trans-attribute>
diff --git a/appserver/tests/appserv-tests/devtests/ejb/mdb/cmt/ejb/MessageBean.java b/appserver/tests/appserv-tests/devtests/ejb/mdb/cmt/ejb/MessageBean.java
index e5ef330..7f3c36f 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/mdb/cmt/ejb/MessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/ejb/mdb/cmt/ejb/MessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,9 +17,8 @@
 package com.sun.s1asdev.ejb.mdb.cmt;
 
 import java.rmi.RemoteException;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.ejb.*;
-import java.io.Serializable;
 import javax.naming.*;
 
 public class MessageBean  
diff --git a/appserver/tests/appserv-tests/devtests/ejb/mdb/msgbean/client/HelloClient.java b/appserver/tests/appserv-tests/devtests/ejb/mdb/msgbean/client/HelloClient.java
index ea3fd5c..1052069 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/mdb/msgbean/client/HelloClient.java
+++ b/appserver/tests/appserv-tests/devtests/ejb/mdb/msgbean/client/HelloClient.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2002, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2002, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,15 +16,8 @@
 
 package com.sun.s1asdev.ejb.mdb.msgbean.client;
 
-import java.io.*;
-import java.util.*;
-import javax.ejb.EJBHome;
 import javax.naming.*;
-import javax.rmi.PortableRemoteObject;
-import org.omg.CORBA.ORB;
-import java.sql.*;
-import javax.sql.*;
-import javax.jms.*;
+import jakarta.jms.*;
 
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
@@ -51,7 +44,7 @@
     private QueueSession queueSession;
     private QueueSender queueSender;
     private QueueReceiver queueReceiver;
-    private javax.jms.Queue clientQueue;
+    private jakarta.jms.Queue clientQueue;
 
 
     private TopicConnection topicCon;
@@ -213,7 +206,7 @@
         // Producer will be specified when actual msg is sent.
         queueSender = queueSession.createSender(null);        
 
-        clientQueue = (javax.jms.Queue) 
+        clientQueue = (jakarta.jms.Queue) 
             context.lookup("java:comp/env/jms/client_queue");
 
         queueReceiver = queueSession.createReceiver(clientQueue);
@@ -256,7 +249,7 @@
         }
     }
 
-    public void sendMsgs(javax.jms.Queue queue, Message msg, int num) 
+    public void sendMsgs(jakarta.jms.Queue queue, Message msg, int num) 
         throws JMSException {
         for(int i = 0; i < num; i++) {
             System.out.println("Sending message " + i + " to " + queue);
@@ -333,7 +326,7 @@
         try {
             Destination dest = (Destination) context.lookup(destName);
             
-            boolean pointToPoint = dest instanceof javax.jms.Queue;
+            boolean pointToPoint = dest instanceof jakarta.jms.Queue;
             
             System.out.println("Beginning test : " + testName);
             
@@ -353,7 +346,7 @@
                 if( expectReply ) {
                     message.setJMSReplyTo(clientQueue);
                 }
-                sendMsgs((javax.jms.Queue) dest, message, numIter);
+                sendMsgs((jakarta.jms.Queue) dest, message, numIter);
             } else {
                 Message message = 
                     topicSession.createTextMessage(destName);
diff --git a/appserver/tests/appserv-tests/devtests/ejb/mdb/msgbean/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/ejb/mdb/msgbean/create_resources.asadmin
index c4e4e8c..63033f2 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/mdb/msgbean/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/ejb/mdb/msgbean/create_resources.asadmin
@@ -1,20 +1,20 @@
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/ejb_mdb_msgbean_QCF
-create-jms-resource --restype javax.jms.TopicConnectionFactory jms/ejb_mdb_msgbean_TCF
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/ejb_mdb_msgbean_QCF
+create-jms-resource --restype jakarta.jms.TopicConnectionFactory jms/ejb_mdb_msgbean_TCF
 create-jmsdest --desttype queue ejb_mdb_msgbean_client_queue
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=ejb_mdb_msgbean_client_queue jms/ejb_mdb_msgbean_client_queue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=ejb_mdb_msgbean_client_queue jms/ejb_mdb_msgbean_client_queue
 create-jmsdest --desttype topic ejb_mdb_msgbean_client_topic
-create-jms-resource --restype javax.jms.Topic --property imqDestinationName=ejb_mdb_msgbean_client_topic jms/ejb_mdb_msgbean_client_topic
+create-jms-resource --restype jakarta.jms.Topic --property imqDestinationName=ejb_mdb_msgbean_client_topic jms/ejb_mdb_msgbean_client_topic
 create-jmsdest --desttype queue ejb_mdb_msgbean_queue_cmt
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=ejb_mdb_msgbean_queue_cmt jms/ejb_mdb_msgbean_queue_cmt
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=ejb_mdb_msgbean_queue_cmt jms/ejb_mdb_msgbean_queue_cmt
 create-jmsdest --desttype queue ejb_mdb_msgbean_queue_bmt
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=ejb_mdb_msgbean_queue_bmt jms/ejb_mdb_msgbean_queue_bmt
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=ejb_mdb_msgbean_queue_bmt jms/ejb_mdb_msgbean_queue_bmt
 create-jmsdest --desttype queue ejb_mdb_msgbean_queue_cmtns
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=ejb_mdb_msgbean_queue_cmtns jms/ejb_mdb_msgbean_queue_cmtns
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=ejb_mdb_msgbean_queue_cmtns jms/ejb_mdb_msgbean_queue_cmtns
 create-jmsdest --desttype topic ejb_mdb_msgbean_topic_cmt
-create-jms-resource --restype javax.jms.Topic --property imqDestinationName=ejb_mdb_msgbean_topic_cmt jms/ejb_mdb_msgbean_topic_cmt
+create-jms-resource --restype jakarta.jms.Topic --property imqDestinationName=ejb_mdb_msgbean_topic_cmt jms/ejb_mdb_msgbean_topic_cmt
 create-jmsdest --desttype topic ejb_mdb_msgbean_topic_bmt
-create-jms-resource --restype javax.jms.Topic --property imqDestinationName=ejb_mdb_msgbean_topic_bmt jms/ejb_mdb_msgbean_topic_bmt
+create-jms-resource --restype jakarta.jms.Topic --property imqDestinationName=ejb_mdb_msgbean_topic_bmt jms/ejb_mdb_msgbean_topic_bmt
 create-jmsdest --desttype topic ejb_mdb_msgbean_op_test_topic
-create-jms-resource --restype javax.jms.Topic --property imqDestinationName=ejb_mdb_msgbean_op_test_topic jms/ejb_mdb_msgbean_op_test_topic
+create-jms-resource --restype jakarta.jms.Topic --property imqDestinationName=ejb_mdb_msgbean_op_test_topic jms/ejb_mdb_msgbean_op_test_topic
 create-jmsdest --desttype queue ejb_mdb_msgbean_op_test_queue
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=ejb_mdb_msgbean_op_test_queue jms/ejb_mdb_msgbean_op_test_queue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=ejb_mdb_msgbean_op_test_queue jms/ejb_mdb_msgbean_op_test_queue
diff --git a/appserver/tests/appserv-tests/devtests/ejb/mdb/msgbean/descriptor/application-client.xml b/appserver/tests/appserv-tests/devtests/ejb/mdb/msgbean/descriptor/application-client.xml
index f958aa5..7151f29 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/mdb/msgbean/descriptor/application-client.xml
+++ b/appserver/tests/appserv-tests/devtests/ejb/mdb/msgbean/descriptor/application-client.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -21,13 +21,13 @@
   <display-name>ejb-mdb-msgbeanClient</display-name>
   <resource-ref>
     <res-ref-name>jms/QCF</res-ref-name>
-    <res-type>javax.jms.QueueConnectionFactory</res-type>
+    <res-type>jakarta.jms.QueueConnectionFactory</res-type>
     <res-auth>Container</res-auth>
     <res-sharing-scope>Shareable</res-sharing-scope>
   </resource-ref>
   <resource-ref>
     <res-ref-name>jms/TCF</res-ref-name>
-    <res-type>javax.jms.TopicConnectionFactory</res-type>
+    <res-type>jakarta.jms.TopicConnectionFactory</res-type>
     <res-auth>Container</res-auth>
     <res-sharing-scope>Shareable</res-sharing-scope>
   </resource-ref>
@@ -35,7 +35,7 @@
      <description>test destination</description>
      <message-destination-ref-name>jms/client_queue
      </message-destination-ref-name>
-     <message-destination-type>javax.jms.Queue</message-destination-type>
+     <message-destination-type>jakarta.jms.Queue</message-destination-type>
      <message-destination-usage>Produces</message-destination-usage>
      <message-destination-link>client_queue</message-destination-link>
   </message-destination-ref>
@@ -43,7 +43,7 @@
      <description>test destination</description>
      <message-destination-ref-name>jms/client_topic
      </message-destination-ref-name>
-     <message-destination-type>javax.jms.Topic</message-destination-type>
+     <message-destination-type>jakarta.jms.Topic</message-destination-type>
      <message-destination-usage>Produces</message-destination-usage>
      <message-destination-link>client_topic</message-destination-link>
   </message-destination-ref>
@@ -51,7 +51,7 @@
      <description>test destination</description>
      <message-destination-ref-name>jms/queue_cmt
      </message-destination-ref-name>
-     <message-destination-type>javax.jms.Queue</message-destination-type>
+     <message-destination-type>jakarta.jms.Queue</message-destination-type>
      <message-destination-usage>Produces</message-destination-usage>
      <message-destination-link>queue_cmt</message-destination-link>
   </message-destination-ref>
@@ -59,7 +59,7 @@
      <description>test destination</description>
      <message-destination-ref-name>jms/queue_bmt
      </message-destination-ref-name>
-     <message-destination-type>javax.jms.Queue</message-destination-type>
+     <message-destination-type>jakarta.jms.Queue</message-destination-type>
      <message-destination-usage>Produces</message-destination-usage>
      <message-destination-link>queue_bmt</message-destination-link>
   </message-destination-ref>
@@ -67,7 +67,7 @@
      <description>test destination</description>
      <message-destination-ref-name>jms/queue_cmtns
      </message-destination-ref-name>
-     <message-destination-type>javax.jms.Queue</message-destination-type>
+     <message-destination-type>jakarta.jms.Queue</message-destination-type>
      <message-destination-usage>Produces</message-destination-usage>
      <message-destination-link>queue_cmtns</message-destination-link>
   </message-destination-ref>
@@ -75,7 +75,7 @@
      <description>test destination</description>
      <message-destination-ref-name>jms/topic_cmt
      </message-destination-ref-name>
-     <message-destination-type>javax.jms.Topic</message-destination-type>
+     <message-destination-type>jakarta.jms.Topic</message-destination-type>
      <message-destination-usage>Produces</message-destination-usage>
      <message-destination-link>topic_cmt</message-destination-link>
   </message-destination-ref>
@@ -83,7 +83,7 @@
      <description>test destination</description>
      <message-destination-ref-name>jms/topic_bmt
      </message-destination-ref-name>
-     <message-destination-type>javax.jms.Topic</message-destination-type>
+     <message-destination-type>jakarta.jms.Topic</message-destination-type>
      <message-destination-usage>Produces</message-destination-usage>
      <message-destination-link>topic_cmt</message-destination-link>
   </message-destination-ref>
diff --git a/appserver/tests/appserv-tests/devtests/ejb/mdb/msgbean/descriptor/ejb-jar.xml b/appserver/tests/appserv-tests/devtests/ejb/mdb/msgbean/descriptor/ejb-jar.xml
index 63afe07..86df82d 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/mdb/msgbean/descriptor/ejb-jar.xml
+++ b/appserver/tests/appserv-tests/devtests/ejb/mdb/msgbean/descriptor/ejb-jar.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -24,9 +24,9 @@
       <display-name>MDB_QUEUE_BMT</display-name>
       <ejb-name>MDB_QUEUE_BMT</ejb-name>
       <ejb-class>com.sun.s1asdev.ejb.mdb.msgbean.MsgBean</ejb-class>
-      <messaging-type>javax.jms.MessageListener</messaging-type>
+      <messaging-type>jakarta.jms.MessageListener</messaging-type>
       <transaction-type>Bean</transaction-type>
-      <message-destination-type>javax.jms.Queue</message-destination-type>
+      <message-destination-type>jakarta.jms.Queue</message-destination-type>
       <env-entry>
         <env-entry-name>beanManagedTx</env-entry-name>
         <env-entry-type>java.lang.Boolean</env-entry-type>
@@ -35,14 +35,14 @@
       <resource-ref>
         <description>description</description>
         <res-ref-name>jms/MyQueueConnectionFactory</res-ref-name>
-        <res-type>javax.jms.QueueConnectionFactory</res-type>
+        <res-type>jakarta.jms.QueueConnectionFactory</res-type>
         <res-auth>Container</res-auth>
         <res-sharing-scope>Shareable</res-sharing-scope>
       </resource-ref>
       <resource-ref>
         <description>description</description>
         <res-ref-name>jms/MyTopicConnectionFactory</res-ref-name>
-        <res-type>javax.jms.TopicConnectionFactory</res-type>
+        <res-type>jakarta.jms.TopicConnectionFactory</res-type>
         <res-auth>Container</res-auth>
         <res-sharing-scope>Shareable</res-sharing-scope>
       </resource-ref>
@@ -61,9 +61,9 @@
       <display-name>MDB_QUEUE_CMT</display-name>
       <ejb-name>MDB_QUEUE_CMT</ejb-name>
       <ejb-class>com.sun.s1asdev.ejb.mdb.msgbean.MsgBean</ejb-class>
-      <messaging-type>javax.jms.MessageListener</messaging-type>
+      <messaging-type>jakarta.jms.MessageListener</messaging-type>
       <transaction-type>Container</transaction-type>
-      <message-destination-type>javax.jms.Queue</message-destination-type>
+      <message-destination-type>jakarta.jms.Queue</message-destination-type>
       <env-entry>
         <env-entry-name>beanManagedTx</env-entry-name>
         <env-entry-type>java.lang.Boolean</env-entry-type>
@@ -72,14 +72,14 @@
       <resource-ref>
         <description>description</description>
         <res-ref-name>jms/MyQueueConnectionFactory</res-ref-name>
-        <res-type>javax.jms.QueueConnectionFactory</res-type>
+        <res-type>jakarta.jms.QueueConnectionFactory</res-type>
         <res-auth>Container</res-auth>
         <res-sharing-scope>Shareable</res-sharing-scope>
       </resource-ref>
       <resource-ref>
         <description>description</description>
         <res-ref-name>jms/MyTopicConnectionFactory</res-ref-name>
-        <res-type>javax.jms.TopicConnectionFactory</res-type>
+        <res-type>jakarta.jms.TopicConnectionFactory</res-type>
         <res-auth>Container</res-auth>
         <res-sharing-scope>Shareable</res-sharing-scope>
       </resource-ref>
@@ -95,9 +95,9 @@
       <display-name>operationtestqueue</display-name>
       <ejb-name>operationtestqueue</ejb-name>
       <ejb-class>com.sun.s1asdev.ejb.mdb.msgbean.OperationTestMsgBean</ejb-class>
-      <messaging-type>javax.jms.MessageListener</messaging-type>
+      <messaging-type>jakarta.jms.MessageListener</messaging-type>
       <transaction-type>Bean</transaction-type>
-      <message-destination-type>javax.jms.Queue</message-destination-type>
+      <message-destination-type>jakarta.jms.Queue</message-destination-type>
       <env-entry>
         <env-entry-name>beanManagedTx</env-entry-name>
         <env-entry-type>java.lang.Boolean</env-entry-type>
@@ -113,9 +113,9 @@
       <display-name>operationtesttopic</display-name>
       <ejb-name>operationtesttopic</ejb-name>
       <ejb-class>com.sun.s1asdev.ejb.mdb.msgbean.OperationTestMsgBean</ejb-class>
-      <messaging-type>javax.jms.MessageListener</messaging-type>
+      <messaging-type>jakarta.jms.MessageListener</messaging-type>
       <transaction-type>Bean</transaction-type>
-      <message-destination-type>javax.jms.Topic</message-destination-type>
+      <message-destination-type>jakarta.jms.Topic</message-destination-type>
       <env-entry>
         <env-entry-name>beanManagedTx</env-entry-name>
         <env-entry-type>java.lang.Boolean</env-entry-type>
@@ -131,9 +131,9 @@
       <display-name>MDB_TOPIC_CMT</display-name>
       <ejb-name>MDB_TOPIC_CMT</ejb-name>
       <ejb-class>com.sun.s1asdev.ejb.mdb.msgbean.MsgBean</ejb-class>
-      <messaging-type>javax.jms.MessageListener</messaging-type>
+      <messaging-type>jakarta.jms.MessageListener</messaging-type>
       <transaction-type>Container</transaction-type>
-      <message-destination-type>javax.jms.Topic</message-destination-type>
+      <message-destination-type>jakarta.jms.Topic</message-destination-type>
       <env-entry>
         <env-entry-name>beanManagedTx</env-entry-name>
         <env-entry-type>java.lang.Boolean</env-entry-type>
@@ -142,14 +142,14 @@
       <resource-ref>
         <description>description</description>
         <res-ref-name>jms/MyQueueConnectionFactory</res-ref-name>
-        <res-type>javax.jms.QueueConnectionFactory</res-type>
+        <res-type>jakarta.jms.QueueConnectionFactory</res-type>
         <res-auth>Container</res-auth>
         <res-sharing-scope>Shareable</res-sharing-scope>
       </resource-ref>
       <resource-ref>
         <description>description</description>
         <res-ref-name>jms/MyTopicConnectionFactory</res-ref-name>
-        <res-type>javax.jms.TopicConnectionFactory</res-type>
+        <res-type>jakarta.jms.TopicConnectionFactory</res-type>
         <res-auth>Container</res-auth>
         <res-sharing-scope>Shareable</res-sharing-scope>
       </resource-ref>
@@ -165,9 +165,9 @@
       <display-name>MDB_QUEUE_CMTNS</display-name>
       <ejb-name>MDB_QUEUE_CMTNS</ejb-name>
       <ejb-class>com.sun.s1asdev.ejb.mdb.msgbean.MsgBean</ejb-class>
-      <messaging-type>javax.jms.MessageListener</messaging-type>
+      <messaging-type>jakarta.jms.MessageListener</messaging-type>
       <transaction-type>Container</transaction-type>
-      <message-destination-type>javax.jms.Queue</message-destination-type>
+      <message-destination-type>jakarta.jms.Queue</message-destination-type>
       <env-entry>
         <env-entry-name>beanManagedTx</env-entry-name>
         <env-entry-type>java.lang.Boolean</env-entry-type>
@@ -176,14 +176,14 @@
       <resource-ref>
         <description>description</description>
         <res-ref-name>jms/MyQueueConnectionFactory</res-ref-name>
-        <res-type>javax.jms.QueueConnectionFactory</res-type>
+        <res-type>jakarta.jms.QueueConnectionFactory</res-type>
         <res-auth>Container</res-auth>
         <res-sharing-scope>Shareable</res-sharing-scope>
       </resource-ref>
       <resource-ref>
         <description>description</description>
         <res-ref-name>jms/MyTopicConnectionFactory</res-ref-name>
-        <res-type>javax.jms.TopicConnectionFactory</res-type>
+        <res-type>jakarta.jms.TopicConnectionFactory</res-type>
         <res-auth>Container</res-auth>
         <res-sharing-scope>Shareable</res-sharing-scope>
       </resource-ref>
@@ -199,9 +199,9 @@
       <display-name>MDB_TOPIC_BMT</display-name>
       <ejb-name>MDB_TOPIC_BMT</ejb-name>
       <ejb-class>com.sun.s1asdev.ejb.mdb.msgbean.MsgBean</ejb-class>
-      <messaging-type>javax.jms.MessageListener</messaging-type>
+      <messaging-type>jakarta.jms.MessageListener</messaging-type>
       <transaction-type>Bean</transaction-type>
-      <message-destination-type>javax.jms.Topic</message-destination-type>
+      <message-destination-type>jakarta.jms.Topic</message-destination-type>
       <env-entry>
         <env-entry-name>beanManagedTx</env-entry-name>
         <env-entry-type>java.lang.Boolean</env-entry-type>
@@ -210,14 +210,14 @@
       <resource-ref>
         <description>description</description>
         <res-ref-name>jms/MyQueueConnectionFactory</res-ref-name>
-        <res-type>javax.jms.QueueConnectionFactory</res-type>
+        <res-type>jakarta.jms.QueueConnectionFactory</res-type>
         <res-auth>Container</res-auth>
         <res-sharing-scope>Shareable</res-sharing-scope>
       </resource-ref>
       <resource-ref>
         <description>description</description>
         <res-ref-name>jms/MyTopicConnectionFactory</res-ref-name>
-        <res-type>javax.jms.TopicConnectionFactory</res-type>
+        <res-type>jakarta.jms.TopicConnectionFactory</res-type>
         <res-auth>Container</res-auth>
         <res-sharing-scope>Shareable</res-sharing-scope>
       </resource-ref>
@@ -236,7 +236,7 @@
         <ejb-name>MDB_QUEUE_CMT</ejb-name>
         <method-name>onMessage</method-name>
         <method-params>
-          <method-param>javax.jms.Message</method-param>
+          <method-param>jakarta.jms.Message</method-param>
         </method-params>
       </method>
       <trans-attribute>Required</trans-attribute>
@@ -246,7 +246,7 @@
         <ejb-name>MDB_TOPIC_CMT</ejb-name>
         <method-name>onMessage</method-name>
         <method-params>
-          <method-param>javax.jms.Message</method-param>
+          <method-param>jakarta.jms.Message</method-param>
         </method-params>
       </method>
       <trans-attribute>Required</trans-attribute>
@@ -256,7 +256,7 @@
         <ejb-name>MDB_QUEUE_CMTNS</ejb-name>
         <method-name>onMessage</method-name>
         <method-params>
-          <method-param>javax.jms.Message</method-param>
+          <method-param>jakarta.jms.Message</method-param>
         </method-params>
       </method>
       <trans-attribute>NotSupported</trans-attribute>
diff --git a/appserver/tests/appserv-tests/devtests/ejb/mdb/msgbean/ejb/MsgBean.java b/appserver/tests/appserv-tests/devtests/ejb/mdb/msgbean/ejb/MsgBean.java
index c00b7d1..7daac5a 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/mdb/msgbean/ejb/MsgBean.java
+++ b/appserver/tests/appserv-tests/devtests/ejb/mdb/msgbean/ejb/MsgBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2002, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2002, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,13 +17,11 @@
 package com.sun.s1asdev.ejb.mdb.msgbean;
 
 import java.util.Vector;
-import java.io.Serializable;
-import java.rmi.RemoteException; 
 import javax.ejb.EJBException;
 import javax.ejb.MessageDrivenBean;
 import javax.ejb.MessageDrivenContext;
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import java.sql.*;
 import javax.sql.*;
 
diff --git a/appserver/tests/appserv-tests/devtests/ejb/mdb/msgbean/ejb/OperationTestMsgBean.java b/appserver/tests/appserv-tests/devtests/ejb/mdb/msgbean/ejb/OperationTestMsgBean.java
index 32168f9..c790707 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/mdb/msgbean/ejb/OperationTestMsgBean.java
+++ b/appserver/tests/appserv-tests/devtests/ejb/mdb/msgbean/ejb/OperationTestMsgBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2002, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2002, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,14 +16,10 @@
 
 package com.sun.s1asdev.ejb.mdb.msgbean;
 
-import java.io.Serializable;
-import java.rmi.RemoteException; 
-import javax.ejb.EJBException;
 import javax.ejb.MessageDrivenBean;
 import javax.ejb.MessageDrivenContext;
-import javax.jms.Message;
-import javax.jms.MessageListener;
-import javax.rmi.PortableRemoteObject;
+import jakarta.jms.Message;
+import jakarta.jms.MessageListener;
 import javax.naming.*;
 
 public class OperationTestMsgBean implements MessageDrivenBean, 
diff --git a/appserver/tests/appserv-tests/devtests/ejb/mdb/singleton/client/Client.java b/appserver/tests/appserv-tests/devtests/ejb/mdb/singleton/client/Client.java
index ad13c10..26411b8 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/mdb/singleton/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/ejb/mdb/singleton/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2011, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2011, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,10 +16,9 @@
 
 package com.sun.s1asdev.ejb.mdb.singleton.client;
 
-import java.io.*;
 import java.util.*;
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.annotation.*;
 import javax.ejb.*;
 import com.sun.s1asdev.ejb.mdb.singleton.FooRemoteIF;
@@ -51,7 +50,7 @@
     private QueueSession queueSession;
     private QueueSender queueSender;
     private QueueReceiver queueReceiver;
-    private javax.jms.Queue clientQueue;
+    private jakarta.jms.Queue clientQueue;
 
     private int numMessages = 1;
     private int numOfCalls = 120;
@@ -120,7 +119,7 @@
         }
     }
 
-    public void sendMsgs(javax.jms.Queue queue, Message msg, int num) 
+    public void sendMsgs(jakarta.jms.Queue queue, Message msg, int num) 
         throws JMSException {
         for(int i = 0; i < num; i++) {
             //System.out.println("Sending message " + i + " to " + queue + 
@@ -139,7 +138,7 @@
             //        Message message = topicSession.createTextMessage(destName);
             message.setBooleanProperty("flag", true);
             message.setIntProperty("num", i);
-            sendMsgs((javax.jms.Queue) dest, message, num);
+            sendMsgs((jakarta.jms.Queue) dest, message, num);
         }
 
         List<String> messageBeanInstances = new ArrayList<String>();
diff --git a/appserver/tests/appserv-tests/devtests/ejb/mdb/singleton/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/ejb/mdb/singleton/create_resources.asadmin
index 04a6de7..7258604 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/mdb/singleton/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/ejb/mdb/singleton/create_resources.asadmin
@@ -1,5 +1,5 @@
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/ejb_mdb_singleton_QCF
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/ejb_mdb_singleton_QCF
 create-jmsdest --desttype queue ejb_mdb_singleton_InQueue 
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=ejb_mdb_singleton_InQueue jms/ejb_mdb_singleton_InQueue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=ejb_mdb_singleton_InQueue jms/ejb_mdb_singleton_InQueue
 create-jmsdest --desttype queue ejb_mdb_singleton_OutQueue 
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=ejb_mdb_singleton_OutQueue jms/ejb_mdb_singleton_OutQueue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=ejb_mdb_singleton_OutQueue jms/ejb_mdb_singleton_OutQueue
diff --git a/appserver/tests/appserv-tests/devtests/ejb/mdb/singleton/descriptor/application-client.xml b/appserver/tests/appserv-tests/devtests/ejb/mdb/singleton/descriptor/application-client.xml
index 739d7b2..088b5fa 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/mdb/singleton/descriptor/application-client.xml
+++ b/appserver/tests/appserv-tests/devtests/ejb/mdb/singleton/descriptor/application-client.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -23,7 +23,7 @@
   <display-name>ejb-mdb-singletonClient</display-name>
   <resource-ref>
     <res-ref-name>FooCF</res-ref-name>
-    <res-type>javax.jms.QueueConnectionFactory</res-type>
+    <res-type>jakarta.jms.QueueConnectionFactory</res-type>
     <res-auth>Container</res-auth>
     <res-sharing-scope>Shareable</res-sharing-scope>
   </resource-ref>
@@ -31,7 +31,7 @@
      <description>test destination</description>
      <message-destination-ref-name>jms/MsgBeanQueue
      </message-destination-ref-name>
-     <message-destination-type>javax.jms.Queue</message-destination-type>
+     <message-destination-type>jakarta.jms.Queue</message-destination-type>
      <message-destination-usage>Produces</message-destination-usage>
      <message-destination-link>MsgBeanInQueue</message-destination-link>
   </message-destination-ref>
@@ -39,7 +39,7 @@
      <description>test explicit reference to another .jar msg dest</description>
      <message-destination-ref-name>jms/testref
      </message-destination-ref-name>
-     <message-destination-type>javax.jms.Queue</message-destination-type>
+     <message-destination-type>jakarta.jms.Queue</message-destination-type>
      <message-destination-usage>Produces</message-destination-usage>
      <message-destination-link>ejb-mdb-singleton-ejb.jar#MsgBeanInQueue
      </message-destination-link>
diff --git a/appserver/tests/appserv-tests/devtests/ejb/mdb/singleton/descriptor/ejb-jar.xml b/appserver/tests/appserv-tests/devtests/ejb/mdb/singleton/descriptor/ejb-jar.xml
index 1e086c4..1735893 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/mdb/singleton/descriptor/ejb-jar.xml
+++ b/appserver/tests/appserv-tests/devtests/ejb/mdb/singleton/descriptor/ejb-jar.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -23,9 +23,9 @@
     <message-driven>
       <ejb-name>MessageBean</ejb-name>
       <ejb-class>com.sun.s1asdev.ejb.mdb.singleton.MessageBean</ejb-class>
-      <messaging-type>javax.jms.MessageListener</messaging-type>
+      <messaging-type>jakarta.jms.MessageListener</messaging-type>
       <transaction-type>Container</transaction-type>
-      <message-destination-type>javax.jms.Queue</message-destination-type>
+      <message-destination-type>jakarta.jms.Queue</message-destination-type>
       <message-destination-link>MsgBeanInQueue</message-destination-link>
     </message-driven>
   </enterprise-beans>
diff --git a/appserver/tests/appserv-tests/devtests/ejb/mdb/singleton/ejb/MessageBean.java b/appserver/tests/appserv-tests/devtests/ejb/mdb/singleton/ejb/MessageBean.java
index 2fd7d3a..3b40a7f 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/mdb/singleton/ejb/MessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/ejb/mdb/singleton/ejb/MessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,7 +16,7 @@
 
 package com.sun.s1asdev.ejb.mdb.singleton;
 
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.ejb.*;
 
 public class MessageBean implements  MessageListener {
diff --git a/appserver/tests/appserv-tests/devtests/ejb/perf/timer1/client/Client.java b/appserver/tests/appserv-tests/devtests/ejb/perf/timer1/client/Client.java
index 65d8ca7..4a613e4 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/perf/timer1/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/ejb/perf/timer1/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,8 +16,7 @@
 
 package com.sun.s1asdev.ejb.perf.timer1;
 
-import java.io.Serializable;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.ejb.*;
 import javax.annotation.Resource;
 
diff --git a/appserver/tests/appserv-tests/devtests/ejb/perf/timer1/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/ejb/perf/timer1/create_resources.asadmin
index 0ab9d1d..57ef077 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/perf/timer1/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/ejb/perf/timer1/create_resources.asadmin
@@ -1,7 +1,7 @@
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/ejb_perf_timer1_TQCF
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/ejb_perf_timer1_TQCF
 
 create-jmsdest --desttype queue ejb_perf_timer1_TQueue
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=ejb_perf_timer1_TQueue jms/ejb_perf_timer1_TQueue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=ejb_perf_timer1_TQueue jms/ejb_perf_timer1_TQueue
 
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/ejb/perf/timer1/ejb/TimerSessionEJB.java b/appserver/tests/appserv-tests/devtests/ejb/perf/timer1/ejb/TimerSessionEJB.java
index c46b95a..3e667b4 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/perf/timer1/ejb/TimerSessionEJB.java
+++ b/appserver/tests/appserv-tests/devtests/ejb/perf/timer1/ejb/TimerSessionEJB.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package com.sun.s1asdev.ejb.perf.timer1;
 
 import javax.ejb.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.annotation.*;
 import java.util.Date;
 
diff --git a/appserver/tests/appserv-tests/devtests/ejb/sfsb/cacheNPE/client/Client.java b/appserver/tests/appserv-tests/devtests/ejb/sfsb/cacheNPE/client/Client.java
index 246df06..3d823ae 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/sfsb/cacheNPE/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/ejb/sfsb/cacheNPE/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -18,12 +18,10 @@
 
 import java.util.ArrayList;
 
-import java.io.Serializable;
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.ejb.*;
 import javax.rmi.PortableRemoteObject;
-import java.rmi.NoSuchObjectException;
 
 import com.sun.s1asdev.ejb.sfsb.cacheNPE.ejb.SFSBHome;
 import com.sun.s1asdev.ejb.sfsb.cacheNPE.ejb.SFSB;
diff --git a/appserver/tests/appserv-tests/devtests/ejb/sfsb/keepstate/client/Client.java b/appserver/tests/appserv-tests/devtests/ejb/sfsb/keepstate/client/Client.java
index b7e5d46..9e9950e 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/sfsb/keepstate/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/ejb/sfsb/keepstate/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -18,12 +18,10 @@
 
 import java.util.ArrayList;
 
-import java.io.Serializable;
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.ejb.*;
 import javax.rmi.PortableRemoteObject;
-import java.rmi.NoSuchObjectException;
 
 import com.sun.s1asdev.ejb.sfsb.keepstate.ejb.SFSBHome;
 import com.sun.s1asdev.ejb.sfsb.keepstate.ejb.SFSB;
diff --git a/appserver/tests/appserv-tests/devtests/ejb/sfsb/keepstate/listener/client/Client.java b/appserver/tests/appserv-tests/devtests/ejb/sfsb/keepstate/listener/client/Client.java
index 03e82b7..f978a62 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/sfsb/keepstate/listener/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/ejb/sfsb/keepstate/listener/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,13 +17,10 @@
 package com.sun.s1asdev.ejb.ejb30.sfsb.lifecycle.client;
 
 import java.util.ArrayList;
-
-import java.io.Serializable;
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.ejb.*;
 import javax.rmi.PortableRemoteObject;
-import java.rmi.NoSuchObjectException;
 
 import com.sun.s1asdev.ejb.ejb30.sfsb.lifecycle.ejb.SFSBHome;
 import com.sun.s1asdev.ejb.ejb30.sfsb.lifecycle.ejb.SFSB;
diff --git a/appserver/tests/appserv-tests/devtests/ejb/sfsb/passivateactivate/client/Client.java b/appserver/tests/appserv-tests/devtests/ejb/sfsb/passivateactivate/client/Client.java
index 1a7b191..fec8470 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/sfsb/passivateactivate/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/ejb/sfsb/passivateactivate/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,13 +17,10 @@
 package com.sun.s1asdev.ejb.sfsb.passivateactivate.client;
 
 import java.util.ArrayList;
-
-import java.io.Serializable;
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.ejb.*;
 import javax.rmi.PortableRemoteObject;
-import java.rmi.NoSuchObjectException;
 
 import com.sun.s1asdev.ejb.sfsb.passivateactivate.ejb.SFSBHome;
 import com.sun.s1asdev.ejb.sfsb.passivateactivate.ejb.SFSB;
diff --git a/appserver/tests/appserv-tests/devtests/ejb/sfsb/passivateactivate/listener/client/Client.java b/appserver/tests/appserv-tests/devtests/ejb/sfsb/passivateactivate/listener/client/Client.java
index b0f89ea..25d2cef 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/sfsb/passivateactivate/listener/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/ejb/sfsb/passivateactivate/listener/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -18,12 +18,10 @@
 
 import java.util.ArrayList;
 
-import java.io.Serializable;
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.ejb.*;
 import javax.rmi.PortableRemoteObject;
-import java.rmi.NoSuchObjectException;
 
 import com.sun.s1asdev.ejb.ejb30.sfsb.lifecycle.ejb.SFSBHome;
 import com.sun.s1asdev.ejb.ejb30.sfsb.lifecycle.ejb.SFSB;
diff --git a/appserver/tests/appserv-tests/devtests/ejb/sfsb/stress/client/Client.java b/appserver/tests/appserv-tests/devtests/ejb/sfsb/stress/client/Client.java
index dd89515..d56fcce 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/sfsb/stress/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/ejb/sfsb/stress/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -18,12 +18,10 @@
 
 import java.util.ArrayList;
 
-import java.io.Serializable;
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.ejb.*;
 import javax.rmi.PortableRemoteObject;
-import java.rmi.NoSuchObjectException;
 
 import com.sun.s1asdev.ejb.sfsb.stress.ejb.StressSFSBHome;
 import com.sun.s1asdev.ejb.sfsb.stress.ejb.StressSFSB;
diff --git a/appserver/tests/appserv-tests/devtests/ejb/stress/passivateactivate/client/Client.java b/appserver/tests/appserv-tests/devtests/ejb/stress/passivateactivate/client/Client.java
index f3205b9..d0827f1 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/stress/passivateactivate/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/ejb/stress/passivateactivate/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -18,12 +18,10 @@
 
 import java.util.ArrayList;
 
-import java.io.Serializable;
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.ejb.*;
 import javax.rmi.PortableRemoteObject;
-import java.rmi.NoSuchObjectException;
 
 import com.sun.s1asdev.ejb.stress.passivateactivate.ejb.SFSBHome;
 import com.sun.s1asdev.ejb.stress.passivateactivate.ejb.SFSB;
diff --git a/appserver/tests/appserv-tests/devtests/ejb/stress/sfsbcache/client/Client.java b/appserver/tests/appserv-tests/devtests/ejb/stress/sfsbcache/client/Client.java
index 2dda69b..5211d07 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/stress/sfsbcache/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/ejb/stress/sfsbcache/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -18,12 +18,10 @@
 
 import java.util.ArrayList;
 
-import java.io.Serializable;
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.ejb.*;
 import javax.rmi.PortableRemoteObject;
-import java.rmi.NoSuchObjectException;
 
 import com.sun.s1asdev.ejb.stress.sfsbcache.ejb.SFSBHome;
 import com.sun.s1asdev.ejb.stress.sfsbcache.ejb.SFSB;
diff --git a/appserver/tests/appserv-tests/devtests/ejb/timer/mdbtimer/client/Client.java b/appserver/tests/appserv-tests/devtests/ejb/timer/mdbtimer/client/Client.java
index 928b6d6..6def4a3 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/timer/mdbtimer/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/ejb/timer/mdbtimer/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2002, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2002, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,11 +16,9 @@
 
 package com.sun.s1asdev.ejb.timer.mdbtimer.client;
 
-import java.io.*;
 import java.util.*;
-import javax.ejb.EJBHome;
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
@@ -43,8 +41,8 @@
     private QueueSession queueSession;
     private QueueSender queueSender;
     private QueueReceiver queueReceiver;
-    private javax.jms.Queue clientDest;
-    private javax.jms.Queue targetDest;
+    private jakarta.jms.Queue clientDest;
+    private jakarta.jms.Queue targetDest;
 
     private int numMessages = 2;
     public Client(String[] args) {
@@ -79,12 +77,12 @@
         queueSession = queueCon.createQueueSession
             (false, Session.AUTO_ACKNOWLEDGE); 
 
-        targetDest = (javax.jms.Queue) context.lookup("java:comp/env/jms/MsgBeanQueue");
+        targetDest = (jakarta.jms.Queue) context.lookup("java:comp/env/jms/MsgBeanQueue");
 
         // Producer will be specified when actual msg is sent.
         queueSender = queueSession.createSender(targetDest);        
 
-        clientDest = (javax.jms.Queue) context.lookup("java:comp/env/jms/ClientQueue");
+        clientDest = (jakarta.jms.Queue) context.lookup("java:comp/env/jms/ClientQueue");
 
         queueReceiver = queueSession.createReceiver(clientDest);
 
diff --git a/appserver/tests/appserv-tests/devtests/ejb/timer/mdbtimer/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/ejb/timer/mdbtimer/create_resources.asadmin
index 0065481..e36bf99 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/timer/mdbtimer/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/ejb/timer/mdbtimer/create_resources.asadmin
@@ -1,11 +1,11 @@
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/ejb_timer_mdbtimer_QCF
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/ejb_timer_mdbtimer_QCF
 
 
 create-jmsdest --desttype queue ejb_timer_mdbtimer_InQueue 
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=ejb_timer_mdbtimer_InQueue jms/ejb_timer_mdbtimer_InQueue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=ejb_timer_mdbtimer_InQueue jms/ejb_timer_mdbtimer_InQueue
 
 
 create-jmsdest --desttype queue ejb_timer_mdbtimer_OutQueue 
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=ejb_timer_mdbtimer_OutQueue jms/ejb_timer_mdbtimer_OutQueue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=ejb_timer_mdbtimer_OutQueue jms/ejb_timer_mdbtimer_OutQueue
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/ejb/timer/mdbtimer/descriptor/application-client.xml b/appserver/tests/appserv-tests/devtests/ejb/timer/mdbtimer/descriptor/application-client.xml
index a8d8b0c..2be1d29 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/timer/mdbtimer/descriptor/application-client.xml
+++ b/appserver/tests/appserv-tests/devtests/ejb/timer/mdbtimer/descriptor/application-client.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -21,7 +21,7 @@
   <display-name>ejb-timer-mdbtimerClient</display-name>
   <resource-ref>
     <res-ref-name>FooCF</res-ref-name>
-    <res-type>javax.jms.QueueConnectionFactory</res-type>
+    <res-type>jakarta.jms.QueueConnectionFactory</res-type>
     <res-auth>Container</res-auth>
     <res-sharing-scope>Shareable</res-sharing-scope>
   </resource-ref>
@@ -29,7 +29,7 @@
      <description>test destination</description>
      <message-destination-ref-name>jms/MsgBeanQueue
      </message-destination-ref-name>
-     <message-destination-type>javax.jms.Queue</message-destination-type>
+     <message-destination-type>jakarta.jms.Queue</message-destination-type>
      <message-destination-usage>Produces</message-destination-usage>
      <message-destination-link>MsgBeanInQueue</message-destination-link>
   </message-destination-ref>
@@ -37,7 +37,7 @@
      <description>test explicit reference to another .jar msg dest</description>
      <message-destination-ref-name>jms/testref
      </message-destination-ref-name>
-     <message-destination-type>javax.jms.Queue</message-destination-type>
+     <message-destination-type>jakarta.jms.Queue</message-destination-type>
      <message-destination-usage>Produces</message-destination-usage>
      <message-destination-link>ejb-timer-mdbtimer-ejb.jar#MsgBeanInQueue
      </message-destination-link>
@@ -46,7 +46,7 @@
      <description>test explicit reference to another .jar msg dest</description>
      <message-destination-ref-name>jms/ClientQueue
      </message-destination-ref-name>
-     <message-destination-type>javax.jms.Queue</message-destination-type>
+     <message-destination-type>jakarta.jms.Queue</message-destination-type>
      <message-destination-usage>Consumes</message-destination-usage>
      <message-destination-link>ejb-timer-mdbtimer-ejb.jar#MsgBeanOutQueue
      </message-destination-link>
diff --git a/appserver/tests/appserv-tests/devtests/ejb/timer/mdbtimer/descriptor/ejb-jar.xml b/appserver/tests/appserv-tests/devtests/ejb/timer/mdbtimer/descriptor/ejb-jar.xml
index 89f7204..bfe50b5 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/timer/mdbtimer/descriptor/ejb-jar.xml
+++ b/appserver/tests/appserv-tests/devtests/ejb/timer/mdbtimer/descriptor/ejb-jar.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -24,14 +24,14 @@
       <display-name>MDB1</display-name>
       <ejb-name>MDB1</ejb-name>
       <ejb-class>com.sun.s1asdev.ejb.timer.mdbtimer.MessageBean</ejb-class>
-      <messaging-type>javax.jms.MessageListener</messaging-type>
+      <messaging-type>jakarta.jms.MessageListener</messaging-type>
       <transaction-type>Container</transaction-type>
-      <message-destination-type>javax.jms.Queue</message-destination-type>
+      <message-destination-type>jakarta.jms.Queue</message-destination-type>
       <message-destination-link>MsgBeanInQueue</message-destination-link>
       <resource-ref>
         <description>description</description>
         <res-ref-name>jms/MyQueueConnectionFactory</res-ref-name>
-        <res-type>javax.jms.QueueConnectionFactory</res-type>
+        <res-type>jakarta.jms.QueueConnectionFactory</res-type>
         <res-auth>Container</res-auth>
         <res-sharing-scope>Shareable</res-sharing-scope>
       </resource-ref>
@@ -39,7 +39,7 @@
         <description>test destination</description>
         <message-destination-ref-name>jms/MyQueue
         </message-destination-ref-name>
-        <message-destination-type>javax.jms.Queue</message-destination-type>
+        <message-destination-type>jakarta.jms.Queue</message-destination-type>
         <message-destination-usage>Produces</message-destination-usage>
         <message-destination-link>MsgBeanOutQueue</message-destination-link>
       </message-destination-ref>
@@ -51,7 +51,7 @@
         <ejb-name>MDB1</ejb-name>
         <method-name>onMessage</method-name>
         <method-params>
-          <method-param>javax.jms.Message</method-param>
+          <method-param>jakarta.jms.Message</method-param>
         </method-params>
       </method>
       <trans-attribute>Required</trans-attribute>
diff --git a/appserver/tests/appserv-tests/devtests/ejb/timer/mdbtimer/ejb/MessageBean.java b/appserver/tests/appserv-tests/devtests/ejb/timer/mdbtimer/ejb/MessageBean.java
index 8fda6ca..40bdf3c 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/timer/mdbtimer/ejb/MessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/ejb/timer/mdbtimer/ejb/MessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,9 +17,8 @@
 package com.sun.s1asdev.ejb.timer.mdbtimer;
 
 import java.rmi.RemoteException;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.ejb.*;
-import java.io.Serializable;
 import javax.naming.*;
 import java.util.Date;
 
diff --git a/appserver/tests/appserv-tests/devtests/ejb/timer/restore/client/Client.java b/appserver/tests/appserv-tests/devtests/ejb/timer/restore/client/Client.java
index 8888f4b..a2eda9f 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/timer/restore/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/ejb/timer/restore/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,12 +16,10 @@
 
 package com.sun.s1asdev.ejb.timer.restore.client;
 
-import java.io.Serializable;
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.ejb.*;
 import javax.rmi.PortableRemoteObject;
-import java.rmi.NoSuchObjectException;
 import java.util.HashSet;
 import java.util.Set;
 import com.sun.s1asdev.ejb.timer.restore.TimerSession;
diff --git a/appserver/tests/appserv-tests/devtests/ejb/timer/restore/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/ejb/timer/restore/create_resources.asadmin
index 730d4db..1e533f7 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/timer/restore/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/ejb/timer/restore/create_resources.asadmin
@@ -1,7 +1,7 @@
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/ejb_timer_restore_TQCF
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/ejb_timer_restore_TQCF
 
 create-jmsdest --desttype queue ejb_timer_restore_TQueue
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=ejb_timer_restore_TQueue jms/ejb_timer_restore_TQueue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=ejb_timer_restore_TQueue jms/ejb_timer_restore_TQueue
 
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/ejb/timer/restore/descriptor/application-client.xml b/appserver/tests/appserv-tests/devtests/ejb/timer/restore/descriptor/application-client.xml
index 67a7e4b..f6a7b3b 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/timer/restore/descriptor/application-client.xml
+++ b/appserver/tests/appserv-tests/devtests/ejb/timer/restore/descriptor/application-client.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -29,12 +29,12 @@
   <resource-ref>
     <description>description</description>
     <res-ref-name>jms/MyQueueConnectionFactory</res-ref-name>
-    <res-type>javax.jms.QueueConnectionFactory</res-type>
+    <res-type>jakarta.jms.QueueConnectionFactory</res-type>
     <res-auth>Container</res-auth>
     <res-sharing-scope>Shareable</res-sharing-scope>
   </resource-ref>
   <resource-env-ref>
     <resource-env-ref-name>jms/MyQueue</resource-env-ref-name>
-    <resource-env-ref-type>javax.jms.Queue</resource-env-ref-type>
+    <resource-env-ref-type>jakarta.jms.Queue</resource-env-ref-type>
   </resource-env-ref>
 </application-client>
diff --git a/appserver/tests/appserv-tests/devtests/ejb/timer/restore/descriptor/ejb-jar.xml b/appserver/tests/appserv-tests/devtests/ejb/timer/restore/descriptor/ejb-jar.xml
index fde6b7b..0d22a74 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/timer/restore/descriptor/ejb-jar.xml
+++ b/appserver/tests/appserv-tests/devtests/ejb/timer/restore/descriptor/ejb-jar.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -30,13 +30,13 @@
       <resource-ref>
         <description>description</description>
         <res-ref-name>jms/MyQueueConnectionFactory</res-ref-name>
-        <res-type>javax.jms.QueueConnectionFactory</res-type>
+        <res-type>jakarta.jms.QueueConnectionFactory</res-type>
         <res-auth>Container</res-auth>
         <res-sharing-scope>Shareable</res-sharing-scope>
       </resource-ref>
       <resource-env-ref>
          <resource-env-ref-name>jms/MyQueue</resource-env-ref-name>
-         <resource-env-ref-type>javax.jms.Queue</resource-env-ref-type>
+         <resource-env-ref-type>jakarta.jms.Queue</resource-env-ref-type>
       </resource-env-ref>
       <security-identity>
         <use-caller-identity/>
diff --git a/appserver/tests/appserv-tests/devtests/ejb/timer/restore/ejb/TimerSessionEJB.java b/appserver/tests/appserv-tests/devtests/ejb/timer/restore/ejb/TimerSessionEJB.java
index 42b9900..032a037 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/timer/restore/ejb/TimerSessionEJB.java
+++ b/appserver/tests/appserv-tests/devtests/ejb/timer/restore/ejb/TimerSessionEJB.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,26 +17,23 @@
 package com.sun.s1asdev.ejb.timer.restore;
 
 import java.util.Iterator;
-import java.util.Collection;
 import java.util.Date;
-
 import javax.ejb.TimedObject;
 import javax.ejb.Timer;
 import javax.ejb.TimerHandle;
 import javax.ejb.TimerService;
 import javax.ejb.SessionBean;
 import javax.ejb.SessionContext;
-import javax.ejb.EJBContext;
 import javax.ejb.EJBException;
-import javax.jms.Session;
+import jakarta.jms.Session;
 import java.rmi.RemoteException;
-import javax.jms.QueueConnectionFactory;
-import javax.jms.QueueConnection;
-import javax.jms.Queue;
-import javax.jms.QueueSender;
-import javax.jms.QueueSession;
-import javax.jms.JMSException;
-import javax.jms.TextMessage;
+import jakarta.jms.QueueConnectionFactory;
+import jakarta.jms.QueueConnection;
+import jakarta.jms.Queue;
+import jakarta.jms.QueueSender;
+import jakarta.jms.QueueSession;
+import jakarta.jms.JMSException;
+import jakarta.jms.TextMessage;
 import javax.naming.*;
 
 import com.sun.ejb.containers.TimerBean;
diff --git a/appserver/tests/appserv-tests/devtests/ejb/timer/sessiontimerSecurity/client/Client.java b/appserver/tests/appserv-tests/devtests/ejb/timer/sessiontimerSecurity/client/Client.java
index 1a93c1c..4ccdd00 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/timer/sessiontimerSecurity/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/ejb/timer/sessiontimerSecurity/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,13 +16,10 @@
 
 package com.sun.s1asdev.ejb.timer.sessiontimersecurity.client;
 
-import java.io.Serializable;
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.ejb.*;
 import javax.rmi.PortableRemoteObject;
-import java.rmi.NoSuchObjectException;
-
 import com.sun.s1asdev.ejb.timer.sessiontimersecurity.TimerSession;
 import com.sun.s1asdev.ejb.timer.sessiontimersecurity.TimerSessionHome;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
diff --git a/appserver/tests/appserv-tests/devtests/ejb/timer/sessiontimerSecurity/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/ejb/timer/sessiontimerSecurity/create_resources.asadmin
index f2a222e..bf8cdd6 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/timer/sessiontimerSecurity/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/ejb/timer/sessiontimerSecurity/create_resources.asadmin
@@ -1,7 +1,7 @@
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/ejb_timer_sessiontimersecurity_TQCF
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/ejb_timer_sessiontimersecurity_TQCF
 
 create-jmsdest --desttype queue ejb_timer_sessiontimersecurity_TQueue
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=ejb_timer_sessiontimersecurity_TQueue jms/ejb_timer_sessiontimersecurity_TQueue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=ejb_timer_sessiontimersecurity_TQueue jms/ejb_timer_sessiontimersecurity_TQueue
 
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/ejb/timer/sessiontimerSecurity/descriptor/ejb-jar.xml b/appserver/tests/appserv-tests/devtests/ejb/timer/sessiontimerSecurity/descriptor/ejb-jar.xml
index 4192481..c50a697 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/timer/sessiontimerSecurity/descriptor/ejb-jar.xml
+++ b/appserver/tests/appserv-tests/devtests/ejb/timer/sessiontimerSecurity/descriptor/ejb-jar.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -30,13 +30,13 @@
       <resource-ref>
         <description>description</description>
         <res-ref-name>jms/MyQueueConnectionFactory</res-ref-name>
-        <res-type>javax.jms.QueueConnectionFactory</res-type>
+        <res-type>jakarta.jms.QueueConnectionFactory</res-type>
         <res-auth>Container</res-auth>
         <res-sharing-scope>Shareable</res-sharing-scope>
       </resource-ref>
       <resource-env-ref>
          <resource-env-ref-name>jms/MyQueue</resource-env-ref-name>
-         <resource-env-ref-type>javax.jms.Queue</resource-env-ref-type>
+         <resource-env-ref-type>jakarta.jms.Queue</resource-env-ref-type>
       </resource-env-ref>
       <security-role-ref>
         <role-name>foo</role-name>
diff --git a/appserver/tests/appserv-tests/devtests/ejb/timer/sessiontimerSecurity/ejb/TimerSessionEJB.java b/appserver/tests/appserv-tests/devtests/ejb/timer/sessiontimerSecurity/ejb/TimerSessionEJB.java
index 1be0d9f..5339924 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/timer/sessiontimerSecurity/ejb/TimerSessionEJB.java
+++ b/appserver/tests/appserv-tests/devtests/ejb/timer/sessiontimerSecurity/ejb/TimerSessionEJB.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -22,16 +22,15 @@
 import javax.ejb.TimerService;
 import javax.ejb.SessionBean;
 import javax.ejb.SessionContext;
-import javax.ejb.EJBContext;
-import javax.jms.Session;
+import jakarta.jms.Session;
 import java.rmi.RemoteException;
-import javax.jms.QueueConnectionFactory;
-import javax.jms.QueueConnection;
-import javax.jms.Queue;
-import javax.jms.QueueSender;
-import javax.jms.QueueSession;
-import javax.jms.JMSException;
-import javax.jms.TextMessage;
+import jakarta.jms.QueueConnectionFactory;
+import jakarta.jms.QueueConnection;
+import jakarta.jms.Queue;
+import jakarta.jms.QueueSender;
+import jakarta.jms.QueueSession;
+import jakarta.jms.JMSException;
+import jakarta.jms.TextMessage;
 import javax.naming.*;
 
 public class TimerSessionEJB implements TimedObject, SessionBean 
diff --git a/appserver/tests/appserv-tests/devtests/ejb/timer/timerserialization/client/Client.java b/appserver/tests/appserv-tests/devtests/ejb/timer/timerserialization/client/Client.java
index 4f5ff32..8dcda82 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/timer/timerserialization/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/ejb/timer/timerserialization/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -18,12 +18,10 @@
 
 import java.util.ArrayList;
 
-import java.io.Serializable;
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.ejb.*;
 import javax.rmi.PortableRemoteObject;
-import java.rmi.NoSuchObjectException;
 
 import com.sun.s1asdev.ejb.timer.timerserialization.ejb.TimerSFSBHome;
 import com.sun.s1asdev.ejb.timer.timerserialization.ejb.TimerSFSB;
diff --git a/appserver/tests/appserv-tests/devtests/ejb/timer/timertests/client/Client.java b/appserver/tests/appserv-tests/devtests/ejb/timer/timertests/client/Client.java
index 4bbc069..15d259e 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/timer/timertests/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/ejb/timer/timertests/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,13 +17,9 @@
 package com.sun.s1asdev.ejb.timer.timertests.client;
 
 import java.io.Serializable;
-import java.rmi.NoSuchObjectException;
 import java.util.Date;
-import java.util.Properties;
-import java.util.Set;
 
 import javax.ejb.*;
-//import javax.jms.*;
 import javax.naming.*;
 import javax.rmi.PortableRemoteObject;
 
diff --git a/appserver/tests/appserv-tests/devtests/ejb/timer/timertests/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/ejb/timer/timertests/create_resources.asadmin
index 86d58dd..a8ff0d6 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/timer/timertests/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/ejb/timer/timertests/create_resources.asadmin
@@ -1,10 +1,10 @@
-create-jms-resource --restype javax.jms.QueueConnectionFactory  jms/ejb_timer_timertests_QCF
-create-jms-resource --restype javax.jms.TopicConnectionFactory  jms/ejb_timer_timertests_TCF
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory  jms/ejb_timer_timertests_QCF
+create-jms-resource --restype jakarta.jms.TopicConnectionFactory  jms/ejb_timer_timertests_TCF
 
-create-jms-resource --restype javax.jms.Queue --enabled=true --property imqDestinationName=ejb_timer_timertests_queue jms/ejb_timer_timertests_queue
-create-jms-resource --restype javax.jms.Topic --enabled=true --property imqDestinationName=ejb_timer_timertests_topic jms/ejb_timer_timertests_topic
-create-jms-resource --restype javax.jms.Queue --enabled=true --property imqDestinationName=ejb_timer_timertests_mdb_cmt jms/ejb_timer_timertests_mdb_cmt
-create-jms-resource --restype javax.jms.Queue --enabled=true --property imqDestinationName=ejb_timer_timertests_mdb_bmt jms/ejb_timer_timertests_mdb_bmt
+create-jms-resource --restype jakarta.jms.Queue --enabled=true --property imqDestinationName=ejb_timer_timertests_queue jms/ejb_timer_timertests_queue
+create-jms-resource --restype jakarta.jms.Topic --enabled=true --property imqDestinationName=ejb_timer_timertests_topic jms/ejb_timer_timertests_topic
+create-jms-resource --restype jakarta.jms.Queue --enabled=true --property imqDestinationName=ejb_timer_timertests_mdb_cmt jms/ejb_timer_timertests_mdb_cmt
+create-jms-resource --restype jakarta.jms.Queue --enabled=true --property imqDestinationName=ejb_timer_timertests_mdb_bmt jms/ejb_timer_timertests_mdb_bmt
 
 create-jmsdest --desttype queue ejb_timer_timertests_queue
 create-jmsdest --desttype topic ejb_timer_timertests_topic
diff --git a/appserver/tests/appserv-tests/devtests/ejb/timer/timertests/descriptor/application-client.xml b/appserver/tests/appserv-tests/devtests/ejb/timer/timertests/descriptor/application-client.xml
index 1af140a..1ba18ae 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/timer/timertests/descriptor/application-client.xml
+++ b/appserver/tests/appserv-tests/devtests/ejb/timer/timertests/descriptor/application-client.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -57,27 +57,27 @@
 <!--
   <resource-ref>
     <res-ref-name>jms/MyTopicConnectionFactory</res-ref-name>
-    <res-type>javax.jms.TopicConnectionFactory</res-type>
+    <res-type>jakarta.jms.TopicConnectionFactory</res-type>
     <res-auth>Container</res-auth>
     <res-sharing-scope>Shareable</res-sharing-scope>
   </resource-ref>
   <resource-ref>
     <res-ref-name>jms/MyQueueConnectionFactory</res-ref-name>
-    <res-type>javax.jms.QueueConnectionFactory</res-type>
+    <res-type>jakarta.jms.QueueConnectionFactory</res-type>
     <res-auth>Container</res-auth>
     <res-sharing-scope>Shareable</res-sharing-scope>
   </resource-ref>
   <message-destination-ref>       
     <description>timertest destination</description>
     <message-destination-ref-name>jms/TimerMDBQueue_CMT</message-destination-ref-name>
-    <message-destination-type>javax.jms.Queue</message-destination-type>
+    <message-destination-type>jakarta.jms.Queue</message-destination-type>
     <message-destination-usage>Produces</message-destination-usage>
     <message-destination-link>TimerMDBQueue_CMT</message-destination-link>
   </message-destination-ref>
   <message-destination-ref>       
     <description>timertest destination</description>
     <message-destination-ref-name>jms/TimerMDBQueue_BMT</message-destination-ref-name>
-    <message-destination-type>javax.jms.Queue</message-destination-type>
+    <message-destination-type>jakarta.jms.Queue</message-destination-type>
     <message-destination-usage>Produces</message-destination-usage>
     <message-destination-link>TimerMDBQueue_BMT</message-destination-link>
   </message-destination-ref>
diff --git a/appserver/tests/appserv-tests/devtests/ejb/timer/timertests/descriptor/ejb-jar.xml b/appserver/tests/appserv-tests/devtests/ejb/timer/timertests/descriptor/ejb-jar.xml
index e38cfb5..6c4ed22 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/timer/timertests/descriptor/ejb-jar.xml
+++ b/appserver/tests/appserv-tests/devtests/ejb/timer/timertests/descriptor/ejb-jar.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -48,14 +48,14 @@
       <resource-ref>
         <description>description</description>
         <res-ref-name>jms/MyQueueConnectionFactory</res-ref-name>
-        <res-type>javax.jms.QueueConnectionFactory</res-type>
+        <res-type>jakarta.jms.QueueConnectionFactory</res-type>
         <res-auth>Container</res-auth>
         <res-sharing-scope>Shareable</res-sharing-scope>
       </resource-ref>
       <message-destination-ref>
         <description>timertest destination</description>
         <message-destination-ref-name>jms/MyQueue</message-destination-ref-name>
-        <message-destination-type>javax.jms.Queue</message-destination-type>
+        <message-destination-type>jakarta.jms.Queue</message-destination-type>
         <message-destination-usage>ConsumesProduces</message-destination-usage>
         <message-destination-link>TimerQueue</message-destination-link>
       </message-destination-ref>
@@ -69,9 +69,9 @@
     <message-driven>
       <ejb-name>msgbean_BMT</ejb-name>
       <ejb-class>com.sun.s1asdev.ejb.timer.timertests.MessageDrivenEJB</ejb-class>
-      <messaging-type>javax.jms.MessageListener</messaging-type>
+      <messaging-type>jakarta.jms.MessageListener</messaging-type>
       <transaction-type>Bean</transaction-type>
-      <message-destination-type>javax.jms.Queue</message-destination-type>
+      <message-destination-type>jakarta.jms.Queue</message-destination-type>
       <message-destination-link>TimerMDBQueue_BMT</message-destination-link>
       <env-entry>
         <env-entry-name>txmode</env-entry-name>
@@ -81,14 +81,14 @@
       <resource-ref>
         <description>description</description>
         <res-ref-name>jms/MyQueueConnectionFactory</res-ref-name>
-        <res-type>javax.jms.QueueConnectionFactory</res-type>
+        <res-type>jakarta.jms.QueueConnectionFactory</res-type>
         <res-auth>Container</res-auth>
         <res-sharing-scope>Shareable</res-sharing-scope>
       </resource-ref>
       <message-destination-ref>       
         <description>timertest destination</description>
         <message-destination-ref-name>jms/MyQueue</message-destination-ref-name>
-        <message-destination-type>javax.jms.Queue</message-destination-type>
+        <message-destination-type>jakarta.jms.Queue</message-destination-type>
         <message-destination-usage>ConsumesProduces</message-destination-usage>
         <message-destination-link>TimerQueue</message-destination-link>
       </message-destination-ref>
@@ -96,9 +96,9 @@
     <message-driven>
       <ejb-name>msgbean_CMT</ejb-name>
       <ejb-class>com.sun.s1asdev.ejb.timer.timertests.MessageDrivenEJB</ejb-class>
-      <messaging-type>javax.jms.MessageListener</messaging-type>
+      <messaging-type>jakarta.jms.MessageListener</messaging-type>
       <transaction-type>Container</transaction-type>
-      <message-destination-type>javax.jms.Queue</message-destination-type>
+      <message-destination-type>jakarta.jms.Queue</message-destination-type>
       <message-destination-link>TimerMDBQueue_CMT</message-destination-link>
       <env-entry>
         <env-entry-name>txmode</env-entry-name>
@@ -108,14 +108,14 @@
       <resource-ref>
         <description>description</description>
         <res-ref-name>jms/MyQueueConnectionFactory</res-ref-name>
-        <res-type>javax.jms.QueueConnectionFactory</res-type>
+        <res-type>jakarta.jms.QueueConnectionFactory</res-type>
         <res-auth>Container</res-auth>
         <res-sharing-scope>Shareable</res-sharing-scope>
       </resource-ref>
       <message-destination-ref>       
         <description>timertest destination</description>
         <message-destination-ref-name>jms/MyQueue</message-destination-ref-name>
-        <message-destination-type>javax.jms.Queue</message-destination-type>
+        <message-destination-type>jakarta.jms.Queue</message-destination-type>
         <message-destination-usage>ConsumesProduces</message-destination-usage>
         <message-destination-link>TimerQueue</message-destination-link>
       </message-destination-ref>
@@ -137,14 +137,14 @@
       <resource-ref>
         <description>description</description>
         <res-ref-name>jms/MyQueueConnectionFactory</res-ref-name>
-        <res-type>javax.jms.QueueConnectionFactory</res-type>
+        <res-type>jakarta.jms.QueueConnectionFactory</res-type>
         <res-auth>Container</res-auth>
         <res-sharing-scope>Shareable</res-sharing-scope>
       </resource-ref>
       <message-destination-ref>       
         <description>timertest destination</description>
         <message-destination-ref-name>jms/MyQueue</message-destination-ref-name>
-        <message-destination-type>javax.jms.Queue</message-destination-type>
+        <message-destination-type>jakarta.jms.Queue</message-destination-type>
         <message-destination-usage>ConsumesProduces</message-destination-usage>
         <message-destination-link>TimerQueue</message-destination-link>
       </message-destination-ref>
@@ -169,14 +169,14 @@
       <resource-ref>
         <description>description</description>
         <res-ref-name>jms/MyQueueConnectionFactory</res-ref-name>
-        <res-type>javax.jms.QueueConnectionFactory</res-type>
+        <res-type>jakarta.jms.QueueConnectionFactory</res-type>
         <res-auth>Container</res-auth>
         <res-sharing-scope>Shareable</res-sharing-scope>
       </resource-ref>
       <message-destination-ref>       
         <description>timertest destination</description>
         <message-destination-ref-name>jms/MyQueue</message-destination-ref-name>
-        <message-destination-type>javax.jms.Queue</message-destination-type>
+        <message-destination-type>jakarta.jms.Queue</message-destination-type>
         <message-destination-usage>ConsumesProduces</message-destination-usage>
         <message-destination-link>TimerQueue</message-destination-link>
       </message-destination-ref>
@@ -201,14 +201,14 @@
       <resource-ref>
         <description>description</description>
         <res-ref-name>jms/MyQueueConnectionFactory</res-ref-name>
-        <res-type>javax.jms.QueueConnectionFactory</res-type>
+        <res-type>jakarta.jms.QueueConnectionFactory</res-type>
         <res-auth>Container</res-auth>
         <res-sharing-scope>Shareable</res-sharing-scope>
       </resource-ref>
       <message-destination-ref>       
         <description>timertest destination</description>
         <message-destination-ref-name>jms/MyQueue</message-destination-ref-name>
-        <message-destination-type>javax.jms.Queue</message-destination-type>
+        <message-destination-type>jakarta.jms.Queue</message-destination-type>
         <message-destination-usage>ConsumesProduces</message-destination-usage>
         <message-destination-link>TimerQueue</message-destination-link>
       </message-destination-ref>
@@ -233,14 +233,14 @@
       <resource-ref>
         <description>description</description>
         <res-ref-name>jms/MyQueueConnectionFactory</res-ref-name>
-        <res-type>javax.jms.QueueConnectionFactory</res-type>
+        <res-type>jakarta.jms.QueueConnectionFactory</res-type>
         <res-auth>Container</res-auth>
         <res-sharing-scope>Shareable</res-sharing-scope>
       </resource-ref>
       <message-destination-ref>       
         <description>timertest destination</description>
         <message-destination-ref-name>jms/MyQueue</message-destination-ref-name>
-        <message-destination-type>javax.jms.Queue</message-destination-type>
+        <message-destination-type>jakarta.jms.Queue</message-destination-type>
         <message-destination-usage>ConsumesProduces</message-destination-usage>
         <message-destination-link>TimerQueue</message-destination-link>
       </message-destination-ref>
@@ -265,14 +265,14 @@
       <resource-ref>
         <description>description</description>
         <res-ref-name>jms/MyQueueConnectionFactory</res-ref-name>
-        <res-type>javax.jms.QueueConnectionFactory</res-type>
+        <res-type>jakarta.jms.QueueConnectionFactory</res-type>
         <res-auth>Container</res-auth>
         <res-sharing-scope>Shareable</res-sharing-scope>
       </resource-ref>
       <message-destination-ref>       
         <description>timertest destination</description>
         <message-destination-ref-name>jms/MyQueue</message-destination-ref-name>
-        <message-destination-type>javax.jms.Queue</message-destination-type>
+        <message-destination-type>jakarta.jms.Queue</message-destination-type>
         <message-destination-usage>ConsumesProduces</message-destination-usage>
         <message-destination-link>TimerQueue</message-destination-link>
       </message-destination-ref>
@@ -289,7 +289,7 @@
         <ejb-name>msgbean_CMT</ejb-name>
         <method-name>onMessage</method-name>
         <method-params>
-          <method-param>javax.jms.Message</method-param>
+          <method-param>jakarta.jms.Message</method-param>
         </method-params>
       </method>
       <trans-attribute>Required</trans-attribute>
diff --git a/appserver/tests/appserv-tests/devtests/ejb/timer/timertests/ejb/MessageDrivenEJB.java b/appserver/tests/appserv-tests/devtests/ejb/timer/timertests/ejb/MessageDrivenEJB.java
index 6fb3762..28cad04 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/timer/timertests/ejb/MessageDrivenEJB.java
+++ b/appserver/tests/appserv-tests/devtests/ejb/timer/timertests/ejb/MessageDrivenEJB.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,9 +17,8 @@
 package com.sun.s1asdev.ejb.timer.timertests;
 
 import java.rmi.RemoteException;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.ejb.*;
-import java.io.Serializable;
 
 public class MessageDrivenEJB extends TimerStuffImpl 
     implements MessageDrivenBean, TimedObject, MessageListener {
diff --git a/appserver/tests/appserv-tests/devtests/ejb/timer/timertests/ejb/TimerStuffImpl.java b/appserver/tests/appserv-tests/devtests/ejb/timer/timertests/ejb/TimerStuffImpl.java
index 31ca6a6..484a5d6 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/timer/timertests/ejb/TimerStuffImpl.java
+++ b/appserver/tests/appserv-tests/devtests/ejb/timer/timertests/ejb/TimerStuffImpl.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -24,14 +24,14 @@
 import java.util.Collection;
 import java.util.Iterator;
 import javax.ejb.*;
-import javax.jms.JMSException;
-import javax.jms.QueueConnectionFactory;
-import javax.jms.QueueConnection;
-import javax.jms.Queue;
-import javax.jms.QueueSession;
-import javax.jms.QueueSender;
-import javax.jms.QueueReceiver;
-import javax.jms.TextMessage;
+import jakarta.jms.JMSException;
+import jakarta.jms.QueueConnectionFactory;
+import jakarta.jms.QueueConnection;
+import jakarta.jms.Queue;
+import jakarta.jms.QueueSession;
+import jakarta.jms.QueueSender;
+import jakarta.jms.QueueReceiver;
+import jakarta.jms.TextMessage;
 
 public class TimerStuffImpl implements TimerStuff {
     
diff --git a/appserver/tests/appserv-tests/devtests/ejb/util/methodmap/client/MethodMapTest.java b/appserver/tests/appserv-tests/devtests/ejb/util/methodmap/client/MethodMapTest.java
index cf1aac7..b5d7152 100644
--- a/appserver/tests/appserv-tests/devtests/ejb/util/methodmap/client/MethodMapTest.java
+++ b/appserver/tests/appserv-tests/devtests/ejb/util/methodmap/client/MethodMapTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -38,8 +38,8 @@
         javax.ejb.EJBObject.class, javax.ejb.EJBLocalObject.class,
         javax.ejb.EJBLocalHome.class, javax.ejb.SessionBean.class,
         javax.ejb.EnterpriseBean.class, java.util.Map.class,
-        javax.jms.QueueConnection.class, javax.jms.QueueSession.class,
-        javax.jms.Session.class, java.util.Date.class,
+        jakarta.jms.QueueConnection.class, jakarta.jms.QueueSession.class,
+        jakarta.jms.Session.class, java.util.Date.class,
         javax.swing.Action.class, javax.swing.AbstractAction.class,
         javax.swing.JComboBox.class, javax.swing.JTextArea.class        
 
diff --git a/appserver/tests/appserv-tests/devtests/jdbc/config/ee-properties.xml b/appserver/tests/appserv-tests/devtests/jdbc/config/ee-properties.xml
index 9d70335..01a3246 100644
--- a/appserver/tests/appserv-tests/devtests/jdbc/config/ee-properties.xml
+++ b/appserver/tests/appserv-tests/devtests/jdbc/config/ee-properties.xml
@@ -1,6 +1,6 @@
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -49,11 +49,11 @@
     <property name="dest.type" value="queue"/>
     <property name="dest.name" value="Queue"/>
     <property name="jms.factory.name" value="jms/QCFactory"/>
-    <property name="jms.factory.type" value="javax.jms.QueueConnectionFactory"/>
+    <property name="jms.factory.type" value="jakarta.jms.QueueConnectionFactory"/>
     <property name="jms.resource.name" value="jms/SampleQueue"/>
-    <property name="jms.resource.type" value="javax.jms.Queue"/>
+    <property name="jms.resource.type" value="jakarta.jms.Queue"/>
     <property name="jms.factory.type" 
-              value="javax.jms.QueueConnectionFactory" />
+              value="jakarta.jms.QueueConnectionFactory" />
     <property name="queue.property.name" value="imqDestinationName" />
     <property name="queue.property.value" value="SampleQueue" />
 
diff --git a/appserver/tests/appserv-tests/devtests/jdbc/jdbcjmsauth/build.xml b/appserver/tests/appserv-tests/devtests/jdbc/jdbcjmsauth/build.xml
index b9f6938..6853569 100755
--- a/appserver/tests/appserv-tests/devtests/jdbc/jdbcjmsauth/build.xml
+++ b/appserver/tests/appserv-tests/devtests/jdbc/jdbcjmsauth/build.xml
@@ -2,7 +2,7 @@
 <!DOCTYPE project [
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -105,12 +105,12 @@
       </antcall>
       -->
       <antcall target="create-jms-connection-common">
-        <param name="jms.factory.type" value="javax.jms.QueueConnectionFactory"/>
+        <param name="jms.factory.type" value="jakarta.jms.QueueConnectionFactory"/>
 	<param name="jms.factory.name" value="jms/jdbcjmsauth_QCF1"/>
       </antcall>
       
       <antcall target="create-jms-connection-common">
-        <param name="jms.factory.type" value="javax.jms.QueueConnectionFactory"/>
+        <param name="jms.factory.type" value="jakarta.jms.QueueConnectionFactory"/>
 	<param name="jms.factory.name" value="jms/jdbcjmsauth_QCF2"/>
       </antcall>
     </target>
diff --git a/appserver/tests/appserv-tests/devtests/jdbc/jdbcjmsauth/create_resources_asadmin.jms b/appserver/tests/appserv-tests/devtests/jdbc/jdbcjmsauth/create_resources_asadmin.jms
index 928470a..a9687a7 100644
--- a/appserver/tests/appserv-tests/devtests/jdbc/jdbcjmsauth/create_resources_asadmin.jms
+++ b/appserver/tests/appserv-tests/devtests/jdbc/jdbcjmsauth/create_resources_asadmin.jms
@@ -14,7 +14,7 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  */
 
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/jdbcjmsauth_QCF1 
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/jdbcjmsauth_QCF2 
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/jdbcjmsauth_QCF1 
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/jdbcjmsauth_QCF2 
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jdbc/jdbcjmsauth/descriptor/ejb-jar.xml b/appserver/tests/appserv-tests/devtests/jdbc/jdbcjmsauth/descriptor/ejb-jar.xml
index 7fb1912..8d0dfbc 100755
--- a/appserver/tests/appserv-tests/devtests/jdbc/jdbcjmsauth/descriptor/ejb-jar.xml
+++ b/appserver/tests/appserv-tests/devtests/jdbc/jdbcjmsauth/descriptor/ejb-jar.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -35,12 +35,12 @@
       <transaction-type>Container</transaction-type>
       <resource-ref>
         <res-ref-name>jms/MyQueueConnectionFactory</res-ref-name>
-	<res-type>javax.jms.QueueConnectionFactory</res-type>
+	<res-type>jakarta.jms.QueueConnectionFactory</res-type>
 	<res-auth>Application</res-auth>
       </resource-ref>	
       <resource-ref>
         <res-ref-name>jms/MyQueueConnectionFactory_CM</res-ref-name>
-	<res-type>javax.jms.QueueConnectionFactory</res-type>
+	<res-type>jakarta.jms.QueueConnectionFactory</res-type>
 	<res-auth>Container</res-auth>
       </resource-ref>	
     </session>
diff --git a/appserver/tests/appserv-tests/devtests/jdbc/jdbcjmsauth/ejb/JmsAuthBean.java b/appserver/tests/appserv-tests/devtests/jdbc/jdbcjmsauth/ejb/JmsAuthBean.java
index 1344f45..e87a87c 100644
--- a/appserver/tests/appserv-tests/devtests/jdbc/jdbcjmsauth/ejb/JmsAuthBean.java
+++ b/appserver/tests/appserv-tests/devtests/jdbc/jdbcjmsauth/ejb/JmsAuthBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,10 +19,10 @@
 import javax.ejb.SessionBean;
 import javax.ejb.SessionContext;
 import javax.ejb.CreateException;
-import javax.jms.QueueConnectionFactory;
-import javax.jms.QueueConnection;
-import javax.jms.QueueSession;
-import javax.jms.Session;
+import jakarta.jms.QueueConnectionFactory;
+import jakarta.jms.QueueConnection;
+import jakarta.jms.QueueSession;
+import jakarta.jms.Session;
 import javax.naming.InitialContext;
 
 public class JmsAuthBean implements SessionBean {
diff --git a/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/ACC1/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/ACC1/client/Client.java
index 382a2ff..e0ee861 100644
--- a/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/ACC1/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/ACC1/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.jmsxdeliverycount.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
 public class Client {
diff --git a/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/ACC1/client/Client2.java b/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/ACC1/client/Client2.java
index bda6c79..314fb30 100644
--- a/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/ACC1/client/Client2.java
+++ b/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/ACC1/client/Client2.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.jmsxdeliverycount.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
 public class Client2 {
diff --git a/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/ACC1/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/ACC1/create_resources.asadmin
index 0841305..34cca97 100644
--- a/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/ACC1/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/ACC1/create_resources.asadmin
@@ -1,7 +1,7 @@
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 create-jmsdest --desttype queue jms_unit_test_Queue
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
 
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/ACC2/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/ACC2/client/Client.java
index acdb8fd..37d11e1 100644
--- a/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/ACC2/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/ACC2/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.jmsxdeliverycount.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
 public class Client {
diff --git a/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/ACC2/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/ACC2/create_resources.asadmin
index 0841305..34cca97 100644
--- a/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/ACC2/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/ACC2/create_resources.asadmin
@@ -1,7 +1,7 @@
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 create-jmsdest --desttype queue jms_unit_test_Queue
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
 
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB1/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB1/client/Client.java
index 0b3503f..c69cd80 100644
--- a/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB1/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB1/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.jmsxdeliverycount.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.jmsxdeliverycount.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB1/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB1/create_resources.asadmin
index 299bc57..8a48a9c 100644
--- a/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB1/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB1/create_resources.asadmin
@@ -1,9 +1,9 @@
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 create-jmsdest --desttype queue jms_unit_test_Queue
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
 
 create-jmsdest --desttype queue jms_unit_result_Queue
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB1/ejb/MySessionBean.java b/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB1/ejb/MySessionBean.java
index 79d3b7e..029a788 100644
--- a/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB1/ejb/MySessionBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB1/ejb/MySessionBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,7 +20,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB1/ejb/NewMessageBean.java b/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB1/ejb/NewMessageBean.java
index 0655601..5629baa 100644
--- a/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB1/ejb/NewMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB1/ejb/NewMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Queue", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Queue"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Queue"),
     @ActivationConfigProperty(propertyName = "endpointExceptionRedeliveryAttempts", propertyValue = "1")
 })
 public class NewMessageBean implements MessageListener {
diff --git a/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB2/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB2/client/Client.java
index 6d05ea9..8f5f483 100644
--- a/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB2/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB2/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.jmsxdeliverycount.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.jmsxdeliverycount.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB2/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB2/create_resources.asadmin
index 299bc57..8a48a9c 100644
--- a/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB2/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB2/create_resources.asadmin
@@ -1,9 +1,9 @@
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 create-jmsdest --desttype queue jms_unit_test_Queue
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
 
 create-jmsdest --desttype queue jms_unit_result_Queue
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB2/ejb/MySessionBean.java b/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB2/ejb/MySessionBean.java
index 79d3b7e..029a788 100644
--- a/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB2/ejb/MySessionBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB2/ejb/MySessionBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,7 +20,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB2/ejb/NewMessageBean.java b/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB2/ejb/NewMessageBean.java
index 6d4a7b7..4ce092a 100644
--- a/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB2/ejb/NewMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB2/ejb/NewMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Queue", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Dups-ok-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Queue"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Queue"),
     @ActivationConfigProperty(propertyName = "endpointExceptionRedeliveryAttempts", propertyValue = "1")
 })
 public class NewMessageBean implements MessageListener {
diff --git a/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB3/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB3/client/Client.java
index 1a0cb39..053b9f7 100644
--- a/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB3/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB3/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.jmsxdeliverycount.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.jmsxdeliverycount.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB3/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB3/create_resources.asadmin
index 299bc57..8a48a9c 100644
--- a/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB3/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB3/create_resources.asadmin
@@ -1,9 +1,9 @@
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 create-jmsdest --desttype queue jms_unit_test_Queue
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
 
 create-jmsdest --desttype queue jms_unit_result_Queue
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB3/ejb/MySessionBean.java b/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB3/ejb/MySessionBean.java
index 79d3b7e..029a788 100644
--- a/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB3/ejb/MySessionBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB3/ejb/MySessionBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,7 +20,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB3/ejb/NewMessageBean.java b/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB3/ejb/NewMessageBean.java
index 0304d4e..5cad61b 100644
--- a/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB3/ejb/NewMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB3/ejb/NewMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Queue", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Queue"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Queue"),
     @ActivationConfigProperty(propertyName = "endpointExceptionRedeliveryAttempts", propertyValue = "1")
 })
 public class NewMessageBean implements MessageListener {
diff --git a/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB4/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB4/client/Client.java
index 0d23ad5..8f5b26c 100644
--- a/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB4/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB4/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.jmsxdeliverycount.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.jmsxdeliverycount.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB4/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB4/create_resources.asadmin
index 299bc57..8a48a9c 100644
--- a/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB4/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB4/create_resources.asadmin
@@ -1,9 +1,9 @@
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 create-jmsdest --desttype queue jms_unit_test_Queue
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
 
 create-jmsdest --desttype queue jms_unit_result_Queue
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB4/ejb/MySessionBean.java b/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB4/ejb/MySessionBean.java
index 79d3b7e..029a788 100644
--- a/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB4/ejb/MySessionBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB4/ejb/MySessionBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,7 +20,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB4/ejb/NewMessageBean.java b/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB4/ejb/NewMessageBean.java
index ab170a8..5d2dd71 100644
--- a/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB4/ejb/NewMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/MDB4/ejb/NewMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Queue", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Queue"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Queue"),
     @ActivationConfigProperty(propertyName = "endpointExceptionRedeliveryAttempts", propertyValue = "1")
 })
 public class NewMessageBean implements MessageListener {
diff --git a/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/sessionBean1/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/sessionBean1/client/Client.java
index f426bf7..73b21b6 100644
--- a/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/sessionBean1/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/sessionBean1/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.jmsxdeliverycount.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.jmsxdeliverycount.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/sessionBean1/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/sessionBean1/create_resources.asadmin
index 0841305..34cca97 100644
--- a/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/sessionBean1/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/sessionBean1/create_resources.asadmin
@@ -1,7 +1,7 @@
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 create-jmsdest --desttype queue jms_unit_test_Queue
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
 
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/sessionBean1/ejb/MySessionBean.java b/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/sessionBean1/ejb/MySessionBean.java
index ce5a341..423faa0 100644
--- a/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/sessionBean1/ejb/MySessionBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/sessionBean1/ejb/MySessionBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,7 +20,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/sessionBean2/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/sessionBean2/client/Client.java
index dab661e..a7f3135 100644
--- a/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/sessionBean2/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/sessionBean2/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.jmsxdeliverycount.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.jmsxdeliverycount.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/sessionBean2/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/sessionBean2/create_resources.asadmin
index 0841305..34cca97 100644
--- a/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/sessionBean2/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/sessionBean2/create_resources.asadmin
@@ -1,7 +1,7 @@
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 create-jmsdest --desttype queue jms_unit_test_Queue
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
 
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/sessionBean2/ejb/MySessionBean.java b/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/sessionBean2/ejb/MySessionBean.java
index 906c02a..0e22850 100644
--- a/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/sessionBean2/ejb/MySessionBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/JMSXDeliveryCount/sessionBean2/ejb/MySessionBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,7 +20,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/durableWithName/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/durableWithName/client/Client.java
index 557fc87..8ad4e3e 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/durableWithName/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/durableWithName/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.activationproperties.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.activationproperties.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/durableWithName/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/durableWithName/create_resources.asadmin
index 6a8be8c..18a2b37 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/durableWithName/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/durableWithName/create_resources.asadmin
@@ -1,9 +1,9 @@
-create-jms-resource --target jmstest-cluster --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --target jmstest-cluster --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 #create-jmsdest --target jmstest-cluster --desttype topic jms_unit_test_Topic
-create-jms-resource --target jmstest-cluster --restype javax.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
+create-jms-resource --target jmstest-cluster --restype jakarta.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
 
 #create-jmsdest --target jmstest-cluster --desttype queue jms_unit_result_Queue
-create-jms-resource --target jmstest-cluster --restype javax.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
+create-jms-resource --target jmstest-cluster --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/durableWithName/ejb/MySessionBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/durableWithName/ejb/MySessionBean.java
index 8c24abb..33442bc 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/durableWithName/ejb/MySessionBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/durableWithName/ejb/MySessionBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,7 +20,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/durableWithName/ejb/NewMessageBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/durableWithName/ejb/NewMessageBean.java
index 77a0302..44a9295 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/durableWithName/ejb/NewMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/durableWithName/ejb/NewMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "subscriptionScope", propertyValue = "Cluster"),
     @ActivationConfigProperty(propertyName = "subscriptionName", propertyValue = "xyz"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "Durable")
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/durableWithName/ejb/NewMessageBean2.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/durableWithName/ejb/NewMessageBean2.java
index 4a27ffd..c82147c 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/durableWithName/ejb/NewMessageBean2.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/durableWithName/ejb/NewMessageBean2.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "subscriptionScope", propertyValue = "Cluster"),
     @ActivationConfigProperty(propertyName = "subscriptionName", propertyValue = "xyz"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "Durable")
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/durableWithoutName/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/durableWithoutName/client/Client.java
index 15f502f..56b0c11 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/durableWithoutName/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/durableWithoutName/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.activationproperties.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.activationproperties.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/durableWithoutName/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/durableWithoutName/create_resources.asadmin
index 6a8be8c..18a2b37 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/durableWithoutName/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/durableWithoutName/create_resources.asadmin
@@ -1,9 +1,9 @@
-create-jms-resource --target jmstest-cluster --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --target jmstest-cluster --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 #create-jmsdest --target jmstest-cluster --desttype topic jms_unit_test_Topic
-create-jms-resource --target jmstest-cluster --restype javax.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
+create-jms-resource --target jmstest-cluster --restype jakarta.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
 
 #create-jmsdest --target jmstest-cluster --desttype queue jms_unit_result_Queue
-create-jms-resource --target jmstest-cluster --restype javax.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
+create-jms-resource --target jmstest-cluster --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/durableWithoutName/ejb/MySessionBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/durableWithoutName/ejb/MySessionBean.java
index 038c02b..41cbbc3 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/durableWithoutName/ejb/MySessionBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/durableWithoutName/ejb/MySessionBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,7 +20,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/durableWithoutName/ejb/NewMessageBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/durableWithoutName/ejb/NewMessageBean.java
index 2ca9f42..28cd5e5 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/durableWithoutName/ejb/NewMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/durableWithoutName/ejb/NewMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "subscriptionScope", propertyValue = "Cluster"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "Durable")
 })
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/durableWithoutName/ejb/NewMessageBean2.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/durableWithoutName/ejb/NewMessageBean2.java
index a1b2da4..786b7e5 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/durableWithoutName/ejb/NewMessageBean2.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/durableWithoutName/ejb/NewMessageBean2.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "subscriptionScope", propertyValue = "Cluster"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "Durable")
 })
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/nondurableWithName/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/nondurableWithName/client/Client.java
index 51eebcd..6485489 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/nondurableWithName/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/nondurableWithName/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.activationproperties.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.activationproperties.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/nondurableWithName/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/nondurableWithName/create_resources.asadmin
index 6a8be8c..18a2b37 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/nondurableWithName/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/nondurableWithName/create_resources.asadmin
@@ -1,9 +1,9 @@
-create-jms-resource --target jmstest-cluster --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --target jmstest-cluster --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 #create-jmsdest --target jmstest-cluster --desttype topic jms_unit_test_Topic
-create-jms-resource --target jmstest-cluster --restype javax.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
+create-jms-resource --target jmstest-cluster --restype jakarta.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
 
 #create-jmsdest --target jmstest-cluster --desttype queue jms_unit_result_Queue
-create-jms-resource --target jmstest-cluster --restype javax.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
+create-jms-resource --target jmstest-cluster --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/nondurableWithName/ejb/MySessionBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/nondurableWithName/ejb/MySessionBean.java
index 8c24abb..33442bc 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/nondurableWithName/ejb/MySessionBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/nondurableWithName/ejb/MySessionBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,7 +20,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/nondurableWithName/ejb/NewMessageBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/nondurableWithName/ejb/NewMessageBean.java
index 198039f..9067a01 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/nondurableWithName/ejb/NewMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/nondurableWithName/ejb/NewMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "subscriptionScope", propertyValue = "Cluster"),
     @ActivationConfigProperty(propertyName = "subscriptionName", propertyValue = "xyz"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "NonDurable")
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/nondurableWithName/ejb/NewMessageBean2.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/nondurableWithName/ejb/NewMessageBean2.java
index 71e2047..cdcd800 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/nondurableWithName/ejb/NewMessageBean2.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/nondurableWithName/ejb/NewMessageBean2.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "subscriptionScope", propertyValue = "Cluster"),
     @ActivationConfigProperty(propertyName = "subscriptionName", propertyValue = "xyz"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "NonDurable")
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/nondurableWithoutName/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/nondurableWithoutName/client/Client.java
index 4f2523a..38462e2 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/nondurableWithoutName/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/nondurableWithoutName/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.activationproperties.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.activationproperties.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/nondurableWithoutName/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/nondurableWithoutName/create_resources.asadmin
index 6a8be8c..18a2b37 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/nondurableWithoutName/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/nondurableWithoutName/create_resources.asadmin
@@ -1,9 +1,9 @@
-create-jms-resource --target jmstest-cluster --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --target jmstest-cluster --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 #create-jmsdest --target jmstest-cluster --desttype topic jms_unit_test_Topic
-create-jms-resource --target jmstest-cluster --restype javax.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
+create-jms-resource --target jmstest-cluster --restype jakarta.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
 
 #create-jmsdest --target jmstest-cluster --desttype queue jms_unit_result_Queue
-create-jms-resource --target jmstest-cluster --restype javax.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
+create-jms-resource --target jmstest-cluster --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/nondurableWithoutName/ejb/MySessionBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/nondurableWithoutName/ejb/MySessionBean.java
index 038c02b..41cbbc3 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/nondurableWithoutName/ejb/MySessionBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/nondurableWithoutName/ejb/MySessionBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,7 +20,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/nondurableWithoutName/ejb/NewMessageBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/nondurableWithoutName/ejb/NewMessageBean.java
index d1356d2..cacf433 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/nondurableWithoutName/ejb/NewMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/nondurableWithoutName/ejb/NewMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "subscriptionScope", propertyValue = "Cluster"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "NonDurable")
 })
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/nondurableWithoutName/ejb/NewMessageBean2.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/nondurableWithoutName/ejb/NewMessageBean2.java
index d8a2c68..1240638 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/nondurableWithoutName/ejb/NewMessageBean2.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/ClusterScope/nondurableWithoutName/ejb/NewMessageBean2.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "subscriptionScope", propertyValue = "Cluster"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "NonDurable")
 })
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/durableWithName/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/durableWithName/client/Client.java
index 34e03ce..a0a2499 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/durableWithName/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/durableWithName/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.activationproperties.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.activationproperties.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/durableWithName/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/durableWithName/create_resources.asadmin
index 6a8be8c..18a2b37 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/durableWithName/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/durableWithName/create_resources.asadmin
@@ -1,9 +1,9 @@
-create-jms-resource --target jmstest-cluster --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --target jmstest-cluster --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 #create-jmsdest --target jmstest-cluster --desttype topic jms_unit_test_Topic
-create-jms-resource --target jmstest-cluster --restype javax.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
+create-jms-resource --target jmstest-cluster --restype jakarta.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
 
 #create-jmsdest --target jmstest-cluster --desttype queue jms_unit_result_Queue
-create-jms-resource --target jmstest-cluster --restype javax.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
+create-jms-resource --target jmstest-cluster --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/durableWithName/ejb/MySessionBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/durableWithName/ejb/MySessionBean.java
index bdf339e..23b2f9b 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/durableWithName/ejb/MySessionBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/durableWithName/ejb/MySessionBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,7 +20,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/durableWithName/ejb/NewMessageBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/durableWithName/ejb/NewMessageBean.java
index 6d9e308..6613c30 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/durableWithName/ejb/NewMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/durableWithName/ejb/NewMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "subscriptionScope", propertyValue = "Instance"),
     @ActivationConfigProperty(propertyName = "subscriptionName", propertyValue = "xyz"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "Durable")
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/durableWithName/ejb/NewMessageBean2.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/durableWithName/ejb/NewMessageBean2.java
index 18f0e09..a8a6409 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/durableWithName/ejb/NewMessageBean2.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/durableWithName/ejb/NewMessageBean2.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "subscriptionScope", propertyValue = "Instance"),
     @ActivationConfigProperty(propertyName = "subscriptionName", propertyValue = "xyz"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "Durable")
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/durableWithoutName/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/durableWithoutName/client/Client.java
index aa07751..724c6d1 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/durableWithoutName/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/durableWithoutName/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.activationproperties.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.activationproperties.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/durableWithoutName/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/durableWithoutName/create_resources.asadmin
index 6a8be8c..18a2b37 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/durableWithoutName/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/durableWithoutName/create_resources.asadmin
@@ -1,9 +1,9 @@
-create-jms-resource --target jmstest-cluster --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --target jmstest-cluster --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 #create-jmsdest --target jmstest-cluster --desttype topic jms_unit_test_Topic
-create-jms-resource --target jmstest-cluster --restype javax.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
+create-jms-resource --target jmstest-cluster --restype jakarta.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
 
 #create-jmsdest --target jmstest-cluster --desttype queue jms_unit_result_Queue
-create-jms-resource --target jmstest-cluster --restype javax.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
+create-jms-resource --target jmstest-cluster --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/durableWithoutName/ejb/MySessionBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/durableWithoutName/ejb/MySessionBean.java
index e23b9d6..c817e21 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/durableWithoutName/ejb/MySessionBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/durableWithoutName/ejb/MySessionBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,7 +20,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/durableWithoutName/ejb/NewMessageBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/durableWithoutName/ejb/NewMessageBean.java
index d9fce7b..1fa993c 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/durableWithoutName/ejb/NewMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/durableWithoutName/ejb/NewMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "subscriptionScope", propertyValue = "Instance"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "Durable")
 })
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/durableWithoutName/ejb/NewMessageBean2.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/durableWithoutName/ejb/NewMessageBean2.java
index 099cf40..7fa7d0b 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/durableWithoutName/ejb/NewMessageBean2.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/durableWithoutName/ejb/NewMessageBean2.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "subscriptionScope", propertyValue = "Instance"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "Durable")
 })
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/nondurableWithName/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/nondurableWithName/client/Client.java
index 7c24d17..ac1dfc6 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/nondurableWithName/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/nondurableWithName/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.activationproperties.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.activationproperties.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/nondurableWithName/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/nondurableWithName/create_resources.asadmin
index 6a8be8c..18a2b37 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/nondurableWithName/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/nondurableWithName/create_resources.asadmin
@@ -1,9 +1,9 @@
-create-jms-resource --target jmstest-cluster --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --target jmstest-cluster --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 #create-jmsdest --target jmstest-cluster --desttype topic jms_unit_test_Topic
-create-jms-resource --target jmstest-cluster --restype javax.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
+create-jms-resource --target jmstest-cluster --restype jakarta.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
 
 #create-jmsdest --target jmstest-cluster --desttype queue jms_unit_result_Queue
-create-jms-resource --target jmstest-cluster --restype javax.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
+create-jms-resource --target jmstest-cluster --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/nondurableWithName/ejb/MySessionBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/nondurableWithName/ejb/MySessionBean.java
index 038c02b..41cbbc3 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/nondurableWithName/ejb/MySessionBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/nondurableWithName/ejb/MySessionBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,7 +20,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/nondurableWithName/ejb/NewMessageBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/nondurableWithName/ejb/NewMessageBean.java
index 986185a..fa0748a 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/nondurableWithName/ejb/NewMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/nondurableWithName/ejb/NewMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "subscriptionScope", propertyValue = "Instance"),
     @ActivationConfigProperty(propertyName = "subscriptionName", propertyValue = "xyz"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "NonDurable")
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/nondurableWithName/ejb/NewMessageBean2.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/nondurableWithName/ejb/NewMessageBean2.java
index 902392a..a929a56 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/nondurableWithName/ejb/NewMessageBean2.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/nondurableWithName/ejb/NewMessageBean2.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "subscriptionScope", propertyValue = "Instance"),
     @ActivationConfigProperty(propertyName = "subscriptionName", propertyValue = "xyz"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "NonDurable")
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/nondurableWithoutName/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/nondurableWithoutName/client/Client.java
index db7ab2e..e8ebf1f 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/nondurableWithoutName/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/nondurableWithoutName/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.activationproperties.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.activationproperties.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/nondurableWithoutName/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/nondurableWithoutName/create_resources.asadmin
index 6a8be8c..18a2b37 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/nondurableWithoutName/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/nondurableWithoutName/create_resources.asadmin
@@ -1,9 +1,9 @@
-create-jms-resource --target jmstest-cluster --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --target jmstest-cluster --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 #create-jmsdest --target jmstest-cluster --desttype topic jms_unit_test_Topic
-create-jms-resource --target jmstest-cluster --restype javax.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
+create-jms-resource --target jmstest-cluster --restype jakarta.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
 
 #create-jmsdest --target jmstest-cluster --desttype queue jms_unit_result_Queue
-create-jms-resource --target jmstest-cluster --restype javax.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
+create-jms-resource --target jmstest-cluster --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/nondurableWithoutName/ejb/MySessionBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/nondurableWithoutName/ejb/MySessionBean.java
index e23b9d6..c817e21 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/nondurableWithoutName/ejb/MySessionBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/nondurableWithoutName/ejb/MySessionBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,7 +20,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/nondurableWithoutName/ejb/NewMessageBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/nondurableWithoutName/ejb/NewMessageBean.java
index a5f48f9..d8b6068 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/nondurableWithoutName/ejb/NewMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/nondurableWithoutName/ejb/NewMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "subscriptionScope", propertyValue = "Instance"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "NonDurable")
 })
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/nondurableWithoutName/ejb/NewMessageBean2.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/nondurableWithoutName/ejb/NewMessageBean2.java
index cdcca02..854d73d 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/nondurableWithoutName/ejb/NewMessageBean2.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/InstanceScope/nondurableWithoutName/ejb/NewMessageBean2.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "subscriptionScope", propertyValue = "Instance"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "NonDurable")
 })
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/durableNoClientIdWithName/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/durableNoClientIdWithName/client/Client.java
index 93bd1f7..0624362 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/durableNoClientIdWithName/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/durableNoClientIdWithName/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.activationproperties.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.activationproperties.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/durableNoClientIdWithName/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/durableNoClientIdWithName/create_resources.asadmin
index 6a8be8c..18a2b37 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/durableNoClientIdWithName/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/durableNoClientIdWithName/create_resources.asadmin
@@ -1,9 +1,9 @@
-create-jms-resource --target jmstest-cluster --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --target jmstest-cluster --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 #create-jmsdest --target jmstest-cluster --desttype topic jms_unit_test_Topic
-create-jms-resource --target jmstest-cluster --restype javax.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
+create-jms-resource --target jmstest-cluster --restype jakarta.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
 
 #create-jmsdest --target jmstest-cluster --desttype queue jms_unit_result_Queue
-create-jms-resource --target jmstest-cluster --restype javax.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
+create-jms-resource --target jmstest-cluster --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/durableNoClientIdWithName/ejb/MySessionBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/durableNoClientIdWithName/ejb/MySessionBean.java
index 8c24abb..33442bc 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/durableNoClientIdWithName/ejb/MySessionBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/durableNoClientIdWithName/ejb/MySessionBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,7 +20,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/durableNoClientIdWithName/ejb/NewMessageBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/durableNoClientIdWithName/ejb/NewMessageBean.java
index e04ab6f..7a358a8 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/durableNoClientIdWithName/ejb/NewMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/durableNoClientIdWithName/ejb/NewMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "subscriptionName", propertyValue = "xyz"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "Durable")
 })
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/durableWithName/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/durableWithName/client/Client.java
index f6ddcd0..211ea4b 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/durableWithName/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/durableWithName/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.activationproperties.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.activationproperties.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/durableWithName/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/durableWithName/create_resources.asadmin
index 6a8be8c..18a2b37 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/durableWithName/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/durableWithName/create_resources.asadmin
@@ -1,9 +1,9 @@
-create-jms-resource --target jmstest-cluster --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --target jmstest-cluster --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 #create-jmsdest --target jmstest-cluster --desttype topic jms_unit_test_Topic
-create-jms-resource --target jmstest-cluster --restype javax.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
+create-jms-resource --target jmstest-cluster --restype jakarta.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
 
 #create-jmsdest --target jmstest-cluster --desttype queue jms_unit_result_Queue
-create-jms-resource --target jmstest-cluster --restype javax.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
+create-jms-resource --target jmstest-cluster --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/durableWithName/ejb/MySessionBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/durableWithName/ejb/MySessionBean.java
index 8c24abb..33442bc 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/durableWithName/ejb/MySessionBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/durableWithName/ejb/MySessionBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,7 +20,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/durableWithName/ejb/NewMessageBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/durableWithName/ejb/NewMessageBean.java
index 95f81c5..f2e8b5f 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/durableWithName/ejb/NewMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/durableWithName/ejb/NewMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "subscriptionName", propertyValue = "xyz"),
     @ActivationConfigProperty(propertyName = "clientId", propertyValue = "abc"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "Durable")
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableNotSharedWithName/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableNotSharedWithName/client/Client.java
index 146a743..e0abcfb 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableNotSharedWithName/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableNotSharedWithName/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.activationproperties.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.activationproperties.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableNotSharedWithName/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableNotSharedWithName/create_resources.asadmin
index 6a8be8c..18a2b37 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableNotSharedWithName/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableNotSharedWithName/create_resources.asadmin
@@ -1,9 +1,9 @@
-create-jms-resource --target jmstest-cluster --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --target jmstest-cluster --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 #create-jmsdest --target jmstest-cluster --desttype topic jms_unit_test_Topic
-create-jms-resource --target jmstest-cluster --restype javax.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
+create-jms-resource --target jmstest-cluster --restype jakarta.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
 
 #create-jmsdest --target jmstest-cluster --desttype queue jms_unit_result_Queue
-create-jms-resource --target jmstest-cluster --restype javax.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
+create-jms-resource --target jmstest-cluster --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableNotSharedWithName/ejb/MySessionBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableNotSharedWithName/ejb/MySessionBean.java
index cd906e5..34e2466 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableNotSharedWithName/ejb/MySessionBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableNotSharedWithName/ejb/MySessionBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,7 +20,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableNotSharedWithName/ejb/NewMessageBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableNotSharedWithName/ejb/NewMessageBean.java
index 0db2915..4c04054 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableNotSharedWithName/ejb/NewMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableNotSharedWithName/ejb/NewMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "useSharedSubscriptionInClusteredContainer", propertyValue = "false"),
     @ActivationConfigProperty(propertyName = "subscriptionName", propertyValue = "xyz"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "NonDurable")
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableNotSharedWithoutName/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableNotSharedWithoutName/client/Client.java
index ab295d3..93ef1ee 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableNotSharedWithoutName/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableNotSharedWithoutName/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.activationproperties.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.activationproperties.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableNotSharedWithoutName/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableNotSharedWithoutName/create_resources.asadmin
index 6a8be8c..18a2b37 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableNotSharedWithoutName/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableNotSharedWithoutName/create_resources.asadmin
@@ -1,9 +1,9 @@
-create-jms-resource --target jmstest-cluster --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --target jmstest-cluster --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 #create-jmsdest --target jmstest-cluster --desttype topic jms_unit_test_Topic
-create-jms-resource --target jmstest-cluster --restype javax.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
+create-jms-resource --target jmstest-cluster --restype jakarta.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
 
 #create-jmsdest --target jmstest-cluster --desttype queue jms_unit_result_Queue
-create-jms-resource --target jmstest-cluster --restype javax.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
+create-jms-resource --target jmstest-cluster --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableNotSharedWithoutName/ejb/MySessionBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableNotSharedWithoutName/ejb/MySessionBean.java
index 038c02b..41cbbc3 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableNotSharedWithoutName/ejb/MySessionBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableNotSharedWithoutName/ejb/MySessionBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,7 +20,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableNotSharedWithoutName/ejb/NewMessageBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableNotSharedWithoutName/ejb/NewMessageBean.java
index 8082820..57fe3c4 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableNotSharedWithoutName/ejb/NewMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableNotSharedWithoutName/ejb/NewMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "useSharedSubscriptionInClusteredContainer", propertyValue = "false"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "NonDurable")
 })
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableWithName/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableWithName/client/Client.java
index 23dae0b..7faee53 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableWithName/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableWithName/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.activationproperties.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.activationproperties.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableWithName/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableWithName/create_resources.asadmin
index 6a8be8c..18a2b37 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableWithName/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableWithName/create_resources.asadmin
@@ -1,9 +1,9 @@
-create-jms-resource --target jmstest-cluster --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --target jmstest-cluster --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 #create-jmsdest --target jmstest-cluster --desttype topic jms_unit_test_Topic
-create-jms-resource --target jmstest-cluster --restype javax.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
+create-jms-resource --target jmstest-cluster --restype jakarta.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
 
 #create-jmsdest --target jmstest-cluster --desttype queue jms_unit_result_Queue
-create-jms-resource --target jmstest-cluster --restype javax.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
+create-jms-resource --target jmstest-cluster --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableWithName/ejb/MySessionBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableWithName/ejb/MySessionBean.java
index 8c24abb..33442bc 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableWithName/ejb/MySessionBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableWithName/ejb/MySessionBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,7 +20,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableWithName/ejb/NewMessageBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableWithName/ejb/NewMessageBean.java
index 577b519..9c3f9c1 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableWithName/ejb/NewMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableWithName/ejb/NewMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "clientId", propertyValue = "abc"),
     @ActivationConfigProperty(propertyName = "subscriptionName", propertyValue = "xyz"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "NonDurable")
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableWithoutName/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableWithoutName/client/Client.java
index b081d5f..5240025 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableWithoutName/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableWithoutName/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.activationproperties.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.activationproperties.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableWithoutName/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableWithoutName/create_resources.asadmin
index 6a8be8c..18a2b37 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableWithoutName/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableWithoutName/create_resources.asadmin
@@ -1,9 +1,9 @@
-create-jms-resource --target jmstest-cluster --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --target jmstest-cluster --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 #create-jmsdest --target jmstest-cluster --desttype topic jms_unit_test_Topic
-create-jms-resource --target jmstest-cluster --restype javax.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
+create-jms-resource --target jmstest-cluster --restype jakarta.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
 
 #create-jmsdest --target jmstest-cluster --desttype queue jms_unit_result_Queue
-create-jms-resource --target jmstest-cluster --restype javax.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
+create-jms-resource --target jmstest-cluster --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableWithoutName/ejb/MySessionBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableWithoutName/ejb/MySessionBean.java
index c4e3bc0..5faabe8 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableWithoutName/ejb/MySessionBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableWithoutName/ejb/MySessionBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,7 +20,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableWithoutName/ejb/NewMessageBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableWithoutName/ejb/NewMessageBean.java
index 3c7de0a..a8f9e49 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableWithoutName/ejb/NewMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/cluster/noScope/nondurableWithoutName/ejb/NewMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "clientId", propertyValue = "abc"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "NonDurable")
 })
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/durableWithName/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/durableWithName/client/Client.java
index 9f2ab86..8983676 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/durableWithName/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/durableWithName/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.activationproperties.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.activationproperties.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/durableWithName/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/durableWithName/create_resources.asadmin
index b58b7d2..925391b 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/durableWithName/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/durableWithName/create_resources.asadmin
@@ -1,9 +1,9 @@
-create-jms-resource --target server --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --target server --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 create-jmsdest --target server --desttype topic jms_unit_test_Topic
-create-jms-resource --target server --restype javax.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
+create-jms-resource --target server --restype jakarta.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
 
 create-jmsdest --target server --desttype queue jms_unit_result_Queue
-create-jms-resource --target server --restype javax.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
+create-jms-resource --target server --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/durableWithName/ejb/MySessionBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/durableWithName/ejb/MySessionBean.java
index 8c24abb..33442bc 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/durableWithName/ejb/MySessionBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/durableWithName/ejb/MySessionBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,7 +20,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/durableWithName/ejb/NewMessageBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/durableWithName/ejb/NewMessageBean.java
index 11ffa01..f616d4e 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/durableWithName/ejb/NewMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/durableWithName/ejb/NewMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "subscriptionScope", propertyValue = "Cluster"),
     @ActivationConfigProperty(propertyName = "subscriptionName", propertyValue = "xyz"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "Durable")
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/durableWithName/ejb/NewMessageBean2.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/durableWithName/ejb/NewMessageBean2.java
index 148c113..98e6ac5 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/durableWithName/ejb/NewMessageBean2.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/durableWithName/ejb/NewMessageBean2.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "subscriptionScope", propertyValue = "Cluster"),
     @ActivationConfigProperty(propertyName = "subscriptionName", propertyValue = "xyz"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "Durable")
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/durableWithoutName/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/durableWithoutName/client/Client.java
index e8c3185..bb4e15b 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/durableWithoutName/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/durableWithoutName/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.activationproperties.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.activationproperties.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/durableWithoutName/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/durableWithoutName/create_resources.asadmin
index b58b7d2..925391b 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/durableWithoutName/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/durableWithoutName/create_resources.asadmin
@@ -1,9 +1,9 @@
-create-jms-resource --target server --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --target server --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 create-jmsdest --target server --desttype topic jms_unit_test_Topic
-create-jms-resource --target server --restype javax.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
+create-jms-resource --target server --restype jakarta.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
 
 create-jmsdest --target server --desttype queue jms_unit_result_Queue
-create-jms-resource --target server --restype javax.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
+create-jms-resource --target server --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/durableWithoutName/ejb/MySessionBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/durableWithoutName/ejb/MySessionBean.java
index 038c02b..41cbbc3 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/durableWithoutName/ejb/MySessionBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/durableWithoutName/ejb/MySessionBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,7 +20,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/durableWithoutName/ejb/NewMessageBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/durableWithoutName/ejb/NewMessageBean.java
index a9f0959..f22bee3 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/durableWithoutName/ejb/NewMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/durableWithoutName/ejb/NewMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "subscriptionScope", propertyValue = "Cluster"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "Durable")
 })
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/durableWithoutName/ejb/NewMessageBean2.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/durableWithoutName/ejb/NewMessageBean2.java
index 8244084..9f857ee 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/durableWithoutName/ejb/NewMessageBean2.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/durableWithoutName/ejb/NewMessageBean2.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,12 +19,11 @@
 import java.util.logging.*;
 import javax.annotation.Resource;
 import javax.ejb.*;
-import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "subscriptionScope", propertyValue = "Cluster"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "Durable")
 })
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/nondurableWithName/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/nondurableWithName/client/Client.java
index cc2b303..dbe5985 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/nondurableWithName/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/nondurableWithName/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.activationproperties.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.activationproperties.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/nondurableWithName/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/nondurableWithName/create_resources.asadmin
index b58b7d2..925391b 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/nondurableWithName/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/nondurableWithName/create_resources.asadmin
@@ -1,9 +1,9 @@
-create-jms-resource --target server --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --target server --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 create-jmsdest --target server --desttype topic jms_unit_test_Topic
-create-jms-resource --target server --restype javax.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
+create-jms-resource --target server --restype jakarta.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
 
 create-jmsdest --target server --desttype queue jms_unit_result_Queue
-create-jms-resource --target server --restype javax.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
+create-jms-resource --target server --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/nondurableWithName/ejb/MySessionBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/nondurableWithName/ejb/MySessionBean.java
index 8c24abb..33442bc 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/nondurableWithName/ejb/MySessionBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/nondurableWithName/ejb/MySessionBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,7 +20,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/nondurableWithName/ejb/NewMessageBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/nondurableWithName/ejb/NewMessageBean.java
index ef51a2d..7332da4 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/nondurableWithName/ejb/NewMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/nondurableWithName/ejb/NewMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "subscriptionScope", propertyValue = "Cluster"),
     @ActivationConfigProperty(propertyName = "subscriptionName", propertyValue = "xyz"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "NonDurable")
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/nondurableWithName/ejb/NewMessageBean2.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/nondurableWithName/ejb/NewMessageBean2.java
index ede68c9..8acbae9 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/nondurableWithName/ejb/NewMessageBean2.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/nondurableWithName/ejb/NewMessageBean2.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "subscriptionScope", propertyValue = "Cluster"),
     @ActivationConfigProperty(propertyName = "subscriptionName", propertyValue = "xyz"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "NonDurable")
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/nondurableWithoutName/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/nondurableWithoutName/client/Client.java
index 9983654..bc18bc3 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/nondurableWithoutName/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/nondurableWithoutName/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.activationproperties.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.activationproperties.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/nondurableWithoutName/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/nondurableWithoutName/create_resources.asadmin
index b58b7d2..925391b 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/nondurableWithoutName/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/nondurableWithoutName/create_resources.asadmin
@@ -1,9 +1,9 @@
-create-jms-resource --target server --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --target server --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 create-jmsdest --target server --desttype topic jms_unit_test_Topic
-create-jms-resource --target server --restype javax.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
+create-jms-resource --target server --restype jakarta.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
 
 create-jmsdest --target server --desttype queue jms_unit_result_Queue
-create-jms-resource --target server --restype javax.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
+create-jms-resource --target server --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/nondurableWithoutName/ejb/MySessionBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/nondurableWithoutName/ejb/MySessionBean.java
index 038c02b..41cbbc3 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/nondurableWithoutName/ejb/MySessionBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/nondurableWithoutName/ejb/MySessionBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,7 +20,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/nondurableWithoutName/ejb/NewMessageBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/nondurableWithoutName/ejb/NewMessageBean.java
index a0c2070..6ccb588 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/nondurableWithoutName/ejb/NewMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/nondurableWithoutName/ejb/NewMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "subscriptionScope", propertyValue = "Cluster"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "NonDurable")
 })
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/nondurableWithoutName/ejb/NewMessageBean2.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/nondurableWithoutName/ejb/NewMessageBean2.java
index 1b676c4..7a8d37e 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/nondurableWithoutName/ejb/NewMessageBean2.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/ClusterScope/nondurableWithoutName/ejb/NewMessageBean2.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "subscriptionScope", propertyValue = "Cluster"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "NonDurable")
 })
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/durableWithName/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/durableWithName/client/Client.java
index 8f8489b..720ee6e 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/durableWithName/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/durableWithName/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.activationproperties.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.activationproperties.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/durableWithName/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/durableWithName/create_resources.asadmin
index b58b7d2..925391b 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/durableWithName/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/durableWithName/create_resources.asadmin
@@ -1,9 +1,9 @@
-create-jms-resource --target server --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --target server --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 create-jmsdest --target server --desttype topic jms_unit_test_Topic
-create-jms-resource --target server --restype javax.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
+create-jms-resource --target server --restype jakarta.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
 
 create-jmsdest --target server --desttype queue jms_unit_result_Queue
-create-jms-resource --target server --restype javax.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
+create-jms-resource --target server --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/durableWithName/ejb/MySessionBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/durableWithName/ejb/MySessionBean.java
index 8c24abb..33442bc 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/durableWithName/ejb/MySessionBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/durableWithName/ejb/MySessionBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,7 +20,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/durableWithName/ejb/NewMessageBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/durableWithName/ejb/NewMessageBean.java
index e666ac3..e04f5c8 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/durableWithName/ejb/NewMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/durableWithName/ejb/NewMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "subscriptionScope", propertyValue = "Instance"),
     @ActivationConfigProperty(propertyName = "subscriptionName", propertyValue = "xyz"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "Durable")
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/durableWithName/ejb/NewMessageBean2.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/durableWithName/ejb/NewMessageBean2.java
index 9cd57a5..7d13081 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/durableWithName/ejb/NewMessageBean2.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/durableWithName/ejb/NewMessageBean2.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "subscriptionScope", propertyValue = "Instance"),
     @ActivationConfigProperty(propertyName = "subscriptionName", propertyValue = "xyz"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "Durable")
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/durableWithoutName/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/durableWithoutName/client/Client.java
index 06bf2a7..52d8b2f 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/durableWithoutName/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/durableWithoutName/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.activationproperties.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.activationproperties.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/durableWithoutName/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/durableWithoutName/create_resources.asadmin
index b58b7d2..925391b 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/durableWithoutName/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/durableWithoutName/create_resources.asadmin
@@ -1,9 +1,9 @@
-create-jms-resource --target server --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --target server --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 create-jmsdest --target server --desttype topic jms_unit_test_Topic
-create-jms-resource --target server --restype javax.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
+create-jms-resource --target server --restype jakarta.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
 
 create-jmsdest --target server --desttype queue jms_unit_result_Queue
-create-jms-resource --target server --restype javax.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
+create-jms-resource --target server --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/durableWithoutName/ejb/MySessionBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/durableWithoutName/ejb/MySessionBean.java
index 038c02b..41cbbc3 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/durableWithoutName/ejb/MySessionBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/durableWithoutName/ejb/MySessionBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,7 +20,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/durableWithoutName/ejb/NewMessageBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/durableWithoutName/ejb/NewMessageBean.java
index 3940313..193a3e1 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/durableWithoutName/ejb/NewMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/durableWithoutName/ejb/NewMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "subscriptionScope", propertyValue = "Instance"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "Durable")
 })
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/durableWithoutName/ejb/NewMessageBean2.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/durableWithoutName/ejb/NewMessageBean2.java
index 094aac2..ca6a75a 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/durableWithoutName/ejb/NewMessageBean2.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/durableWithoutName/ejb/NewMessageBean2.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "subscriptionScope", propertyValue = "Instance"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "Durable")
 })
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/nondurableWithName/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/nondurableWithName/client/Client.java
index 983e4c2..4057a05 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/nondurableWithName/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/nondurableWithName/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.activationproperties.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.activationproperties.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/nondurableWithName/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/nondurableWithName/create_resources.asadmin
index b58b7d2..925391b 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/nondurableWithName/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/nondurableWithName/create_resources.asadmin
@@ -1,9 +1,9 @@
-create-jms-resource --target server --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --target server --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 create-jmsdest --target server --desttype topic jms_unit_test_Topic
-create-jms-resource --target server --restype javax.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
+create-jms-resource --target server --restype jakarta.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
 
 create-jmsdest --target server --desttype queue jms_unit_result_Queue
-create-jms-resource --target server --restype javax.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
+create-jms-resource --target server --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/nondurableWithName/ejb/MySessionBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/nondurableWithName/ejb/MySessionBean.java
index 8c24abb..33442bc 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/nondurableWithName/ejb/MySessionBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/nondurableWithName/ejb/MySessionBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,7 +20,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/nondurableWithName/ejb/NewMessageBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/nondurableWithName/ejb/NewMessageBean.java
index ffce3fd..4cd9a8f 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/nondurableWithName/ejb/NewMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/nondurableWithName/ejb/NewMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "subscriptionScope", propertyValue = "Instance"),
     @ActivationConfigProperty(propertyName = "subscriptionName", propertyValue = "xyz"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "NonDurable")
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/nondurableWithName/ejb/NewMessageBean2.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/nondurableWithName/ejb/NewMessageBean2.java
index 6eaf05a..7039600 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/nondurableWithName/ejb/NewMessageBean2.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/nondurableWithName/ejb/NewMessageBean2.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "subscriptionScope", propertyValue = "Instance"),
     @ActivationConfigProperty(propertyName = "subscriptionName", propertyValue = "xyz"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "NonDurable")
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/nondurableWithoutName/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/nondurableWithoutName/client/Client.java
index 552eb4a..3d33c40 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/nondurableWithoutName/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/nondurableWithoutName/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.activationproperties.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.activationproperties.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/nondurableWithoutName/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/nondurableWithoutName/create_resources.asadmin
index b58b7d2..925391b 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/nondurableWithoutName/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/nondurableWithoutName/create_resources.asadmin
@@ -1,9 +1,9 @@
-create-jms-resource --target server --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --target server --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 create-jmsdest --target server --desttype topic jms_unit_test_Topic
-create-jms-resource --target server --restype javax.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
+create-jms-resource --target server --restype jakarta.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
 
 create-jmsdest --target server --desttype queue jms_unit_result_Queue
-create-jms-resource --target server --restype javax.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
+create-jms-resource --target server --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/nondurableWithoutName/ejb/MySessionBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/nondurableWithoutName/ejb/MySessionBean.java
index 038c02b..41cbbc3 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/nondurableWithoutName/ejb/MySessionBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/nondurableWithoutName/ejb/MySessionBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,7 +20,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/nondurableWithoutName/ejb/NewMessageBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/nondurableWithoutName/ejb/NewMessageBean.java
index a0148bc..0b8907f 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/nondurableWithoutName/ejb/NewMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/nondurableWithoutName/ejb/NewMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "subscriptionScope", propertyValue = "Instance"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "NonDurable")
 })
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/nondurableWithoutName/ejb/NewMessageBean2.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/nondurableWithoutName/ejb/NewMessageBean2.java
index 431b879..a8917ac 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/nondurableWithoutName/ejb/NewMessageBean2.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/InstanceScope/nondurableWithoutName/ejb/NewMessageBean2.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "subscriptionScope", propertyValue = "Instance"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "NonDurable")
 })
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/durableNoClientIdWithName/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/durableNoClientIdWithName/client/Client.java
index 7181005..f16a81a 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/durableNoClientIdWithName/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/durableNoClientIdWithName/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.activationproperties.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.activationproperties.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/durableNoClientIdWithName/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/durableNoClientIdWithName/create_resources.asadmin
index b58b7d2..925391b 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/durableNoClientIdWithName/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/durableNoClientIdWithName/create_resources.asadmin
@@ -1,9 +1,9 @@
-create-jms-resource --target server --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --target server --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 create-jmsdest --target server --desttype topic jms_unit_test_Topic
-create-jms-resource --target server --restype javax.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
+create-jms-resource --target server --restype jakarta.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
 
 create-jmsdest --target server --desttype queue jms_unit_result_Queue
-create-jms-resource --target server --restype javax.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
+create-jms-resource --target server --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/durableNoClientIdWithName/ejb/MySessionBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/durableNoClientIdWithName/ejb/MySessionBean.java
index 8c24abb..33442bc 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/durableNoClientIdWithName/ejb/MySessionBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/durableNoClientIdWithName/ejb/MySessionBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,7 +20,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/durableNoClientIdWithName/ejb/NewMessageBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/durableNoClientIdWithName/ejb/NewMessageBean.java
index e991f18..e803ac2 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/durableNoClientIdWithName/ejb/NewMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/durableNoClientIdWithName/ejb/NewMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "subscriptionName", propertyValue = "xyz"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "Durable")
 })
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/durableWithName/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/durableWithName/client/Client.java
index 11624b6..bb8d2db 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/durableWithName/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/durableWithName/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.activationproperties.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.activationproperties.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/durableWithName/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/durableWithName/create_resources.asadmin
index b58b7d2..925391b 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/durableWithName/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/durableWithName/create_resources.asadmin
@@ -1,9 +1,9 @@
-create-jms-resource --target server --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --target server --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 create-jmsdest --target server --desttype topic jms_unit_test_Topic
-create-jms-resource --target server --restype javax.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
+create-jms-resource --target server --restype jakarta.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
 
 create-jmsdest --target server --desttype queue jms_unit_result_Queue
-create-jms-resource --target server --restype javax.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
+create-jms-resource --target server --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/durableWithName/ejb/MySessionBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/durableWithName/ejb/MySessionBean.java
index 8c24abb..33442bc 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/durableWithName/ejb/MySessionBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/durableWithName/ejb/MySessionBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,7 +20,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/durableWithName/ejb/NewMessageBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/durableWithName/ejb/NewMessageBean.java
index 62d14e4..bd8cfa9 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/durableWithName/ejb/NewMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/durableWithName/ejb/NewMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "subscriptionName", propertyValue = "xyz"),
     @ActivationConfigProperty(propertyName = "clientId", propertyValue = "abc"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "Durable")
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/nondurableWithName/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/nondurableWithName/client/Client.java
index 5d83cb8..afd432c 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/nondurableWithName/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/nondurableWithName/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.activationproperties.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.activationproperties.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/nondurableWithName/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/nondurableWithName/create_resources.asadmin
index b58b7d2..925391b 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/nondurableWithName/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/nondurableWithName/create_resources.asadmin
@@ -1,9 +1,9 @@
-create-jms-resource --target server --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --target server --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 create-jmsdest --target server --desttype topic jms_unit_test_Topic
-create-jms-resource --target server --restype javax.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
+create-jms-resource --target server --restype jakarta.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
 
 create-jmsdest --target server --desttype queue jms_unit_result_Queue
-create-jms-resource --target server --restype javax.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
+create-jms-resource --target server --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/nondurableWithName/ejb/MySessionBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/nondurableWithName/ejb/MySessionBean.java
index 8c24abb..33442bc 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/nondurableWithName/ejb/MySessionBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/nondurableWithName/ejb/MySessionBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,7 +20,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/nondurableWithName/ejb/NewMessageBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/nondurableWithName/ejb/NewMessageBean.java
index 39e8731..bd5195d 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/nondurableWithName/ejb/NewMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/nondurableWithName/ejb/NewMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "clientId", propertyValue = "abc"),
     @ActivationConfigProperty(propertyName = "subscriptionName", propertyValue = "xyz"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "NonDurable")
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/nondurableWithoutName/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/nondurableWithoutName/client/Client.java
index 920f92a..0d3ba7b 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/nondurableWithoutName/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/nondurableWithoutName/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.activationproperties.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.activationproperties.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/nondurableWithoutName/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/nondurableWithoutName/create_resources.asadmin
index b58b7d2..925391b 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/nondurableWithoutName/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/nondurableWithoutName/create_resources.asadmin
@@ -1,9 +1,9 @@
-create-jms-resource --target server --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --target server --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 create-jmsdest --target server --desttype topic jms_unit_test_Topic
-create-jms-resource --target server --restype javax.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
+create-jms-resource --target server --restype jakarta.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
 
 create-jmsdest --target server --desttype queue jms_unit_result_Queue
-create-jms-resource --target server --restype javax.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
+create-jms-resource --target server --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/nondurableWithoutName/ejb/MySessionBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/nondurableWithoutName/ejb/MySessionBean.java
index c4e3bc0..5faabe8 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/nondurableWithoutName/ejb/MySessionBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/nondurableWithoutName/ejb/MySessionBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,7 +20,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/nondurableWithoutName/ejb/NewMessageBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/nondurableWithoutName/ejb/NewMessageBean.java
index ad02a2e..712a290 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/nondurableWithoutName/ejb/NewMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/embedded/noScope/nondurableWithoutName/ejb/NewMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "clientId", propertyValue = "abc"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "NonDurable")
 })
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/durableWithName/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/durableWithName/client/Client.java
index f7998cb..c1b19fc 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/durableWithName/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/durableWithName/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.activationproperties.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.activationproperties.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/durableWithName/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/durableWithName/create_resources.asadmin
index b58b7d2..925391b 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/durableWithName/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/durableWithName/create_resources.asadmin
@@ -1,9 +1,9 @@
-create-jms-resource --target server --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --target server --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 create-jmsdest --target server --desttype topic jms_unit_test_Topic
-create-jms-resource --target server --restype javax.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
+create-jms-resource --target server --restype jakarta.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
 
 create-jmsdest --target server --desttype queue jms_unit_result_Queue
-create-jms-resource --target server --restype javax.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
+create-jms-resource --target server --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/durableWithName/ejb/MySessionBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/durableWithName/ejb/MySessionBean.java
index 8c24abb..33442bc 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/durableWithName/ejb/MySessionBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/durableWithName/ejb/MySessionBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,7 +20,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/durableWithName/ejb/NewMessageBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/durableWithName/ejb/NewMessageBean.java
index 11ffa01..f616d4e 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/durableWithName/ejb/NewMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/durableWithName/ejb/NewMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "subscriptionScope", propertyValue = "Cluster"),
     @ActivationConfigProperty(propertyName = "subscriptionName", propertyValue = "xyz"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "Durable")
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/durableWithName/ejb/NewMessageBean2.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/durableWithName/ejb/NewMessageBean2.java
index 148c113..98e6ac5 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/durableWithName/ejb/NewMessageBean2.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/durableWithName/ejb/NewMessageBean2.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "subscriptionScope", propertyValue = "Cluster"),
     @ActivationConfigProperty(propertyName = "subscriptionName", propertyValue = "xyz"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "Durable")
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/durableWithoutName/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/durableWithoutName/client/Client.java
index 4e21593..5c9bf6a 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/durableWithoutName/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/durableWithoutName/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.activationproperties.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.activationproperties.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/durableWithoutName/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/durableWithoutName/create_resources.asadmin
index b58b7d2..925391b 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/durableWithoutName/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/durableWithoutName/create_resources.asadmin
@@ -1,9 +1,9 @@
-create-jms-resource --target server --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --target server --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 create-jmsdest --target server --desttype topic jms_unit_test_Topic
-create-jms-resource --target server --restype javax.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
+create-jms-resource --target server --restype jakarta.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
 
 create-jmsdest --target server --desttype queue jms_unit_result_Queue
-create-jms-resource --target server --restype javax.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
+create-jms-resource --target server --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/durableWithoutName/ejb/MySessionBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/durableWithoutName/ejb/MySessionBean.java
index 038c02b..41cbbc3 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/durableWithoutName/ejb/MySessionBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/durableWithoutName/ejb/MySessionBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,7 +20,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/durableWithoutName/ejb/NewMessageBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/durableWithoutName/ejb/NewMessageBean.java
index a9f0959..f22bee3 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/durableWithoutName/ejb/NewMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/durableWithoutName/ejb/NewMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "subscriptionScope", propertyValue = "Cluster"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "Durable")
 })
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/durableWithoutName/ejb/NewMessageBean2.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/durableWithoutName/ejb/NewMessageBean2.java
index 8244084..9d4b608 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/durableWithoutName/ejb/NewMessageBean2.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/durableWithoutName/ejb/NewMessageBean2.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "subscriptionScope", propertyValue = "Cluster"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "Durable")
 })
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/nondurableWithName/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/nondurableWithName/client/Client.java
index 515ada2..749a9dd 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/nondurableWithName/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/nondurableWithName/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.activationproperties.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.activationproperties.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/nondurableWithName/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/nondurableWithName/create_resources.asadmin
index b58b7d2..925391b 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/nondurableWithName/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/nondurableWithName/create_resources.asadmin
@@ -1,9 +1,9 @@
-create-jms-resource --target server --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --target server --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 create-jmsdest --target server --desttype topic jms_unit_test_Topic
-create-jms-resource --target server --restype javax.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
+create-jms-resource --target server --restype jakarta.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
 
 create-jmsdest --target server --desttype queue jms_unit_result_Queue
-create-jms-resource --target server --restype javax.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
+create-jms-resource --target server --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/nondurableWithName/ejb/MySessionBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/nondurableWithName/ejb/MySessionBean.java
index 8c24abb..33442bc 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/nondurableWithName/ejb/MySessionBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/nondurableWithName/ejb/MySessionBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,7 +20,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/nondurableWithName/ejb/NewMessageBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/nondurableWithName/ejb/NewMessageBean.java
index ef51a2d..7332da4 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/nondurableWithName/ejb/NewMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/nondurableWithName/ejb/NewMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "subscriptionScope", propertyValue = "Cluster"),
     @ActivationConfigProperty(propertyName = "subscriptionName", propertyValue = "xyz"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "NonDurable")
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/nondurableWithName/ejb/NewMessageBean2.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/nondurableWithName/ejb/NewMessageBean2.java
index ede68c9..8acbae9 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/nondurableWithName/ejb/NewMessageBean2.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/nondurableWithName/ejb/NewMessageBean2.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "subscriptionScope", propertyValue = "Cluster"),
     @ActivationConfigProperty(propertyName = "subscriptionName", propertyValue = "xyz"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "NonDurable")
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/nondurableWithoutName/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/nondurableWithoutName/client/Client.java
index c7b9390..def6af9 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/nondurableWithoutName/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/nondurableWithoutName/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.activationproperties.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.activationproperties.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/nondurableWithoutName/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/nondurableWithoutName/create_resources.asadmin
index b58b7d2..925391b 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/nondurableWithoutName/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/nondurableWithoutName/create_resources.asadmin
@@ -1,9 +1,9 @@
-create-jms-resource --target server --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --target server --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 create-jmsdest --target server --desttype topic jms_unit_test_Topic
-create-jms-resource --target server --restype javax.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
+create-jms-resource --target server --restype jakarta.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
 
 create-jmsdest --target server --desttype queue jms_unit_result_Queue
-create-jms-resource --target server --restype javax.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
+create-jms-resource --target server --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/nondurableWithoutName/ejb/MySessionBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/nondurableWithoutName/ejb/MySessionBean.java
index 038c02b..41cbbc3 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/nondurableWithoutName/ejb/MySessionBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/nondurableWithoutName/ejb/MySessionBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,7 +20,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/nondurableWithoutName/ejb/NewMessageBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/nondurableWithoutName/ejb/NewMessageBean.java
index a0c2070..e95e72d 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/nondurableWithoutName/ejb/NewMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/nondurableWithoutName/ejb/NewMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,12 +19,11 @@
 import java.util.logging.*;
 import javax.annotation.Resource;
 import javax.ejb.*;
-import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "subscriptionScope", propertyValue = "Cluster"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "NonDurable")
 })
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/nondurableWithoutName/ejb/NewMessageBean2.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/nondurableWithoutName/ejb/NewMessageBean2.java
index 1b676c4..7a8d37e 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/nondurableWithoutName/ejb/NewMessageBean2.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/ClusterScope/nondurableWithoutName/ejb/NewMessageBean2.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "subscriptionScope", propertyValue = "Cluster"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "NonDurable")
 })
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/durableWithName/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/durableWithName/client/Client.java
index a2df6d4..8fa28d5 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/durableWithName/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/durableWithName/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.activationproperties.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.activationproperties.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/durableWithName/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/durableWithName/create_resources.asadmin
index b58b7d2..925391b 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/durableWithName/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/durableWithName/create_resources.asadmin
@@ -1,9 +1,9 @@
-create-jms-resource --target server --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --target server --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 create-jmsdest --target server --desttype topic jms_unit_test_Topic
-create-jms-resource --target server --restype javax.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
+create-jms-resource --target server --restype jakarta.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
 
 create-jmsdest --target server --desttype queue jms_unit_result_Queue
-create-jms-resource --target server --restype javax.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
+create-jms-resource --target server --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/durableWithName/ejb/MySessionBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/durableWithName/ejb/MySessionBean.java
index 8c24abb..33442bc 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/durableWithName/ejb/MySessionBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/durableWithName/ejb/MySessionBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,7 +20,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/durableWithName/ejb/NewMessageBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/durableWithName/ejb/NewMessageBean.java
index e666ac3..e04f5c8 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/durableWithName/ejb/NewMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/durableWithName/ejb/NewMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "subscriptionScope", propertyValue = "Instance"),
     @ActivationConfigProperty(propertyName = "subscriptionName", propertyValue = "xyz"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "Durable")
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/durableWithName/ejb/NewMessageBean2.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/durableWithName/ejb/NewMessageBean2.java
index 9cd57a5..7d13081 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/durableWithName/ejb/NewMessageBean2.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/durableWithName/ejb/NewMessageBean2.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "subscriptionScope", propertyValue = "Instance"),
     @ActivationConfigProperty(propertyName = "subscriptionName", propertyValue = "xyz"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "Durable")
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/durableWithoutName/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/durableWithoutName/client/Client.java
index c40c762..7dbed2d 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/durableWithoutName/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/durableWithoutName/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.activationproperties.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.activationproperties.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/durableWithoutName/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/durableWithoutName/create_resources.asadmin
index b58b7d2..925391b 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/durableWithoutName/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/durableWithoutName/create_resources.asadmin
@@ -1,9 +1,9 @@
-create-jms-resource --target server --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --target server --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 create-jmsdest --target server --desttype topic jms_unit_test_Topic
-create-jms-resource --target server --restype javax.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
+create-jms-resource --target server --restype jakarta.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
 
 create-jmsdest --target server --desttype queue jms_unit_result_Queue
-create-jms-resource --target server --restype javax.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
+create-jms-resource --target server --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/durableWithoutName/ejb/MySessionBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/durableWithoutName/ejb/MySessionBean.java
index 038c02b..41cbbc3 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/durableWithoutName/ejb/MySessionBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/durableWithoutName/ejb/MySessionBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,7 +20,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/durableWithoutName/ejb/NewMessageBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/durableWithoutName/ejb/NewMessageBean.java
index 3940313..193a3e1 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/durableWithoutName/ejb/NewMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/durableWithoutName/ejb/NewMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "subscriptionScope", propertyValue = "Instance"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "Durable")
 })
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/durableWithoutName/ejb/NewMessageBean2.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/durableWithoutName/ejb/NewMessageBean2.java
index 094aac2..ca6a75a 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/durableWithoutName/ejb/NewMessageBean2.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/durableWithoutName/ejb/NewMessageBean2.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "subscriptionScope", propertyValue = "Instance"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "Durable")
 })
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/nondurableWithName/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/nondurableWithName/client/Client.java
index 12e727d..c213482 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/nondurableWithName/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/nondurableWithName/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.activationproperties.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.activationproperties.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/nondurableWithName/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/nondurableWithName/create_resources.asadmin
index b58b7d2..925391b 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/nondurableWithName/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/nondurableWithName/create_resources.asadmin
@@ -1,9 +1,9 @@
-create-jms-resource --target server --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --target server --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 create-jmsdest --target server --desttype topic jms_unit_test_Topic
-create-jms-resource --target server --restype javax.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
+create-jms-resource --target server --restype jakarta.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
 
 create-jmsdest --target server --desttype queue jms_unit_result_Queue
-create-jms-resource --target server --restype javax.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
+create-jms-resource --target server --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/nondurableWithName/ejb/MySessionBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/nondurableWithName/ejb/MySessionBean.java
index 8c24abb..33442bc 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/nondurableWithName/ejb/MySessionBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/nondurableWithName/ejb/MySessionBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,7 +20,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/nondurableWithName/ejb/NewMessageBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/nondurableWithName/ejb/NewMessageBean.java
index ffce3fd..4cd9a8f 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/nondurableWithName/ejb/NewMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/nondurableWithName/ejb/NewMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "subscriptionScope", propertyValue = "Instance"),
     @ActivationConfigProperty(propertyName = "subscriptionName", propertyValue = "xyz"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "NonDurable")
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/nondurableWithName/ejb/NewMessageBean2.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/nondurableWithName/ejb/NewMessageBean2.java
index 954c101..7791833 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/nondurableWithName/ejb/NewMessageBean2.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/nondurableWithName/ejb/NewMessageBean2.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "subscriptionScope", propertyValue = "Instance"),
     @ActivationConfigProperty(propertyName = "subscriptionName", propertyValue = "xyz"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "NonDurable")
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/nondurableWithoutName/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/nondurableWithoutName/client/Client.java
index 4b7e8a7..b376aad 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/nondurableWithoutName/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/nondurableWithoutName/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.activationproperties.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.activationproperties.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/nondurableWithoutName/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/nondurableWithoutName/create_resources.asadmin
index b58b7d2..925391b 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/nondurableWithoutName/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/nondurableWithoutName/create_resources.asadmin
@@ -1,9 +1,9 @@
-create-jms-resource --target server --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --target server --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 create-jmsdest --target server --desttype topic jms_unit_test_Topic
-create-jms-resource --target server --restype javax.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
+create-jms-resource --target server --restype jakarta.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
 
 create-jmsdest --target server --desttype queue jms_unit_result_Queue
-create-jms-resource --target server --restype javax.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
+create-jms-resource --target server --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/nondurableWithoutName/ejb/MySessionBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/nondurableWithoutName/ejb/MySessionBean.java
index 038c02b..41cbbc3 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/nondurableWithoutName/ejb/MySessionBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/nondurableWithoutName/ejb/MySessionBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,7 +20,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/nondurableWithoutName/ejb/NewMessageBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/nondurableWithoutName/ejb/NewMessageBean.java
index a0148bc..0b8907f 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/nondurableWithoutName/ejb/NewMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/nondurableWithoutName/ejb/NewMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "subscriptionScope", propertyValue = "Instance"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "NonDurable")
 })
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/nondurableWithoutName/ejb/NewMessageBean2.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/nondurableWithoutName/ejb/NewMessageBean2.java
index 431b879..a8917ac 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/nondurableWithoutName/ejb/NewMessageBean2.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/InstanceScope/nondurableWithoutName/ejb/NewMessageBean2.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "subscriptionScope", propertyValue = "Instance"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "NonDurable")
 })
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/durableNoClientIdWithName/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/durableNoClientIdWithName/client/Client.java
index 8c31ae1..17d9d3c 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/durableNoClientIdWithName/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/durableNoClientIdWithName/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.activationproperties.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.activationproperties.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/durableNoClientIdWithName/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/durableNoClientIdWithName/create_resources.asadmin
index b58b7d2..925391b 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/durableNoClientIdWithName/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/durableNoClientIdWithName/create_resources.asadmin
@@ -1,9 +1,9 @@
-create-jms-resource --target server --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --target server --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 create-jmsdest --target server --desttype topic jms_unit_test_Topic
-create-jms-resource --target server --restype javax.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
+create-jms-resource --target server --restype jakarta.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
 
 create-jmsdest --target server --desttype queue jms_unit_result_Queue
-create-jms-resource --target server --restype javax.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
+create-jms-resource --target server --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/durableNoClientIdWithName/ejb/MySessionBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/durableNoClientIdWithName/ejb/MySessionBean.java
index 8c24abb..33442bc 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/durableNoClientIdWithName/ejb/MySessionBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/durableNoClientIdWithName/ejb/MySessionBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,7 +20,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/durableNoClientIdWithName/ejb/NewMessageBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/durableNoClientIdWithName/ejb/NewMessageBean.java
index e991f18..e803ac2 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/durableNoClientIdWithName/ejb/NewMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/durableNoClientIdWithName/ejb/NewMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "subscriptionName", propertyValue = "xyz"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "Durable")
 })
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/durableWithName/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/durableWithName/client/Client.java
index 844add6..5ab4fb9 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/durableWithName/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/durableWithName/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.activationproperties.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.activationproperties.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/durableWithName/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/durableWithName/create_resources.asadmin
index b58b7d2..925391b 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/durableWithName/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/durableWithName/create_resources.asadmin
@@ -1,9 +1,9 @@
-create-jms-resource --target server --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --target server --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 create-jmsdest --target server --desttype topic jms_unit_test_Topic
-create-jms-resource --target server --restype javax.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
+create-jms-resource --target server --restype jakarta.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
 
 create-jmsdest --target server --desttype queue jms_unit_result_Queue
-create-jms-resource --target server --restype javax.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
+create-jms-resource --target server --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/durableWithName/ejb/MySessionBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/durableWithName/ejb/MySessionBean.java
index 8c24abb..33442bc 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/durableWithName/ejb/MySessionBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/durableWithName/ejb/MySessionBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,7 +20,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/durableWithName/ejb/NewMessageBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/durableWithName/ejb/NewMessageBean.java
index 62d14e4..bd8cfa9 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/durableWithName/ejb/NewMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/durableWithName/ejb/NewMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "subscriptionName", propertyValue = "xyz"),
     @ActivationConfigProperty(propertyName = "clientId", propertyValue = "abc"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "Durable")
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/nondurableWithName/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/nondurableWithName/client/Client.java
index aba616c..a9625e3 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/nondurableWithName/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/nondurableWithName/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.activationproperties.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.activationproperties.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/nondurableWithName/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/nondurableWithName/create_resources.asadmin
index b58b7d2..925391b 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/nondurableWithName/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/nondurableWithName/create_resources.asadmin
@@ -1,9 +1,9 @@
-create-jms-resource --target server --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --target server --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 create-jmsdest --target server --desttype topic jms_unit_test_Topic
-create-jms-resource --target server --restype javax.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
+create-jms-resource --target server --restype jakarta.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
 
 create-jmsdest --target server --desttype queue jms_unit_result_Queue
-create-jms-resource --target server --restype javax.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
+create-jms-resource --target server --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/nondurableWithName/ejb/MySessionBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/nondurableWithName/ejb/MySessionBean.java
index 8c24abb..33442bc 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/nondurableWithName/ejb/MySessionBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/nondurableWithName/ejb/MySessionBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,7 +20,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/nondurableWithName/ejb/NewMessageBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/nondurableWithName/ejb/NewMessageBean.java
index 39e8731..bd5195d 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/nondurableWithName/ejb/NewMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/nondurableWithName/ejb/NewMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "clientId", propertyValue = "abc"),
     @ActivationConfigProperty(propertyName = "subscriptionName", propertyValue = "xyz"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "NonDurable")
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/nondurableWithoutName/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/nondurableWithoutName/client/Client.java
index a47b8b3..97d5077 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/nondurableWithoutName/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/nondurableWithoutName/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.activationproperties.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.activationproperties.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/nondurableWithoutName/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/nondurableWithoutName/create_resources.asadmin
index b58b7d2..925391b 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/nondurableWithoutName/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/nondurableWithoutName/create_resources.asadmin
@@ -1,9 +1,9 @@
-create-jms-resource --target server --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --target server --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 create-jmsdest --target server --desttype topic jms_unit_test_Topic
-create-jms-resource --target server --restype javax.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
+create-jms-resource --target server --restype jakarta.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
 
 create-jmsdest --target server --desttype queue jms_unit_result_Queue
-create-jms-resource --target server --restype javax.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
+create-jms-resource --target server --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/nondurableWithoutName/ejb/MySessionBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/nondurableWithoutName/ejb/MySessionBean.java
index c4e3bc0..5faabe8 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/nondurableWithoutName/ejb/MySessionBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/nondurableWithoutName/ejb/MySessionBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,7 +20,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/nondurableWithoutName/ejb/NewMessageBean.java b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/nondurableWithoutName/ejb/NewMessageBean.java
index ad02a2e..712a290 100644
--- a/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/nondurableWithoutName/ejb/NewMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/activationProperties/subscriptionScope/standalone/local/noScope/nondurableWithoutName/ejb/NewMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "clientId", propertyValue = "abc"),
     @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "NonDurable")
 })
diff --git a/appserver/tests/appserv-tests/devtests/jms/annotation/MDB1/ejb/MyMessageBean.java b/appserver/tests/appserv-tests/devtests/jms/annotation/MDB1/ejb/MyMessageBean.java
index c8720aa..0078af5 100644
--- a/appserver/tests/appserv-tests/devtests/jms/annotation/MDB1/ejb/MyMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/annotation/MDB1/ejb/MyMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -23,23 +23,20 @@
 import javax.ejb.EJBException;
 import javax.ejb.MessageDriven;
 import javax.inject.Inject;
-import javax.jms.Connection;
-import javax.jms.ConnectionFactory;
-import javax.jms.JMSConnectionFactory;
-import javax.jms.JMSContext;
-import javax.jms.JMSException;
-import javax.jms.JMSProducer;
-import javax.jms.JMSSessionMode;
-import javax.jms.Message;
-import javax.jms.MessageListener;
-import javax.jms.MessageProducer;
-import javax.jms.Queue;
-import javax.jms.Session;
-import javax.jms.TextMessage;
+import jakarta.jms.ConnectionFactory;
+import jakarta.jms.JMSConnectionFactory;
+import jakarta.jms.JMSContext;
+import jakarta.jms.JMSException;
+import jakarta.jms.JMSProducer;
+import jakarta.jms.JMSSessionMode;
+import jakarta.jms.Message;
+import jakarta.jms.MessageListener;
+import jakarta.jms.Queue;
+import jakarta.jms.TextMessage;
 
 @MessageDriven(mappedName = "java:module/env/annotation_testQueue", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Queue"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Queue"),
     @ActivationConfigProperty(propertyName = "endpointExceptionRedeliveryAttempts", propertyValue = "1")
 })
 public class MyMessageBean implements MessageListener {
diff --git a/appserver/tests/appserv-tests/devtests/jms/annotation/MDB1/ejb/MySessionBean.java b/appserver/tests/appserv-tests/devtests/jms/annotation/MDB1/ejb/MySessionBean.java
index 1aac96a..f5f1fa3 100644
--- a/appserver/tests/appserv-tests/devtests/jms/annotation/MDB1/ejb/MySessionBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/annotation/MDB1/ejb/MySessionBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -21,26 +21,25 @@
 import javax.ejb.EJBException;
 import javax.ejb.Stateless;
 import javax.inject.Inject;
-import javax.jms.Connection;
-import javax.jms.ConnectionFactory;
-import javax.jms.JMSConnectionFactory;
-import javax.jms.JMSConnectionFactoryDefinition;
-import javax.jms.JMSContext;
-import javax.jms.JMSDestinationDefinition;
-import javax.jms.JMSDestinationDefinitions;
-import javax.jms.JMSProducer;
-import javax.jms.JMSSessionMode;
-import javax.jms.JMSException;
-import javax.jms.MessageConsumer;
-import javax.jms.MessageProducer;
-import javax.jms.Queue;
-import javax.jms.Session;
-import javax.jms.TextMessage;
+import jakarta.jms.Connection;
+import jakarta.jms.ConnectionFactory;
+import jakarta.jms.JMSConnectionFactory;
+import jakarta.jms.JMSConnectionFactoryDefinition;
+import jakarta.jms.JMSContext;
+import jakarta.jms.JMSDestinationDefinition;
+import jakarta.jms.JMSDestinationDefinitions;
+import jakarta.jms.JMSProducer;
+import jakarta.jms.JMSSessionMode;
+import jakarta.jms.JMSException;
+import jakarta.jms.MessageConsumer;
+import jakarta.jms.Queue;
+import jakarta.jms.Session;
+import jakarta.jms.TextMessage;
 
 @JMSConnectionFactoryDefinition(
     description = "module-scope CF defined by @JMSConnectionFactoryDefinition",
     name = "java:module/env/annotation_CF",
-    interfaceName = "javax.jms.ConnectionFactory",
+    interfaceName = "jakarta.jms.ConnectionFactory",
     resourceAdapter = "jmsra",
     user = "admin",
     password = "admin",
@@ -53,7 +52,7 @@
         @JMSDestinationDefinition(
             description = "module-scope test queue defined by @JMSDestinationDefinition",
             name = "java:module/env/annotation_testQueue",
-            interfaceName = "javax.jms.Queue",
+            interfaceName = "jakarta.jms.Queue",
             resourceAdapter = "jmsra",
             destinationName = "myPhysicalTestQueue"
         ),
@@ -61,7 +60,7 @@
         @JMSDestinationDefinition(
             description = "module-scope result queue defined by @JMSDestinationDefinition",
             name = "java:module/env/annotation_resultQueue",
-            interfaceName = "javax.jms.Queue",
+            interfaceName = "jakarta.jms.Queue",
             resourceAdapter = "jmsra",
             destinationName = "myPhysicalResultQueue"
         )
diff --git a/appserver/tests/appserv-tests/devtests/jms/annotation/MDB2/ejb/MyMessageBean.java b/appserver/tests/appserv-tests/devtests/jms/annotation/MDB2/ejb/MyMessageBean.java
index 4bf0368..d06012a 100644
--- a/appserver/tests/appserv-tests/devtests/jms/annotation/MDB2/ejb/MyMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/annotation/MDB2/ejb/MyMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -23,27 +23,27 @@
 import javax.ejb.EJBException;
 import javax.ejb.MessageDriven;
 import javax.inject.Inject;
-import javax.jms.Connection;
-import javax.jms.ConnectionFactory;
-import javax.jms.JMSConnectionFactory;
-import javax.jms.JMSConnectionFactoryDefinition;
-import javax.jms.JMSContext;
-import javax.jms.JMSDestinationDefinition;
-import javax.jms.JMSDestinationDefinitions;
-import javax.jms.JMSException;
-import javax.jms.JMSProducer;
-import javax.jms.JMSSessionMode;
-import javax.jms.Message;
-import javax.jms.MessageListener;
-import javax.jms.MessageProducer;
-import javax.jms.Queue;
-import javax.jms.Session;
-import javax.jms.TextMessage;
+import jakarta.jms.Connection;
+import jakarta.jms.ConnectionFactory;
+import jakarta.jms.JMSConnectionFactory;
+import jakarta.jms.JMSConnectionFactoryDefinition;
+import jakarta.jms.JMSContext;
+import jakarta.jms.JMSDestinationDefinition;
+import jakarta.jms.JMSDestinationDefinitions;
+import jakarta.jms.JMSException;
+import jakarta.jms.JMSProducer;
+import jakarta.jms.JMSSessionMode;
+import jakarta.jms.Message;
+import jakarta.jms.MessageListener;
+import jakarta.jms.MessageProducer;
+import jakarta.jms.Queue;
+import jakarta.jms.Session;
+import jakarta.jms.TextMessage;
 
 @JMSConnectionFactoryDefinition(
     description = "application-scope CF defined by @JMSConnectionFactoryDefinition",
     name = "java:app/env/annotation_CF",
-    interfaceName = "javax.jms.ConnectionFactory",
+    interfaceName = "jakarta.jms.ConnectionFactory",
     resourceAdapter = "jmsra",
     user = "admin",
     password = "admin",
@@ -56,7 +56,7 @@
         @JMSDestinationDefinition(
             description = "application-scope test queue defined by @JMSDestinationDefinition",
             name = "java:app/env/annotation_testQueue",
-            interfaceName = "javax.jms.Queue",
+            interfaceName = "jakarta.jms.Queue",
             resourceAdapter = "jmsra",
             destinationName = "myPhysicalTestQueue"
         ),
@@ -64,7 +64,7 @@
         @JMSDestinationDefinition(
             description = "application-scope result queue defined by @JMSDestinationDefinition",
             name = "java:app/env/annotation_resultQueue",
-            interfaceName = "javax.jms.Queue",
+            interfaceName = "jakarta.jms.Queue",
             resourceAdapter = "jmsra",
             destinationName = "myPhysicalResultQueue"
         )
@@ -73,7 +73,7 @@
 
 @MessageDriven(mappedName = "java:app/env/annotation_testQueue", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Queue"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Queue"),
     @ActivationConfigProperty(propertyName = "endpointExceptionRedeliveryAttempts", propertyValue = "1")
 })
 public class MyMessageBean implements MessageListener {
diff --git a/appserver/tests/appserv-tests/devtests/jms/annotation/MDB2/ejb/MySessionBean.java b/appserver/tests/appserv-tests/devtests/jms/annotation/MDB2/ejb/MySessionBean.java
index 21ae69c..5486bd0 100644
--- a/appserver/tests/appserv-tests/devtests/jms/annotation/MDB2/ejb/MySessionBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/annotation/MDB2/ejb/MySessionBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -21,18 +21,17 @@
 import javax.ejb.EJBException;
 import javax.ejb.Stateless;
 import javax.inject.Inject;
-import javax.jms.Connection;
-import javax.jms.ConnectionFactory;
-import javax.jms.JMSConnectionFactory;
-import javax.jms.JMSContext;
-import javax.jms.JMSProducer;
-import javax.jms.JMSSessionMode;
-import javax.jms.JMSException;
-import javax.jms.MessageConsumer;
-import javax.jms.MessageProducer;
-import javax.jms.Queue;
-import javax.jms.Session;
-import javax.jms.TextMessage;
+import jakarta.jms.Connection;
+import jakarta.jms.ConnectionFactory;
+import jakarta.jms.JMSConnectionFactory;
+import jakarta.jms.JMSContext;
+import jakarta.jms.JMSProducer;
+import jakarta.jms.JMSSessionMode;
+import jakarta.jms.JMSException;
+import jakarta.jms.MessageConsumer;
+import jakarta.jms.Queue;
+import jakarta.jms.Session;
+import jakarta.jms.TextMessage;
 
 @Stateless(mappedName="MySessionBean/remote")
 public class MySessionBean implements MySessionBeanRemote {
diff --git a/appserver/tests/appserv-tests/devtests/jms/annotation/MDB3/ejb/MyMessageBean.java b/appserver/tests/appserv-tests/devtests/jms/annotation/MDB3/ejb/MyMessageBean.java
index d04b23b..cc7a230 100644
--- a/appserver/tests/appserv-tests/devtests/jms/annotation/MDB3/ejb/MyMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/annotation/MDB3/ejb/MyMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -23,26 +23,23 @@
 import javax.ejb.EJBException;
 import javax.ejb.MessageDriven;
 import javax.inject.Inject;
-import javax.jms.Connection;
-import javax.jms.ConnectionFactory;
-import javax.jms.JMSConnectionFactory;
-import javax.jms.JMSConnectionFactoryDefinition;
-import javax.jms.JMSContext;
-import javax.jms.JMSDestinationDefinition;
-import javax.jms.JMSException;
-import javax.jms.JMSProducer;
-import javax.jms.JMSSessionMode;
-import javax.jms.Message;
-import javax.jms.MessageListener;
-import javax.jms.MessageProducer;
-import javax.jms.Queue;
-import javax.jms.Session;
-import javax.jms.TextMessage;
+import jakarta.jms.ConnectionFactory;
+import jakarta.jms.JMSConnectionFactory;
+import jakarta.jms.JMSConnectionFactoryDefinition;
+import jakarta.jms.JMSContext;
+import jakarta.jms.JMSDestinationDefinition;
+import jakarta.jms.JMSException;
+import jakarta.jms.JMSProducer;
+import jakarta.jms.JMSSessionMode;
+import jakarta.jms.Message;
+import jakarta.jms.MessageListener;
+import jakarta.jms.Queue;
+import jakarta.jms.TextMessage;
 
 @JMSConnectionFactoryDefinition(
     description = "global-scope CF defined by @JMSConnectionFactoryDefinition",
     name = "java:global/env/annotation_CF",
-    interfaceName = "javax.jms.ConnectionFactory",
+    interfaceName = "jakarta.jms.ConnectionFactory",
     resourceAdapter = "jmsra",
     user = "admin",
     password = "admin",
@@ -53,14 +50,14 @@
 @JMSDestinationDefinition(
     description = "global-scope test queue defined by @JMSDestinationDefinition",
     name = "java:global/env/annotation_testQueue",
-    interfaceName = "javax.jms.Queue",
+    interfaceName = "jakarta.jms.Queue",
     resourceAdapter = "jmsra",
     destinationName = "myPhysicalTestQueue"
 )
 
 @MessageDriven(mappedName = "java:global/env/annotation_testQueue", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Queue"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Queue"),
     @ActivationConfigProperty(propertyName = "endpointExceptionRedeliveryAttempts", propertyValue = "1")
 })
 public class MyMessageBean implements MessageListener {
diff --git a/appserver/tests/appserv-tests/devtests/jms/annotation/MDB3/ejb/MySessionBean.java b/appserver/tests/appserv-tests/devtests/jms/annotation/MDB3/ejb/MySessionBean.java
index 9d5b0e6..404a011 100644
--- a/appserver/tests/appserv-tests/devtests/jms/annotation/MDB3/ejb/MySessionBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/annotation/MDB3/ejb/MySessionBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -21,24 +21,24 @@
 import javax.ejb.EJBException;
 import javax.ejb.Stateless;
 import javax.inject.Inject;
-import javax.jms.Connection;
-import javax.jms.ConnectionFactory;
-import javax.jms.JMSConnectionFactory;
-import javax.jms.JMSContext;
-import javax.jms.JMSDestinationDefinition;
-import javax.jms.JMSProducer;
-import javax.jms.JMSSessionMode;
-import javax.jms.JMSException;
-import javax.jms.MessageConsumer;
-import javax.jms.MessageProducer;
-import javax.jms.Queue;
-import javax.jms.Session;
-import javax.jms.TextMessage;
+import jakarta.jms.Connection;
+import jakarta.jms.ConnectionFactory;
+import jakarta.jms.JMSConnectionFactory;
+import jakarta.jms.JMSContext;
+import jakarta.jms.JMSDestinationDefinition;
+import jakarta.jms.JMSProducer;
+import jakarta.jms.JMSSessionMode;
+import jakarta.jms.JMSException;
+import jakarta.jms.MessageConsumer;
+import jakarta.jms.MessageProducer;
+import jakarta.jms.Queue;
+import jakarta.jms.Session;
+import jakarta.jms.TextMessage;
 
 @JMSDestinationDefinition(
     description = "global-scope result queue defined by @JMSDestinationDefinition",
     name = "java:global/env/annotation_resultQueue",
-    interfaceName = "javax.jms.Queue",
+    interfaceName = "jakarta.jms.Queue",
     resourceAdapter = "jmsra",
     destinationName = "myPhysicalResultQueue"
 )
diff --git a/appserver/tests/appserv-tests/devtests/jms/annotation/sessionBean/ejb/MySessionBean.java b/appserver/tests/appserv-tests/devtests/jms/annotation/sessionBean/ejb/MySessionBean.java
index d50658d..77f4973 100644
--- a/appserver/tests/appserv-tests/devtests/jms/annotation/sessionBean/ejb/MySessionBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/annotation/sessionBean/ejb/MySessionBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,20 +19,20 @@
 import javax.annotation.Resource;
 import javax.ejb.EJBException;
 import javax.ejb.Stateless;
-import javax.jms.Connection;
-import javax.jms.ConnectionFactory;
-import javax.jms.JMSConnectionFactoryDefinition;
-import javax.jms.JMSConnectionFactoryDefinitions;
-import javax.jms.JMSDestinationDefinition;
-import javax.jms.JMSDestinationDefinitions;
-import javax.jms.JMSException;
-import javax.jms.Message;
-import javax.jms.MessageConsumer;
-import javax.jms.MessageProducer;
-import javax.jms.Queue;
-import javax.jms.Session;
-import javax.jms.TextMessage;
-import javax.jms.Topic;
+import jakarta.jms.Connection;
+import jakarta.jms.ConnectionFactory;
+import jakarta.jms.JMSConnectionFactoryDefinition;
+import jakarta.jms.JMSConnectionFactoryDefinitions;
+import jakarta.jms.JMSDestinationDefinition;
+import jakarta.jms.JMSDestinationDefinitions;
+import jakarta.jms.JMSException;
+import jakarta.jms.Message;
+import jakarta.jms.MessageConsumer;
+import jakarta.jms.MessageProducer;
+import jakarta.jms.Queue;
+import jakarta.jms.Session;
+import jakarta.jms.TextMessage;
+import jakarta.jms.Topic;
 import javax.naming.InitialContext;
 
 @JMSConnectionFactoryDefinitions(
@@ -40,7 +40,7 @@
         @JMSConnectionFactoryDefinition(
             description = "global-scope CF defined by @JMSConnectionFactoryDefinition",
             name = "java:global/env/annotation_CF",
-            interfaceName = "javax.jms.ConnectionFactory",
+            interfaceName = "jakarta.jms.ConnectionFactory",
             resourceAdapter = "jmsra",
             user = "admin",
             password = "admin",
@@ -51,7 +51,7 @@
         @JMSConnectionFactoryDefinition(
             description = "application-scope resource defined by @JMSConnectionFactoryDefinition",
             name = "java:app/env/annotation_CF",
-            interfaceName = "javax.jms.ConnectionFactory",
+            interfaceName = "jakarta.jms.ConnectionFactory",
             resourceAdapter = "jmsra",
             user = "admin",
             password = "admin",
@@ -62,7 +62,7 @@
         @JMSConnectionFactoryDefinition(
             description = "module-scope resource defined by @JMSConnectionFactoryDefinition",
             name = "java:module/env/annotation_CF",
-            interfaceName = "javax.jms.ConnectionFactory",
+            interfaceName = "jakarta.jms.ConnectionFactory",
             resourceAdapter = "jmsra",
             user = "admin",
             password = "admin",
@@ -73,7 +73,7 @@
         @JMSConnectionFactoryDefinition(
             description = "component-scope resource defined by @JMSConnectionFactoryDefinition",
             name = "java:comp/env/annotation_CF",
-            interfaceName = "javax.jms.ConnectionFactory",
+            interfaceName = "jakarta.jms.ConnectionFactory",
             resourceAdapter = "jmsra",
             user = "admin",
             password = "admin",
@@ -88,7 +88,7 @@
         @JMSDestinationDefinition(
             description = "global-scope queue defined by @JMSDestinationDefinition",
             name = "java:global/env/annotation_queue",
-            interfaceName = "javax.jms.Queue",
+            interfaceName = "jakarta.jms.Queue",
             resourceAdapter = "jmsra",
             destinationName = "myPhysicalQueue"
         ),
@@ -96,14 +96,14 @@
         @JMSDestinationDefinition(
             description = "application-scope topic defined by @JMSDestinationDefinition",
             name = "java:app/env/annotation_topic",
-            interfaceName = "javax.jms.Topic",
+            interfaceName = "jakarta.jms.Topic",
             resourceAdapter = "jmsra",
             destinationName = "myPhysicalTopic"
         ),
         @JMSDestinationDefinition(
             description = "module-scope topic defined by @JMSDestinationDefinition",
             name = "java:module/env/annotation_topic",
-            interfaceName = "javax.jms.Topic",
+            interfaceName = "jakarta.jms.Topic",
             resourceAdapter = "jmsra",
             destinationName = "myPhysicalTopic"
         ),
@@ -111,7 +111,7 @@
         @JMSDestinationDefinition(
             description = "component-scope queue defined by @JMSDestinationDefinition",
             name = "java:comp/env/annotation_queue",
-            interfaceName = "javax.jms.Queue",
+            interfaceName = "jakarta.jms.Queue",
             resourceAdapter = "jmsra",
             destinationName = "myPhysicalQueue"
         )
diff --git a/appserver/tests/appserv-tests/devtests/jms/defaultCF/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/defaultCF/client/Client.java
index 24cb30e..7191046 100644
--- a/appserver/tests/appserv-tests/devtests/jms/defaultCF/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/defaultCF/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.defaultcf.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.defaultcf.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/defaultCF/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/defaultCF/create_resources.asadmin
index 2b2261f..163ddb0 100644
--- a/appserver/tests/appserv-tests/devtests/jms/defaultCF/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/defaultCF/create_resources.asadmin
@@ -1,5 +1,5 @@
 create-jmsdest --desttype queue jms_unit_test_Queue
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
 
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/defaultCF/descriptor/ejb-jar.xml b/appserver/tests/appserv-tests/devtests/jms/defaultCF/descriptor/ejb-jar.xml
index 638c8a2..74b8358 100644
--- a/appserver/tests/appserv-tests/devtests/jms/defaultCF/descriptor/ejb-jar.xml
+++ b/appserver/tests/appserv-tests/devtests/jms/defaultCF/descriptor/ejb-jar.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -28,7 +28,7 @@
                 <ejb-name>SessionBeanDefault</ejb-name>
                 <resource-ref>
                     <res-ref-name>jms/systemDefaultCF</res-ref-name>
-                    <res-type>javax.jms.ConnectionFactory</res-type>
+                    <res-type>jakarta.jms.ConnectionFactory</res-type>
                 </resource-ref>
             </session>
         </enterprise-beans>
diff --git a/appserver/tests/appserv-tests/devtests/jms/defaultCF/ejb/SessionBeanDefault.java b/appserver/tests/appserv-tests/devtests/jms/defaultCF/ejb/SessionBeanDefault.java
index 355f5ef..403d2d8 100644
--- a/appserver/tests/appserv-tests/devtests/jms/defaultCF/ejb/SessionBeanDefault.java
+++ b/appserver/tests/appserv-tests/devtests/jms/defaultCF/ejb/SessionBeanDefault.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -18,7 +18,7 @@
 
 import javax.annotation.Resource;
 import javax.ejb.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.naming.InitialContext;
 
 /**
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/ejbInterceptorRequestScoped/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/ejbInterceptorRequestScoped/client/Client.java
index 6eb2dbd..1af92f0 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/ejbInterceptorRequestScoped/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/ejbInterceptorRequestScoped/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.injection.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.injection.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/ejbInterceptorRequestScoped/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/ejbInterceptorRequestScoped/create_resources.asadmin
index c554820..4c8401f 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/ejbInterceptorRequestScoped/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/ejbInterceptorRequestScoped/create_resources.asadmin
@@ -1,6 +1,6 @@
 create-jmsdest --desttype queue jms_unit_test_Queue
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
 
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/ejbInterceptorRequestScoped/ejb/InterceptorInjection.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/ejbInterceptorRequestScoped/ejb/InterceptorInjection.java
index f624292..1ffc7eb 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/ejbInterceptorRequestScoped/ejb/InterceptorInjection.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/ejbInterceptorRequestScoped/ejb/InterceptorInjection.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,7 +20,7 @@
 import javax.inject.Inject;
 import javax.interceptor.*;
 import javax.ejb.*;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/ejbInterceptorRequestScoped/ejb/MyInterceptor.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/ejbInterceptorRequestScoped/ejb/MyInterceptor.java
index 42e5844..9b0a934 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/ejbInterceptorRequestScoped/ejb/MyInterceptor.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/ejbInterceptorRequestScoped/ejb/MyInterceptor.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,7 +20,7 @@
 import javax.inject.Inject;
 import javax.interceptor.AroundInvoke;
 import javax.interceptor.InvocationContext;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.ejb.*;
 import javax.naming.*;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/ejbInterceptorTransactionScoped/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/ejbInterceptorTransactionScoped/client/Client.java
index 3d4bf6a..5201aae 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/ejbInterceptorTransactionScoped/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/ejbInterceptorTransactionScoped/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.injection.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.injection.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/ejbInterceptorTransactionScoped/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/ejbInterceptorTransactionScoped/create_resources.asadmin
index c554820..4c8401f 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/ejbInterceptorTransactionScoped/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/ejbInterceptorTransactionScoped/create_resources.asadmin
@@ -1,6 +1,6 @@
 create-jmsdest --desttype queue jms_unit_test_Queue
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
 
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/ejbInterceptorTransactionScoped/ejb/InterceptorInjection.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/ejbInterceptorTransactionScoped/ejb/InterceptorInjection.java
index c4dfa87..692e60d 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/ejbInterceptorTransactionScoped/ejb/InterceptorInjection.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/ejbInterceptorTransactionScoped/ejb/InterceptorInjection.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,7 +20,7 @@
 import javax.inject.Inject;
 import javax.interceptor.*;
 import javax.ejb.*;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/ejbInterceptorTransactionScoped/ejb/MyInterceptor.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/ejbInterceptorTransactionScoped/ejb/MyInterceptor.java
index 07fa037..f2d1bf5 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/ejbInterceptorTransactionScoped/ejb/MyInterceptor.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/ejbInterceptorTransactionScoped/ejb/MyInterceptor.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,11 +16,10 @@
 
 package org.glassfish.test.jms.injection.ejb;
 
-import javax.annotation.Resource;
 import javax.inject.Inject;
 import javax.interceptor.AroundInvoke;
 import javax.interceptor.InvocationContext;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.ejb.*;
 import javax.naming.*;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jsfRequestScoped/client/WebTest.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jsfRequestScoped/client/WebTest.java
index 9b89f0d..91d05a7 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jsfRequestScoped/client/WebTest.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jsfRequestScoped/client/WebTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 import java.io.*;
 import java.net.*;
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import com.sun.ejte.ccl.reporter.*;
 import org.glassfish.test.jms.injection.ejb.*;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jsfRequestScoped/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jsfRequestScoped/create_resources.asadmin
index 150afb7..fd8754a 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jsfRequestScoped/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jsfRequestScoped/create_resources.asadmin
@@ -1,4 +1,4 @@
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 create-jmsdest --desttype queue jms_unit_test_Queue
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jsfRequestScoped/ejb/MessageReceiverBean.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jsfRequestScoped/ejb/MessageReceiverBean.java
index 8773d8d..e1b7317 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jsfRequestScoped/ejb/MessageReceiverBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jsfRequestScoped/ejb/MessageReceiverBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,7 +19,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jsfRequestScoped/servlet/com/oracle/jms/test/NewJSFManagedBean.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jsfRequestScoped/servlet/com/oracle/jms/test/NewJSFManagedBean.java
index 35efa04..9c146dc 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jsfRequestScoped/servlet/com/oracle/jms/test/NewJSFManagedBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jsfRequestScoped/servlet/com/oracle/jms/test/NewJSFManagedBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -24,7 +24,7 @@
 import javax.faces.bean.ManagedBean;
 import javax.faces.bean.ViewScoped;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jsfTransactionScoped/client/WebTest.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jsfTransactionScoped/client/WebTest.java
index e5566c8..8d82e5d 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jsfTransactionScoped/client/WebTest.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jsfTransactionScoped/client/WebTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 import java.io.*;
 import java.net.*;
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import com.sun.ejte.ccl.reporter.*;
 import org.glassfish.test.jms.injection.ejb.*;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jsfTransactionScoped/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jsfTransactionScoped/create_resources.asadmin
index 150afb7..fd8754a 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jsfTransactionScoped/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jsfTransactionScoped/create_resources.asadmin
@@ -1,4 +1,4 @@
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 create-jmsdest --desttype queue jms_unit_test_Queue
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jsfTransactionScoped/ejb/MessageReceiverBean.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jsfTransactionScoped/ejb/MessageReceiverBean.java
index 8773d8d..e1b7317 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jsfTransactionScoped/ejb/MessageReceiverBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jsfTransactionScoped/ejb/MessageReceiverBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,7 +19,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jsfTransactionScoped/servlet/com/oracle/jms/test/NewJSFManagedBean.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jsfTransactionScoped/servlet/com/oracle/jms/test/NewJSFManagedBean.java
index ca0588f..53b841c 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jsfTransactionScoped/servlet/com/oracle/jms/test/NewJSFManagedBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jsfTransactionScoped/servlet/com/oracle/jms/test/NewJSFManagedBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -24,7 +24,7 @@
 import javax.faces.bean.ManagedBean;
 import javax.faces.bean.ViewScoped;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.ejb.*;
 import javax.transaction.UserTransaction;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jspRequestScoped/client/WebTest.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jspRequestScoped/client/WebTest.java
index 4574ff4..a636246 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jspRequestScoped/client/WebTest.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jspRequestScoped/client/WebTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 import java.io.*;
 import java.net.*;
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import com.sun.ejte.ccl.reporter.*;
 import org.glassfish.test.jms.injection.ejb.*;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jspRequestScoped/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jspRequestScoped/create_resources.asadmin
index 150afb7..fd8754a 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jspRequestScoped/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jspRequestScoped/create_resources.asadmin
@@ -1,4 +1,4 @@
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 create-jmsdest --desttype queue jms_unit_test_Queue
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jspRequestScoped/ejb/MessageReceiverBean.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jspRequestScoped/ejb/MessageReceiverBean.java
index 8773d8d..e1b7317 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jspRequestScoped/ejb/MessageReceiverBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jspRequestScoped/ejb/MessageReceiverBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,7 +19,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jspRequestScoped/servlet/test/JSPTagServletContextListener.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jspRequestScoped/servlet/test/JSPTagServletContextListener.java
index c906fd2..567a13b 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jspRequestScoped/servlet/test/JSPTagServletContextListener.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jspRequestScoped/servlet/test/JSPTagServletContextListener.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -18,7 +18,7 @@
 
 import javax.annotation.Resource;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.servlet.ServletContextEvent;
 import javax.servlet.ServletContextListener;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jspRequestScoped/servlet/test/JmsTagHandler.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jspRequestScoped/servlet/test/JmsTagHandler.java
index 9ac0ea0..c7a8f01 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jspRequestScoped/servlet/test/JmsTagHandler.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jspRequestScoped/servlet/test/JmsTagHandler.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -23,7 +23,7 @@
 import java.io.IOException;
 import javax.annotation.Resource;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.servlet.jsp.JspException;
 import javax.servlet.jsp.JspWriter;
 import javax.servlet.jsp.tagext.TagSupport;
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jspTransactionScoped/client/WebTest.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jspTransactionScoped/client/WebTest.java
index 9a73415..c8c3257 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jspTransactionScoped/client/WebTest.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jspTransactionScoped/client/WebTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 import java.io.*;
 import java.net.*;
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import com.sun.ejte.ccl.reporter.*;
 import org.glassfish.test.jms.injection.ejb.*;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jspTransactionScoped/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jspTransactionScoped/create_resources.asadmin
index 150afb7..fd8754a 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jspTransactionScoped/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jspTransactionScoped/create_resources.asadmin
@@ -1,4 +1,4 @@
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 create-jmsdest --desttype queue jms_unit_test_Queue
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jspTransactionScoped/ejb/MessageReceiverBean.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jspTransactionScoped/ejb/MessageReceiverBean.java
index 8773d8d..e1b7317 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jspTransactionScoped/ejb/MessageReceiverBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jspTransactionScoped/ejb/MessageReceiverBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,7 +19,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jspTransactionScoped/servlet/test/JSPTagServletContextListener.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jspTransactionScoped/servlet/test/JSPTagServletContextListener.java
index c906fd2..567a13b 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jspTransactionScoped/servlet/test/JSPTagServletContextListener.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jspTransactionScoped/servlet/test/JSPTagServletContextListener.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -18,7 +18,7 @@
 
 import javax.annotation.Resource;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.servlet.ServletContextEvent;
 import javax.servlet.ServletContextListener;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jspTransactionScoped/servlet/test/JmsTagHandler.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jspTransactionScoped/servlet/test/JmsTagHandler.java
index c0defaf..f44b858 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jspTransactionScoped/servlet/test/JmsTagHandler.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/jspTransactionScoped/servlet/test/JmsTagHandler.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,10 +20,9 @@
  */
 package test;
 
-import java.io.IOException;
 import javax.annotation.Resource;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.servlet.jsp.JspException;
 import javax.servlet.jsp.JspWriter;
 import javax.servlet.jsp.tagext.TagSupport;
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/servletRequestScoped/client/WebTest.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/servletRequestScoped/client/WebTest.java
index 554f59c..c848198 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/servletRequestScoped/client/WebTest.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/servletRequestScoped/client/WebTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 import java.io.*;
 import java.net.*;
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.injection.ejb.*;
 import com.sun.ejte.ccl.reporter.*;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/servletRequestScoped/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/servletRequestScoped/create_resources.asadmin
index 0841305..34cca97 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/servletRequestScoped/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/servletRequestScoped/create_resources.asadmin
@@ -1,7 +1,7 @@
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 create-jmsdest --desttype queue jms_unit_test_Queue
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
 
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/servletRequestScoped/ejb/MessageReceiverBean.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/servletRequestScoped/ejb/MessageReceiverBean.java
index beb96ab..9abe30e 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/servletRequestScoped/ejb/MessageReceiverBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/servletRequestScoped/ejb/MessageReceiverBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,7 +19,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/servletRequestScoped/servlet/myfilter/MyFilter.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/servletRequestScoped/servlet/myfilter/MyFilter.java
index ec5dd2c..f005db3 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/servletRequestScoped/servlet/myfilter/MyFilter.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/servletRequestScoped/servlet/myfilter/MyFilter.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,7 +19,7 @@
 import java.io.*;
 import javax.annotation.Resource;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.servlet.*;
 import javax.naming.*;
 import javax.annotation.*;
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/servletRequestScoped/servlet/test/TestServlet.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/servletRequestScoped/servlet/test/TestServlet.java
index e15199c..a97f96f 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/servletRequestScoped/servlet/test/TestServlet.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/servletRequestScoped/servlet/test/TestServlet.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,7 +19,7 @@
 import java.io.*;
 import javax.annotation.Resource;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.servlet.*;
 import javax.servlet.http.*;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/servletTransactionScoped/client/WebTest.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/servletTransactionScoped/client/WebTest.java
index 696171a..a376d50 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/servletTransactionScoped/client/WebTest.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/servletTransactionScoped/client/WebTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 import java.io.*;
 import java.net.*;
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.injection.ejb.*;
 import com.sun.ejte.ccl.reporter.*;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/servletTransactionScoped/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/servletTransactionScoped/create_resources.asadmin
index 0841305..34cca97 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/servletTransactionScoped/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/servletTransactionScoped/create_resources.asadmin
@@ -1,7 +1,7 @@
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 create-jmsdest --desttype queue jms_unit_test_Queue
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
 
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/servletTransactionScoped/ejb/MessageReceiverBean.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/servletTransactionScoped/ejb/MessageReceiverBean.java
index beb96ab..9abe30e 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/servletTransactionScoped/ejb/MessageReceiverBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/servletTransactionScoped/ejb/MessageReceiverBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,7 +19,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/servletTransactionScoped/servlet/myfilter/MyFilter.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/servletTransactionScoped/servlet/myfilter/MyFilter.java
index ec5dd2c..f005db3 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/servletTransactionScoped/servlet/myfilter/MyFilter.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/servletTransactionScoped/servlet/myfilter/MyFilter.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,7 +19,7 @@
 import java.io.*;
 import javax.annotation.Resource;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.servlet.*;
 import javax.naming.*;
 import javax.annotation.*;
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/servletTransactionScoped/servlet/test/TestServlet.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/servletTransactionScoped/servlet/test/TestServlet.java
index 876b4ac..40481f8 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/servletTransactionScoped/servlet/test/TestServlet.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/servletTransactionScoped/servlet/test/TestServlet.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,7 +19,7 @@
 import java.io.*;
 import javax.annotation.Resource;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.servlet.*;
 import javax.servlet.http.*;
 import javax.transaction.UserTransaction;
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/sessionBeanRequestScoped/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/sessionBeanRequestScoped/client/Client.java
index d79dd31..c321919 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/sessionBeanRequestScoped/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/sessionBeanRequestScoped/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.injection.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.injection.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/sessionBeanRequestScoped/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/sessionBeanRequestScoped/create_resources.asadmin
index 0841305..34cca97 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/sessionBeanRequestScoped/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/sessionBeanRequestScoped/create_resources.asadmin
@@ -1,7 +1,7 @@
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 create-jmsdest --desttype queue jms_unit_test_Queue
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
 
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/sessionBeanRequestScoped/ejb/SessionBeanInjection.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/sessionBeanRequestScoped/ejb/SessionBeanInjection.java
index 72491c3..ff54bc8 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/sessionBeanRequestScoped/ejb/SessionBeanInjection.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/sessionBeanRequestScoped/ejb/SessionBeanInjection.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,7 +19,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/sessionBeanTransactionScoped/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/sessionBeanTransactionScoped/client/Client.java
index 0c44838..9f94a7f 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/sessionBeanTransactionScoped/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/sessionBeanTransactionScoped/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.injection.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.injection.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/sessionBeanTransactionScoped/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/sessionBeanTransactionScoped/create_resources.asadmin
index 0841305..34cca97 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/sessionBeanTransactionScoped/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/sessionBeanTransactionScoped/create_resources.asadmin
@@ -1,7 +1,7 @@
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 create-jmsdest --desttype queue jms_unit_test_Queue
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
 
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/sessionBeanTransactionScoped/ejb/SessionBeanInjection.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/sessionBeanTransactionScoped/ejb/SessionBeanInjection.java
index 1af50a7..a4de661 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/sessionBeanTransactionScoped/ejb/SessionBeanInjection.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/sessionBeanTransactionScoped/ejb/SessionBeanInjection.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,7 +19,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/wsRequestScoped/client/WsTest.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/wsRequestScoped/client/WsTest.java
index c4604f4..e17fd66 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/wsRequestScoped/client/WsTest.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/wsRequestScoped/client/WsTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,7 +16,7 @@
 
 import java.io.*;
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import com.sun.ejte.ccl.reporter.*;
 import test.*;
 import org.glassfish.test.jms.injection.ejb.*;
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/wsRequestScoped/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/wsRequestScoped/create_resources.asadmin
index 150afb7..fd8754a 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/wsRequestScoped/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/wsRequestScoped/create_resources.asadmin
@@ -1,4 +1,4 @@
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 create-jmsdest --desttype queue jms_unit_test_Queue
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/wsRequestScoped/ejb/MessageReceiverBean.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/wsRequestScoped/ejb/MessageReceiverBean.java
index 8773d8d..e1b7317 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/wsRequestScoped/ejb/MessageReceiverBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/wsRequestScoped/ejb/MessageReceiverBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,7 +19,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/wsRequestScoped/servlet/test/NewWebService.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/wsRequestScoped/servlet/test/NewWebService.java
index e8b8207..13a753c 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/wsRequestScoped/servlet/test/NewWebService.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/wsRequestScoped/servlet/test/NewWebService.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -22,7 +22,7 @@
 
 import javax.annotation.Resource;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.jws.WebService;
 import javax.jws.WebMethod;
 import javax.jws.WebParam;
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/wsTransactionScoped/client/WsTest.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/wsTransactionScoped/client/WsTest.java
index f9b40bb..46b10a4 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/wsTransactionScoped/client/WsTest.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/wsTransactionScoped/client/WsTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,7 +16,7 @@
 
 import java.io.*;
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import com.sun.ejte.ccl.reporter.*;
 import test.*;
 import org.glassfish.test.jms.injection.ejb.*;
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/wsTransactionScoped/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/wsTransactionScoped/create_resources.asadmin
index 150afb7..fd8754a 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/wsTransactionScoped/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/wsTransactionScoped/create_resources.asadmin
@@ -1,4 +1,4 @@
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 create-jmsdest --desttype queue jms_unit_test_Queue
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/wsTransactionScoped/ejb/MessageReceiverBean.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/wsTransactionScoped/ejb/MessageReceiverBean.java
index 8773d8d..e1b7317 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/wsTransactionScoped/ejb/MessageReceiverBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/wsTransactionScoped/ejb/MessageReceiverBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,7 +19,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/wsTransactionScoped/servlet/test/NewWebService.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/wsTransactionScoped/servlet/test/NewWebService.java
index 33a6cd2..4133870 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/wsTransactionScoped/servlet/test/NewWebService.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/basic/wsTransactionScoped/servlet/test/NewWebService.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -22,7 +22,7 @@
 
 import javax.annotation.Resource;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.jws.WebService;
 import javax.jws.WebMethod;
 import javax.jws.WebParam;
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextDefaultInjection/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextDefaultInjection/client/Client.java
index 61908ad..604bb95 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextDefaultInjection/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextDefaultInjection/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.injection.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.injection.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextDefaultInjection/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextDefaultInjection/create_resources.asadmin
index ce78f64..9ec188a 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextDefaultInjection/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextDefaultInjection/create_resources.asadmin
@@ -1,8 +1,8 @@
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF2
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF2
 
 create-jmsdest --desttype queue jms_unit_test_Queue
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
 
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextDefaultInjection/ejb/SessionBeanInjection1.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextDefaultInjection/ejb/SessionBeanInjection1.java
index db7c265..91651b4 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextDefaultInjection/ejb/SessionBeanInjection1.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextDefaultInjection/ejb/SessionBeanInjection1.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,7 +19,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 import java.lang.String;
 import org.glassfish.test.jms.injection.ejb.SessionBeanInjection2;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextDefaultInjection/ejb/SessionBeanInjection2.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextDefaultInjection/ejb/SessionBeanInjection2.java
index 6359754..70688e8 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextDefaultInjection/ejb/SessionBeanInjection2.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextDefaultInjection/ejb/SessionBeanInjection2.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,7 +19,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionA/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionA/client/Client.java
index 87d2c4c..fed581a 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionA/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionA/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.injection.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.injection.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionA/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionA/create_resources.asadmin
index 0841305..34cca97 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionA/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionA/create_resources.asadmin
@@ -1,7 +1,7 @@
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 create-jmsdest --desttype queue jms_unit_test_Queue
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
 
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionA/ejb/SessionBeanInjection.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionA/ejb/SessionBeanInjection.java
index 9a0f5b0..25a5370 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionA/ejb/SessionBeanInjection.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionA/ejb/SessionBeanInjection.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,7 +19,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionB/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionB/client/Client.java
index 223c35d..3a57bdb 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionB/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionB/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.injection.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.injection.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionB/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionB/create_resources.asadmin
index 0841305..34cca97 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionB/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionB/create_resources.asadmin
@@ -1,7 +1,7 @@
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 create-jmsdest --desttype queue jms_unit_test_Queue
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
 
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionB/ejb/SessionBeanInjection1.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionB/ejb/SessionBeanInjection1.java
index ad680f2..0a1a77e 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionB/ejb/SessionBeanInjection1.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionB/ejb/SessionBeanInjection1.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,7 +19,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.injection.ejb.SessionBeanInjection2;
 
 /**
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionB/ejb/SessionBeanInjection2.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionB/ejb/SessionBeanInjection2.java
index 24077f0..34b1209 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionB/ejb/SessionBeanInjection2.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionB/ejb/SessionBeanInjection2.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,7 +19,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionC/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionC/client/Client.java
index b974301..1be4b3c 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionC/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionC/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.injection.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.injection.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionC/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionC/create_resources.asadmin
index 0841305..34cca97 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionC/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionC/create_resources.asadmin
@@ -1,7 +1,7 @@
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 create-jmsdest --desttype queue jms_unit_test_Queue
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
 
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionC/ejb/SessionBeanInjection1.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionC/ejb/SessionBeanInjection1.java
index 2ea509a..34e0716 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionC/ejb/SessionBeanInjection1.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionC/ejb/SessionBeanInjection1.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,7 +19,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 import java.lang.String;
 import org.glassfish.test.jms.injection.ejb.SessionBeanInjection2;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionC/ejb/SessionBeanInjection2.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionC/ejb/SessionBeanInjection2.java
index d099e33..a23960c 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionC/ejb/SessionBeanInjection2.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionC/ejb/SessionBeanInjection2.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,7 +19,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionD/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionD/client/Client.java
index 3689df0..079b89b 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionD/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionD/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.injection.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.injection.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionD/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionD/create_resources.asadmin
index 0841305..34cca97 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionD/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionD/create_resources.asadmin
@@ -1,7 +1,7 @@
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 create-jmsdest --desttype queue jms_unit_test_Queue
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
 
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionD/ejb/SessionBeanInjection.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionD/ejb/SessionBeanInjection.java
index aee264e..ae92c61 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionD/ejb/SessionBeanInjection.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionD/ejb/SessionBeanInjection.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,7 +19,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionE/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionE/client/Client.java
index 0cbf268..33d3e5c 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionE/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionE/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.injection.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.injection.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionE/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionE/create_resources.asadmin
index 0841305..34cca97 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionE/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionE/create_resources.asadmin
@@ -1,7 +1,7 @@
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 create-jmsdest --desttype queue jms_unit_test_Queue
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
 
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionE/ejb/SessionBeanInjection.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionE/ejb/SessionBeanInjection.java
index d66476a..c8bcd0e 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionE/ejb/SessionBeanInjection.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionE/ejb/SessionBeanInjection.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,8 +19,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
-import javax.transaction.UserTransaction;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionF/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionF/client/Client.java
index 234b946..d672436 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionF/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionF/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.injection.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.injection.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionF/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionF/create_resources.asadmin
index 0841305..34cca97 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionF/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionF/create_resources.asadmin
@@ -1,7 +1,7 @@
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 create-jmsdest --desttype queue jms_unit_test_Queue
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
 
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionF/ejb/SessionBeanInjection1.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionF/ejb/SessionBeanInjection1.java
index 8adc6e8..a88e539 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionF/ejb/SessionBeanInjection1.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionF/ejb/SessionBeanInjection1.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,9 +19,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
-import java.lang.String;
-import org.glassfish.test.jms.injection.ejb.SessionBeanInjection2;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionF/ejb/SessionBeanInjection2.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionF/ejb/SessionBeanInjection2.java
index e7392f5..599de7d 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionF/ejb/SessionBeanInjection2.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionF/ejb/SessionBeanInjection2.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,7 +19,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionG/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionG/client/Client.java
index a1e4595..e7ae910 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionG/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionG/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.injection.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.injection.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionG/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionG/create_resources.asadmin
index 0841305..34cca97 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionG/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionG/create_resources.asadmin
@@ -1,7 +1,7 @@
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 create-jmsdest --desttype queue jms_unit_test_Queue
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
 
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionG/ejb/SessionBeanInjection.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionG/ejb/SessionBeanInjection.java
index ce3f2c2..e3011ea 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionG/ejb/SessionBeanInjection.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionG/ejb/SessionBeanInjection.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,15 +19,8 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.transaction.UserTransaction;
-import javax.transaction.NotSupportedException;
-import javax.transaction.SystemException;
-import javax.transaction.RollbackException;
-import javax.transaction.HeuristicMixedException;
-import javax.transaction.HeuristicRollbackException;
-import java.lang.SecurityException;
-import java.lang.IllegalStateException;
 
 
 /**
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionH/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionH/client/Client.java
index eecdb24..cd78203 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionH/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionH/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.injection.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.injection.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionH/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionH/create_resources.asadmin
index 0841305..34cca97 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionH/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionH/create_resources.asadmin
@@ -1,7 +1,7 @@
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 create-jmsdest --desttype queue jms_unit_test_Queue
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
 
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionH/ejb/SessionBeanInjection.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionH/ejb/SessionBeanInjection.java
index 743276d..76f317f 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionH/ejb/SessionBeanInjection.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionH/ejb/SessionBeanInjection.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,16 +19,8 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.transaction.UserTransaction;
-import javax.transaction.NotSupportedException;
-import javax.transaction.SystemException;
-import javax.transaction.RollbackException;
-import javax.transaction.Status;
-import javax.transaction.HeuristicMixedException;
-import javax.transaction.HeuristicRollbackException;
-import java.lang.SecurityException;
-import java.lang.IllegalStateException;
 
 
 /**
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionJ/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionJ/client/Client.java
index ac26ba9..7aa97af 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionJ/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionJ/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.injection.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.injection.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionJ/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionJ/create_resources.asadmin
index 0841305..34cca97 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionJ/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionJ/create_resources.asadmin
@@ -1,7 +1,7 @@
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 create-jmsdest --desttype queue jms_unit_test_Queue
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
 
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionJ/ejb/SessionBeanInjection1.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionJ/ejb/SessionBeanInjection1.java
index c632fab..30c305c 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionJ/ejb/SessionBeanInjection1.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionJ/ejb/SessionBeanInjection1.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,7 +19,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.injection.ejb.SessionBeanInjection2;
 
 /**
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionJ/ejb/SessionBeanInjection2.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionJ/ejb/SessionBeanInjection2.java
index 48abb38..f03b298 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionJ/ejb/SessionBeanInjection2.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionJ/ejb/SessionBeanInjection2.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,7 +19,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionK/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionK/client/Client.java
index c52b3ea..0f8382a 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionK/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionK/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.injection.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.injection.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionK/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionK/create_resources.asadmin
index ce78f64..9ec188a 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionK/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionK/create_resources.asadmin
@@ -1,8 +1,8 @@
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF2
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF2
 
 create-jmsdest --desttype queue jms_unit_test_Queue
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_test_Queue jms/jms_unit_test_Queue
 
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionK/ejb/SessionBeanInjection1.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionK/ejb/SessionBeanInjection1.java
index 76ca7b1..910119a 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionK/ejb/SessionBeanInjection1.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionK/ejb/SessionBeanInjection1.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,8 +19,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
-import java.lang.String;
+import jakarta.jms.*;
 import org.glassfish.test.jms.injection.ejb.SessionBeanInjection2;
 
 /**
diff --git a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionK/ejb/SessionBeanInjection2.java b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionK/ejb/SessionBeanInjection2.java
index 4314ea1..cec0440 100644
--- a/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionK/ejb/SessionBeanInjection2.java
+++ b/appserver/tests/appserv-tests/devtests/jms/injection/jmsContext/mixedScoped/jmsContextInjectionK/ejb/SessionBeanInjection2.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,7 +19,7 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/mdbDest/client/Client.java b/appserver/tests/appserv-tests/devtests/jms/mdbDest/client/Client.java
index 15c87c7..ddcde92 100644
--- a/appserver/tests/appserv-tests/devtests/jms/mdbDest/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/jms/mdbDest/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package org.glassfish.test.jms.mdbdest.client;
 
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import org.glassfish.test.jms.mdbdest.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/appserv-tests/devtests/jms/mdbDest/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/mdbDest/create_resources.asadmin
index e075af9..08b6a4c 100644
--- a/appserver/tests/appserv-tests/devtests/jms/mdbDest/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/mdbDest/create_resources.asadmin
@@ -1,9 +1,9 @@
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/jms_unit_test_QCF
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/jms_unit_test_QCF
 
 create-jmsdest --desttype topic jms_unit_test_Topic
-create-jms-resource --restype javax.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
+create-jms-resource --restype jakarta.jms.Topic --property imqDestinationName=jms_unit_test_Topic jms/jms_unit_test_Topic
 
 create-jmsdest --desttype queue jms_unit_result_Queue
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=jms_unit_result_Queue jms/jms_unit_result_Queue
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/jms/mdbDest/ejb/MySessionBean.java b/appserver/tests/appserv-tests/devtests/jms/mdbDest/ejb/MySessionBean.java
index f8200ba..d66ba20 100644
--- a/appserver/tests/appserv-tests/devtests/jms/mdbDest/ejb/MySessionBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/mdbDest/ejb/MySessionBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,11 +16,10 @@
 
 package org.glassfish.test.jms.mdbdest.ejb;
 
-import java.util.logging.Logger;
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/jms/mdbDest/ejb/NewMessageBean.java b/appserver/tests/appserv-tests/devtests/jms/mdbDest/ejb/NewMessageBean.java
index 2081e41..2c4773b 100644
--- a/appserver/tests/appserv-tests/devtests/jms/mdbDest/ejb/NewMessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/mdbDest/ejb/NewMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(name = "test0", mappedName = "jms/jms_unit_test_Topic", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "connectionFactoryLookup", propertyValue = "java:comp/DefaultJMSConnectionFactory")
 })
 public class NewMessageBean implements MessageListener {
diff --git a/appserver/tests/appserv-tests/devtests/jms/mdbDest/ejb/NewMessageBean1.java b/appserver/tests/appserv-tests/devtests/jms/mdbDest/ejb/NewMessageBean1.java
index 0522515..4ce70ff 100644
--- a/appserver/tests/appserv-tests/devtests/jms/mdbDest/ejb/NewMessageBean1.java
+++ b/appserver/tests/appserv-tests/devtests/jms/mdbDest/ejb/NewMessageBean1.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(name = "test1", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "destinationLookup", propertyValue = "jms/jms_unit_test_Topic")
 })
 public class NewMessageBean1 implements MessageListener {
diff --git a/appserver/tests/appserv-tests/devtests/jms/mdbDest/ejb/NewMessageBean2.java b/appserver/tests/appserv-tests/devtests/jms/mdbDest/ejb/NewMessageBean2.java
index ed59be6..f4b8941 100644
--- a/appserver/tests/appserv-tests/devtests/jms/mdbDest/ejb/NewMessageBean2.java
+++ b/appserver/tests/appserv-tests/devtests/jms/mdbDest/ejb/NewMessageBean2.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(name = "test2", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "destination", propertyValue = "jms_unit_test_Topic")
 })
 public class NewMessageBean2 implements MessageListener {
diff --git a/appserver/tests/appserv-tests/devtests/jms/mdbDest/ejb/NewMessageBean3.java b/appserver/tests/appserv-tests/devtests/jms/mdbDest/ejb/NewMessageBean3.java
index 42917a0..cd17cf6 100644
--- a/appserver/tests/appserv-tests/devtests/jms/mdbDest/ejb/NewMessageBean3.java
+++ b/appserver/tests/appserv-tests/devtests/jms/mdbDest/ejb/NewMessageBean3.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(name = "test3", mappedName="wrongname", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "destination", propertyValue = "jms_unit_test_Topic")
 })
 public class NewMessageBean3 implements MessageListener {
diff --git a/appserver/tests/appserv-tests/devtests/jms/mdbDest/ejb/NewMessageBean4.java b/appserver/tests/appserv-tests/devtests/jms/mdbDest/ejb/NewMessageBean4.java
index f71a704..2d33228 100644
--- a/appserver/tests/appserv-tests/devtests/jms/mdbDest/ejb/NewMessageBean4.java
+++ b/appserver/tests/appserv-tests/devtests/jms/mdbDest/ejb/NewMessageBean4.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(name = "test4", mappedName="wrongname", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "destinationLookup", propertyValue = "jms/jms_unit_test_Topic")
 })
 public class NewMessageBean4 implements MessageListener {
diff --git a/appserver/tests/appserv-tests/devtests/jms/mdbDest/ejb/NewMessageBean5.java b/appserver/tests/appserv-tests/devtests/jms/mdbDest/ejb/NewMessageBean5.java
index e0987f9..f44d921 100644
--- a/appserver/tests/appserv-tests/devtests/jms/mdbDest/ejb/NewMessageBean5.java
+++ b/appserver/tests/appserv-tests/devtests/jms/mdbDest/ejb/NewMessageBean5.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,11 +20,11 @@
 import javax.annotation.Resource;
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 @MessageDriven(name = "test5", activationConfig = {
     @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
+    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Topic"),
     @ActivationConfigProperty(propertyName = "destinationLookup", propertyValue = "jms/jms_unit_test_Topic"),
     @ActivationConfigProperty(propertyName = "destination", propertyValue = "wrongname")
 })
diff --git a/appserver/tests/appserv-tests/devtests/jms/msgdest/jmsweb/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/msgdest/jmsweb/create_resources.asadmin
index 7cd182d..0d9654b 100644
--- a/appserver/tests/appserv-tests/devtests/jms/msgdest/jmsweb/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/msgdest/jmsweb/create_resources.asadmin
Binary files differ
diff --git a/appserver/tests/appserv-tests/devtests/jms/msgdest/jmsweb/delete_resources.asadmin b/appserver/tests/appserv-tests/devtests/jms/msgdest/jmsweb/delete_resources.asadmin
index 95727cd..d67a842 100644
--- a/appserver/tests/appserv-tests/devtests/jms/msgdest/jmsweb/delete_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/jms/msgdest/jmsweb/delete_resources.asadmin
@@ -1,7 +1,7 @@
 delete-jms-resource jms/jms_msgdest_jmsweb_QCF
 delete-jms-resource jms/jms_msgdest_jmsweb_ServletQueue
-delete-jmsdest --desttype javax.jms.Queue jms_msgdest_jmsweb_ServletQueue
+delete-jmsdest --desttype jakarta.jms.Queue jms_msgdest_jmsweb_ServletQueue
 delete-jms-resource jms/jms_msgdest_jmsweb_mdbQueue 
-delete-jmsdest --desttype javax.jms.Queue jms_msgdest_jmsweb_mdbQueue 
+delete-jmsdest --desttype jakarta.jms.Queue jms_msgdest_jmsweb_mdbQueue 
 delete-jms-resource jms/jms_msgdest_jmsweb_AppclientQueue 
-delete-jmsdest --desttype javax.jms.Queue jms_msgdest_jmsweb_AppclientQueue 
+delete-jmsdest --desttype jakarta.jms.Queue jms_msgdest_jmsweb_AppclientQueue 
diff --git a/appserver/tests/appserv-tests/devtests/jms/msgdest/jmsweb/descriptor/application-client.xml b/appserver/tests/appserv-tests/devtests/jms/msgdest/jmsweb/descriptor/application-client.xml
index 3d5fb37..f99abfc 100644
--- a/appserver/tests/appserv-tests/devtests/jms/msgdest/jmsweb/descriptor/application-client.xml
+++ b/appserver/tests/appserv-tests/devtests/jms/msgdest/jmsweb/descriptor/application-client.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -23,7 +23,7 @@
      <description>non-qualified .war-defined destination</description>
      <message-destination-ref-name>jms/MyQueue
      </message-destination-ref-name>
-     <message-destination-type>javax.jms.Queue</message-destination-type>
+     <message-destination-type>jakarta.jms.Queue</message-destination-type>
      <message-destination-usage>Produces</message-destination-usage>
      <message-destination-link>WebQueue</message-destination-link>
    </message-destination-ref>
@@ -31,7 +31,7 @@
      <description>explicitly referenced .war-defined destination</description>
      <message-destination-ref-name>jms/MyQueue2
      </message-destination-ref-name>
-     <message-destination-type>javax.jms.Queue</message-destination-type>
+     <message-destination-type>jakarta.jms.Queue</message-destination-type>
      <message-destination-usage>Produces</message-destination-usage>
      <message-destination-link>a/b/jms-msgdest-jmsweb-web.war#WebQueue</message-destination-link>
   </message-destination-ref>
diff --git a/appserver/tests/appserv-tests/devtests/jms/msgdest/jmsweb/descriptor/ejb-jar.xml b/appserver/tests/appserv-tests/devtests/jms/msgdest/jmsweb/descriptor/ejb-jar.xml
index 25bad7c..6b4b1e7 100644
--- a/appserver/tests/appserv-tests/devtests/jms/msgdest/jmsweb/descriptor/ejb-jar.xml
+++ b/appserver/tests/appserv-tests/devtests/jms/msgdest/jmsweb/descriptor/ejb-jar.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -24,9 +24,9 @@
       <display-name>MDB1</display-name>
       <ejb-name>MDB1</ejb-name>
       <ejb-class>com.sun.s1asdev.jms.msgdest.jmsweb.MessageBean</ejb-class>
-      <messaging-type>javax.jms.MessageListener</messaging-type>
+      <messaging-type>jakarta.jms.MessageListener</messaging-type>
       <transaction-type>Container</transaction-type>
-      <message-destination-type>javax.jms.Queue</message-destination-type>
+      <message-destination-type>jakarta.jms.Queue</message-destination-type>
     </message-driven>
   </enterprise-beans>
   <assembly-descriptor>
@@ -35,7 +35,7 @@
         <ejb-name>MDB1</ejb-name>
         <method-name>onMessage</method-name>
         <method-params>
-          <method-param>javax.jms.Message</method-param>
+          <method-param>jakarta.jms.Message</method-param>
         </method-params>
       </method>
       <trans-attribute>Required</trans-attribute>
diff --git a/appserver/tests/appserv-tests/devtests/jms/msgdest/jmsweb/descriptor/web.xml b/appserver/tests/appserv-tests/devtests/jms/msgdest/jmsweb/descriptor/web.xml
index 73b91ff..ac85d77 100644
--- a/appserver/tests/appserv-tests/devtests/jms/msgdest/jmsweb/descriptor/web.xml
+++ b/appserver/tests/appserv-tests/devtests/jms/msgdest/jmsweb/descriptor/web.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2018, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -33,7 +33,7 @@
   <resource-ref>
      <description>description</description>
      <res-ref-name>jms/MyQueueConnectionFactory</res-ref-name>
-     <res-type>javax.jms.QueueConnectionFactory</res-type>
+     <res-type>jakarta.jms.QueueConnectionFactory</res-type>
      <res-auth>Container</res-auth>
      <res-sharing-scope>Shareable</res-sharing-scope> 
   </resource-ref>
@@ -41,7 +41,7 @@
      <description>intra-war destination</description>
      <message-destination-ref-name>jms/MyQueue
      </message-destination-ref-name>
-     <message-destination-type>javax.jms.Queue</message-destination-type>
+     <message-destination-type>jakarta.jms.Queue</message-destination-type>
      <message-destination-usage>ConsumesProduces</message-destination-usage>
      <message-destination-link>WebQueue</message-destination-link>
   </message-destination-ref>
@@ -49,7 +49,7 @@
      <description>non-qualified appclient destination</description>
      <message-destination-ref-name>jms/MyQueue2
      </message-destination-ref-name>
-     <message-destination-type>javax.jms.Queue</message-destination-type>
+     <message-destination-type>jakarta.jms.Queue</message-destination-type>
      <message-destination-usage>Consumes</message-destination-usage>
      <message-destination-link>AppclientQueue</message-destination-link>
    </message-destination-ref>
@@ -57,7 +57,7 @@
      <description>explicitly referenced appclient destination</description>
      <message-destination-ref-name>jms/MyQueue3
      </message-destination-ref-name>
-     <message-destination-type>javax.jms.Queue</message-destination-type>
+     <message-destination-type>jakarta.jms.Queue</message-destination-type>
      <message-destination-usage>Consumes</message-destination-usage>
      <message-destination-link>../../jms-msgdest-jmsweb-client.jar#AppclientQueue</message-destination-link>
    </message-destination-ref>
diff --git a/appserver/tests/appserv-tests/devtests/jms/msgdest/jmsweb/ejb/MessageBean.java b/appserver/tests/appserv-tests/devtests/jms/msgdest/jmsweb/ejb/MessageBean.java
index 9de9f57..25b74b9 100644
--- a/appserver/tests/appserv-tests/devtests/jms/msgdest/jmsweb/ejb/MessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/jms/msgdest/jmsweb/ejb/MessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,7 @@
 package com.sun.s1asdev.jms.msgdest.jmsweb;
 
 import java.rmi.RemoteException;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.ejb.*;
 import java.io.Serializable;
 import javax.naming.*;
diff --git a/appserver/tests/appserv-tests/devtests/jms/msgdest/jmsweb/servlet/JmsServlet.java b/appserver/tests/appserv-tests/devtests/jms/msgdest/jmsweb/servlet/JmsServlet.java
index 42f9a2e..3be067d 100644
--- a/appserver/tests/appserv-tests/devtests/jms/msgdest/jmsweb/servlet/JmsServlet.java
+++ b/appserver/tests/appserv-tests/devtests/jms/msgdest/jmsweb/servlet/JmsServlet.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2002, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2002, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -23,7 +23,7 @@
 import javax.naming.*;
 import java.sql.*;
 import javax.sql.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.transaction.*;
 
 public class JmsServlet extends HttpServlet {
diff --git a/appserver/tests/appserv-tests/devtests/naming/loadbalancing/cluster-setup b/appserver/tests/appserv-tests/devtests/naming/loadbalancing/cluster-setup
index 8e2c10e..f4f2900 100644
--- a/appserver/tests/appserv-tests/devtests/naming/loadbalancing/cluster-setup
+++ b/appserver/tests/appserv-tests/devtests/naming/loadbalancing/cluster-setup
@@ -83,8 +83,8 @@
 #./asadmin set --user admin --password adminadmin --host localhost --port 4849 domain.resources.jdbc-connection-pool.bmpEnrollerPool.property.User=pbPublic
 #./asadmin set --user admin --password adminadmin --host localhost --port 4849 domain.resources.jdbc-connection-pool.bmpEnrollerPool.property.Password=pbPublic
 
-#./asadmin create-jms-resource --restype javax.jms.QueueConnectionFactory --user admin --password adminadmin --target C1 jms/QCFactory
+#./asadmin create-jms-resource --restype jakarta.jms.QueueConnectionFactory --user admin --password adminadmin --target C1 jms/QCFactory
 
 #./asadmin create-jmsdest --desttype queue --user admin --password adminadmin --target C1 Queue
 
-#./asadmin create-jms-resource --restype javax.jms.Queue --property imqDestinationName=Queue --target C1 --user admin --password adminadmin jms/SampleQueue
+#./asadmin create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=Queue --target C1 --user admin --password adminadmin jms/SampleQueue
diff --git a/appserver/tests/appserv-tests/devtests/naming/lookup/enroller/client/EnrollerClient.java b/appserver/tests/appserv-tests/devtests/naming/lookup/enroller/client/EnrollerClient.java
index abc2b6a..d0c7229 100755
--- a/appserver/tests/appserv-tests/devtests/naming/lookup/enroller/client/EnrollerClient.java
+++ b/appserver/tests/appserv-tests/devtests/naming/lookup/enroller/client/EnrollerClient.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2001, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,11 +19,10 @@
 import javax.naming.Context;
 import javax.naming.InitialContext;
 import javax.rmi.PortableRemoteObject;
-import javax.jms.*;
+import jakarta.jms.*;
 import java.util.*;
 import com.sun.s1peqe.ejb.bmp.enroller.ejb.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
-import com.sun.enterprise.naming.impl.SerialContext;
 import org.glassfish.internal.api.Globals;
 import org.glassfish.internal.api.ORBLocator;
 
@@ -140,12 +139,12 @@
 	    System.out.println("Looking up JMS Resource Refs ==>");
 	    System.out.println("Creating new Context 2..");
 	    Context initial1 = new InitialContext();            	    
-	    javax.jms.Queue queue = (javax.jms.Queue) initial1.lookup(queueString);
+	    jakarta.jms.Queue queue = (jakarta.jms.Queue) initial1.lookup(queueString);
 	    System.out.println("looked up " + queueString);
 
 	    System.out.println("Creating new Context 3...");
 	    Context initial2 = new InitialContext();
-	    javax.jms.QueueConnectionFactory queueConnectionFactory = 
+	    jakarta.jms.QueueConnectionFactory queueConnectionFactory = 
 	      (QueueConnectionFactory)
 	      initial2.lookup("jms/QCFactory");
 	    System.out.println("Looked up jms/QCFactory");
diff --git a/appserver/tests/appserv-tests/devtests/naming/lookup/enroller/descriptor/application-client.xml b/appserver/tests/appserv-tests/devtests/naming/lookup/enroller/descriptor/application-client.xml
index 52cfcdf..c005b11 100755
--- a/appserver/tests/appserv-tests/devtests/naming/lookup/enroller/descriptor/application-client.xml
+++ b/appserver/tests/appserv-tests/devtests/naming/lookup/enroller/descriptor/application-client.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -39,12 +39,12 @@
   </ejb-ref>
   <resource-ref>
     <res-ref-name>jms/QCFactory</res-ref-name>
-    <res-type>javax.jms.QueueConnectionFactory</res-type>
+    <res-type>jakarta.jms.QueueConnectionFactory</res-type>
     <res-auth>Container</res-auth>
     <res-sharing-scope>Shareable</res-sharing-scope>
   </resource-ref>
   <resource-env-ref>
     <resource-env-ref-name>jms/SampleQueue</resource-env-ref-name>
-    <resource-env-ref-type>javax.jms.Queue</resource-env-ref-type>
+    <resource-env-ref-type>jakarta.jms.Queue</resource-env-ref-type>
   </resource-env-ref>
 </application-client>
diff --git a/appserver/tests/appserv-tests/devtests/naming/nonfailover/client/Client.java b/appserver/tests/appserv-tests/devtests/naming/nonfailover/client/Client.java
index 9066965..6cfa591 100644
--- a/appserver/tests/appserv-tests/devtests/naming/nonfailover/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/naming/nonfailover/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,7 +16,7 @@
 
 package com.sun.s1aspe.naming.nonfailover.client;
 
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.naming.*;
 import java.sql.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
diff --git a/appserver/tests/appserv-tests/devtests/naming/nonfailover/descriptor/application-client.xml b/appserver/tests/appserv-tests/devtests/naming/nonfailover/descriptor/application-client.xml
index 5b669c9..c41fa7e 100644
--- a/appserver/tests/appserv-tests/devtests/naming/nonfailover/descriptor/application-client.xml
+++ b/appserver/tests/appserv-tests/devtests/naming/nonfailover/descriptor/application-client.xml
@@ -2,7 +2,7 @@
 <!DOCTYPE application-client PUBLIC '-//Sun Microsystems, Inc.//DTD J2EE Application Client 1.3//EN' 'http://java.sun.com/dtd/application-client_1_3.dtd'>
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -22,13 +22,13 @@
   <display-name>nonfailoverClient</display-name>
   <resource-ref>
     <res-ref-name>jms/QCFactory</res-ref-name>
-    <res-type>javax.jms.QueueConnectionFactory</res-type>
+    <res-type>jakarta.jms.QueueConnectionFactory</res-type>
     <res-auth>Container</res-auth>
     <res-sharing-scope>Shareable</res-sharing-scope>
   </resource-ref>
   <resource-env-ref>
     <resource-env-ref-name>jms/SampleQueue</resource-env-ref-name>
-    <resource-env-ref-type>javax.jms.Queue</resource-env-ref-type>
+    <resource-env-ref-type>jakarta.jms.Queue</resource-env-ref-type>
   </resource-env-ref>
 </application-client>
 
diff --git a/appserver/tests/appserv-tests/devtests/security/container-auth/testConfig/domain.xml b/appserver/tests/appserv-tests/devtests/security/container-auth/testConfig/domain.xml
index e10ccb4..5c6f0df 100644
--- a/appserver/tests/appserv-tests/devtests/security/container-auth/testConfig/domain.xml
+++ b/appserver/tests/appserv-tests/devtests/security/container-auth/testConfig/domain.xml
@@ -2,7 +2,7 @@
 <!DOCTYPE domain PUBLIC "-//Sun Microsystems Inc.//DTD Application Server 8.0 Domain//EN" "http://www.sun.com/software/appserver/dtds/sun-domain_1_1.dtd">
 <!--
 
-    Copyright (c) 2004, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2004, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -42,13 +42,13 @@
     <jdbc-resource enabled="true" jndi-name="jdbc/s1qeDB" object-type="user" pool-name="jdbc-pointbase-pool"/>
     <jdbc-resource enabled="true" jndi-name="jdbc/ejb-subclassing" object-type="user" pool-name="ejb-subclassing-pool"/>
     <persistence-manager-factory-resource enabled="true" factory-class="com.sun.jdo.spi.persistence.support.sqlstore.impl.PersistenceManagerFactoryImpl" jdbc-resource-jndi-name="jdbc/s1qeDB" jndi-name="jdo/s1qePM" object-type="user"/>
-    <admin-object-resource enabled="true" jndi-name="jms/SampleQueue" object-type="user" res-adapter="jmsra" res-type="javax.jms.Queue">
+    <admin-object-resource enabled="true" jndi-name="jms/SampleQueue" object-type="user" res-adapter="jmsra" res-type="jakarta.jms.Queue">
       <property name="Name" value="Queue"/>
     </admin-object-resource>
-    <admin-object-resource enabled="true" jndi-name="jms/adminQueue" object-type="user" res-adapter="jmsra" res-type="javax.jms.Queue">
+    <admin-object-resource enabled="true" jndi-name="jms/adminQueue" object-type="user" res-adapter="jmsra" res-type="jakarta.jms.Queue">
       <property name="Name" value="adminQueue"/>
     </admin-object-resource>
-    <admin-object-resource enabled="true" jndi-name="jms/MyQueue" object-type="user" res-adapter="jmsra" res-type="javax.jms.Queue">
+    <admin-object-resource enabled="true" jndi-name="jms/MyQueue" object-type="user" res-adapter="jmsra" res-type="jakarta.jms.Queue">
       <property name="Name" value="MyQueue"/>
     </admin-object-resource>
     <connector-resource enabled="true" jndi-name="jms/QCFactory" object-type="user" pool-name="__SYSTEM/pools/jms/QCFactory"/>
@@ -79,9 +79,9 @@
       <property name="User" value="DBUSER"/>
       <property name="Password" value="DBPASSWORD"/>
     </jdbc-connection-pool>
-    <connector-connection-pool connection-definition-name="javax.jms.QueueConnectionFactory" fail-all-connections="false" idle-timeout-in-seconds="300" max-pool-size="250" max-wait-time-in-millis="60000" name="__SYSTEM/pools/jms/QCFactory" pool-resize-quantity="2" resource-adapter-name="jmsra" steady-pool-size="1"/>
-    <connector-connection-pool connection-definition-name="javax.jms.QueueConnectionFactory" fail-all-connections="false" idle-timeout-in-seconds="300" max-pool-size="250" max-wait-time-in-millis="60000" name="__SYSTEM/pools/jms/QueueConnectionFactory" pool-resize-quantity="2" resource-adapter-name="jmsra" steady-pool-size="1"/>
-    <connector-connection-pool connection-definition-name="javax.jms.QueueConnectionFactory" fail-all-connections="false" idle-timeout-in-seconds="300" max-pool-size="250" max-wait-time-in-millis="60000" name="__SYSTEM/pools/jms/MyQueueConnectionFactory" pool-resize-quantity="2" resource-adapter-name="jmsra" steady-pool-size="1"/>
+    <connector-connection-pool connection-definition-name="jakarta.jms.QueueConnectionFactory" fail-all-connections="false" idle-timeout-in-seconds="300" max-pool-size="250" max-wait-time-in-millis="60000" name="__SYSTEM/pools/jms/QCFactory" pool-resize-quantity="2" resource-adapter-name="jmsra" steady-pool-size="1"/>
+    <connector-connection-pool connection-definition-name="jakarta.jms.QueueConnectionFactory" fail-all-connections="false" idle-timeout-in-seconds="300" max-pool-size="250" max-wait-time-in-millis="60000" name="__SYSTEM/pools/jms/QueueConnectionFactory" pool-resize-quantity="2" resource-adapter-name="jmsra" steady-pool-size="1"/>
+    <connector-connection-pool connection-definition-name="jakarta.jms.QueueConnectionFactory" fail-all-connections="false" idle-timeout-in-seconds="300" max-pool-size="250" max-wait-time-in-millis="60000" name="__SYSTEM/pools/jms/MyQueueConnectionFactory" pool-resize-quantity="2" resource-adapter-name="jmsra" steady-pool-size="1"/>
   </resources>
   <configs>
     <config dynamic-reconfiguration-enabled="true" name="server-config">
diff --git a/appserver/tests/appserv-tests/devtests/security/mdb/client/Client.java b/appserver/tests/appserv-tests/devtests/security/mdb/client/Client.java
index 59b0111..ba83b08 100644
--- a/appserver/tests/appserv-tests/devtests/security/mdb/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/security/mdb/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2006, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,7 +19,7 @@
 import java.io.*;
 import java.util.*;
 import javax.ejb.EJBHome;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.annotation.Resource;
 
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
@@ -46,12 +46,12 @@
     private static QueueConnectionFactory queueConFactory;
 
     @Resource(name="MsgBeanQueue", mappedName="jms/security_mdb_InQueue")
-    private static javax.jms.Queue msgBeanQueue;
+    private static jakarta.jms.Queue msgBeanQueue;
 
 //    @Resource(name="ClientQueue", mappedName="foo")
-//    private static javax.jms.Queue clientQueue;
+//    private static jakarta.jms.Queue clientQueue;
 @Resource(name="ClientQueue", mappedName="jms/security_mdb_OutQueue") 
-private static javax.jms.Queue clientQueue;
+private static jakarta.jms.Queue clientQueue;
 
 
     private QueueConnection queueCon;
@@ -107,7 +107,7 @@
         }
     }
 
-    public void sendMsgs(javax.jms.Queue queue, Message msg, int num) 
+    public void sendMsgs(jakarta.jms.Queue queue, Message msg, int num) 
         throws JMSException {
         for(int i = 0; i < num; i++) {
             System.out.println("Sending message " + i + " to " + queue + 
@@ -127,7 +127,7 @@
 
         message.setBooleanProperty("flag", true);
         message.setIntProperty("num", 2);
-        sendMsgs((javax.jms.Queue) dest, message, num);
+        sendMsgs((jakarta.jms.Queue) dest, message, num);
 
 /*        System.out.println("Waiting for queue message");
         Message recvdmessage = queueReceiver.receive(TIMEOUT);
diff --git a/appserver/tests/appserv-tests/devtests/security/mdb/create_resources.asadmin b/appserver/tests/appserv-tests/devtests/security/mdb/create_resources.asadmin
index c2f199c..05d89fc 100644
--- a/appserver/tests/appserv-tests/devtests/security/mdb/create_resources.asadmin
+++ b/appserver/tests/appserv-tests/devtests/security/mdb/create_resources.asadmin
@@ -1,11 +1,11 @@
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/security_mdb_QCF
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/security_mdb_QCF
 
 
 create-jmsdest --desttype queue security_mdb_InQueue 
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=security_mdb__mdb_InQueue jms/security_mdb_InQueue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=security_mdb__mdb_InQueue jms/security_mdb_InQueue
 
 
 create-jmsdest --desttype queue security_mdb_OutQueue 
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=security_mdb_OutQueue jms/security_mdb_OutQueue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=security_mdb_OutQueue jms/security_mdb_OutQueue
 
 quit
diff --git a/appserver/tests/appserv-tests/devtests/security/mdb/ejb/MessageBean.java b/appserver/tests/appserv-tests/devtests/security/mdb/ejb/MessageBean.java
index c71d098..d3eab37 100644
--- a/appserver/tests/appserv-tests/devtests/security/mdb/ejb/MessageBean.java
+++ b/appserver/tests/appserv-tests/devtests/security/mdb/ejb/MessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -25,15 +25,15 @@
 import javax.ejb.TransactionManagementType;
 import javax.ejb.ActivationConfigProperty;
 
-import javax.jms.MessageListener;
-import javax.jms.Message;
-import javax.jms.Queue;
-import javax.jms.QueueConnectionFactory;
-import javax.jms.QueueConnection;
-import javax.jms.QueueSession;
-import javax.jms.QueueSender;
-import javax.jms.TextMessage;
-import javax.jms.Session;
+import jakarta.jms.MessageListener;
+import jakarta.jms.Message;
+import jakarta.jms.Queue;
+import jakarta.jms.QueueConnectionFactory;
+import jakarta.jms.QueueConnection;
+import jakarta.jms.QueueSession;
+import jakarta.jms.QueueSender;
+import jakarta.jms.TextMessage;
+import jakarta.jms.Session;
 
 import javax.annotation.Resource;
 import javax.annotation.security.RunAs;
diff --git a/appserver/tests/appserv-tests/devtests/transaction/ee/dblogs/mdb/client/Client.java b/appserver/tests/appserv-tests/devtests/transaction/ee/dblogs/mdb/client/Client.java
index a6a09a6..8a23176 100644
--- a/appserver/tests/appserv-tests/devtests/transaction/ee/dblogs/mdb/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/transaction/ee/dblogs/mdb/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2011, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2011, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -59,9 +59,9 @@
             asadmin("create-local-instance", "--cluster", CLUSTER_NAME, INSTANCE1_NAME);
             asadmin("create-local-instance", "--cluster", CLUSTER_NAME, INSTANCE2_NAME);
             System.out.println("Creating JMS resources");
-            asadmin("create-jms-resource", "--target", CLUSTER_NAME, "--restype", "javax.jms.QueueConnectionFactory", "jms/ejb_mdb_QCF");
+            asadmin("create-jms-resource", "--target", CLUSTER_NAME, "--restype", "jakarta.jms.QueueConnectionFactory", "jms/ejb_mdb_QCF");
             asadmin("create-jmsdest", "--target", CLUSTER_NAME, "--desttype", "ejb_mdb_Queue");
-            asadmin("create-jms-resource", "--target", CLUSTER_NAME, "--restype", "javax.jms.Queue", "--property", "imqDestinationName=ejb_mdb_Queue", "jms/ejb_mdb_Queue");
+            asadmin("create-jms-resource", "--target", CLUSTER_NAME, "--restype", "jakarta.jms.Queue", "--property", "imqDestinationName=ejb_mdb_Queue", "jms/ejb_mdb_Queue");
             System.out.println("Finished creating JMS resources");
 
             if (Boolean.getBoolean("enableShoalLogger")) {
diff --git a/appserver/tests/appserv-tests/devtests/transaction/ee/dblogs/mdb/war/MdBean.java b/appserver/tests/appserv-tests/devtests/transaction/ee/dblogs/mdb/war/MdBean.java
index 87421d7..22d28b7 100644
--- a/appserver/tests/appserv-tests/devtests/transaction/ee/dblogs/mdb/war/MdBean.java
+++ b/appserver/tests/appserv-tests/devtests/transaction/ee/dblogs/mdb/war/MdBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -22,7 +22,7 @@
 package com.acme;
 
 import javax.ejb.*;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/transaction/ee/dblogs/mdb/war/MyBean.java b/appserver/tests/appserv-tests/devtests/transaction/ee/dblogs/mdb/war/MyBean.java
index 5524f6d..2f9c8ec 100644
--- a/appserver/tests/appserv-tests/devtests/transaction/ee/dblogs/mdb/war/MyBean.java
+++ b/appserver/tests/appserv-tests/devtests/transaction/ee/dblogs/mdb/war/MyBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -22,10 +22,8 @@
 package com.acme;
 
 import java.sql.*;
-import java.util.Set;
-import java.util.HashSet;
 import javax.ejb.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.sql.DataSource;
 import javax.naming.InitialContext;
 import javax.annotation.Resource;
diff --git a/appserver/tests/appserv-tests/devtests/transaction/ee/mdb/client/Client.java b/appserver/tests/appserv-tests/devtests/transaction/ee/mdb/client/Client.java
index a5e478d..4bf4f0e 100644
--- a/appserver/tests/appserv-tests/devtests/transaction/ee/mdb/client/Client.java
+++ b/appserver/tests/appserv-tests/devtests/transaction/ee/mdb/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2010, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -53,9 +53,9 @@
             asadmin("create-local-instance", "--cluster", CLUSTER_NAME, INSTANCE1_NAME);
             asadmin("create-local-instance", "--cluster", CLUSTER_NAME, INSTANCE2_NAME);
             System.out.println("Creating JMS resources");
-            asadmin("create-jms-resource", "--target", CLUSTER_NAME, "--restype", "javax.jms.QueueConnectionFactory", "jms/ejb_mdb_QCF");
+            asadmin("create-jms-resource", "--target", CLUSTER_NAME, "--restype", "jakarta.jms.QueueConnectionFactory", "jms/ejb_mdb_QCF");
             asadmin("create-jmsdest", "--target", CLUSTER_NAME, "--desttype", "ejb_mdb_Queue");
-            asadmin("create-jms-resource", "--target", CLUSTER_NAME, "--restype", "javax.jms.Queue", "--property", "imqDestinationName=ejb_mdb_Queue", "jms/ejb_mdb_Queue");
+            asadmin("create-jms-resource", "--target", CLUSTER_NAME, "--restype", "jakarta.jms.Queue", "--property", "imqDestinationName=ejb_mdb_Queue", "jms/ejb_mdb_Queue");
             System.out.println("Finished creating JMS resources");
 
             if (Boolean.getBoolean("enableShoalLogger")) {
diff --git a/appserver/tests/appserv-tests/devtests/transaction/ee/mdb/war/MdBean.java b/appserver/tests/appserv-tests/devtests/transaction/ee/mdb/war/MdBean.java
index 87421d7..22d28b7 100644
--- a/appserver/tests/appserv-tests/devtests/transaction/ee/mdb/war/MdBean.java
+++ b/appserver/tests/appserv-tests/devtests/transaction/ee/mdb/war/MdBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -22,7 +22,7 @@
 package com.acme;
 
 import javax.ejb.*;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  *
diff --git a/appserver/tests/appserv-tests/devtests/transaction/ee/mdb/war/MyBean.java b/appserver/tests/appserv-tests/devtests/transaction/ee/mdb/war/MyBean.java
index f7d90fd..dd93613 100644
--- a/appserver/tests/appserv-tests/devtests/transaction/ee/mdb/war/MyBean.java
+++ b/appserver/tests/appserv-tests/devtests/transaction/ee/mdb/war/MyBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -22,10 +22,8 @@
 package com.acme;
 
 import java.sql.*;
-import java.util.Set;
-import java.util.HashSet;
 import javax.ejb.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.sql.DataSource;
 import javax.naming.InitialContext;
 import javax.annotation.Resource;
diff --git a/appserver/tests/appserv-tests/devtests/transaction/txlao/descriptor/ejb-jar.xml b/appserver/tests/appserv-tests/devtests/transaction/txlao/descriptor/ejb-jar.xml
index a8e80b8..0d31a86 100755
--- a/appserver/tests/appserv-tests/devtests/transaction/txlao/descriptor/ejb-jar.xml
+++ b/appserver/tests/appserv-tests/devtests/transaction/txlao/descriptor/ejb-jar.xml
@@ -2,7 +2,7 @@
 <!DOCTYPE ejb-jar PUBLIC "-//Sun Microsystems, Inc.//DTD Enterprise JavaBeans 2.0//EN" "http://java.sun.com/dtd/ejb-jar_2_0.dtd">
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -86,13 +86,13 @@
       </resource-ref>
       <resource-ref>
         <res-ref-name>jms/QCFactory</res-ref-name>
-        <res-type>javax.jms.QueueConnectionFactory</res-type>
+        <res-type>jakarta.jms.QueueConnectionFactory</res-type>
         <res-auth>Container</res-auth>
         <res-sharing-scope>Shareable</res-sharing-scope>
       </resource-ref>
       <resource-env-ref>
         <resource-env-ref-name>jms/SampleQueue</resource-env-ref-name>
-        <resource-env-ref-type>javax.jms.Queue</resource-env-ref-type>
+        <resource-env-ref-type>jakarta.jms.Queue</resource-env-ref-type>
       </resource-env-ref>
     </session>
 
diff --git a/appserver/tests/appserv-tests/devtests/transaction/txlao/ejb/beanB/TxBeanB.java b/appserver/tests/appserv-tests/devtests/transaction/txlao/ejb/beanB/TxBeanB.java
index b10f0f6..8c00ea2 100755
--- a/appserver/tests/appserv-tests/devtests/transaction/txlao/ejb/beanB/TxBeanB.java
+++ b/appserver/tests/appserv-tests/devtests/transaction/txlao/ejb/beanB/TxBeanB.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -25,19 +25,18 @@
 import javax.sql.DataSource;
 import javax.naming.Context;
 import javax.naming.InitialContext;
-import java.util.Enumeration;
 import java.rmi.RemoteException;
 import java.util.*;
 
-import javax.jms.Queue;
-import javax.jms.Message;
-import javax.jms.TextMessage;
-import javax.jms.QueueSender;
-import javax.jms.QueueSession;
-import javax.jms.JMSException;
-import javax.jms.QueueReceiver;
-import javax.jms.QueueConnection;
-import javax.jms.QueueConnectionFactory;
+import jakarta.jms.Queue;
+import jakarta.jms.Message;
+import jakarta.jms.TextMessage;
+import jakarta.jms.QueueSender;
+import jakarta.jms.QueueSession;
+import jakarta.jms.JMSException;
+import jakarta.jms.QueueReceiver;
+import jakarta.jms.QueueConnection;
+import jakarta.jms.QueueConnectionFactory;
 
 
 public class TxBeanB implements SessionBean {
diff --git a/appserver/tests/appserv-tests/devtests/transaction/txstress/descriptor/ejb-jar.xml b/appserver/tests/appserv-tests/devtests/transaction/txstress/descriptor/ejb-jar.xml
index 22119c9..cafb3c1 100644
--- a/appserver/tests/appserv-tests/devtests/transaction/txstress/descriptor/ejb-jar.xml
+++ b/appserver/tests/appserv-tests/devtests/transaction/txstress/descriptor/ejb-jar.xml
@@ -2,7 +2,7 @@
 <!DOCTYPE ejb-jar PUBLIC "-//Sun Microsystems, Inc.//DTD Enterprise JavaBeans 2.0//EN" "http://java.sun.com/dtd/ejb-jar_2_0.dtd">
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -74,13 +74,13 @@
       </resource-ref>
       <resource-ref>
         <res-ref-name>jms/QCFactory</res-ref-name>
-        <res-type>javax.jms.QueueConnectionFactory</res-type>
+        <res-type>jakarta.jms.QueueConnectionFactory</res-type>
         <res-auth>Container</res-auth>
         <res-sharing-scope>Shareable</res-sharing-scope>
       </resource-ref>
       <resource-env-ref>
         <resource-env-ref-name>jms/SampleQueue</resource-env-ref-name>
-        <resource-env-ref-type>javax.jms.Queue</resource-env-ref-type>
+        <resource-env-ref-type>jakarta.jms.Queue</resource-env-ref-type>
       </resource-env-ref>
     </session>
 
diff --git a/appserver/tests/appserv-tests/devtests/transaction/txstress/descriptor/ejb-jar.xml.back b/appserver/tests/appserv-tests/devtests/transaction/txstress/descriptor/ejb-jar.xml.back
index 22119c9..d6d80a9 100755
--- a/appserver/tests/appserv-tests/devtests/transaction/txstress/descriptor/ejb-jar.xml.back
+++ b/appserver/tests/appserv-tests/devtests/transaction/txstress/descriptor/ejb-jar.xml.back
@@ -74,13 +74,13 @@
       </resource-ref>
       <resource-ref>
         <res-ref-name>jms/QCFactory</res-ref-name>
-        <res-type>javax.jms.QueueConnectionFactory</res-type>
+        <res-type>jakarta.jms.QueueConnectionFactory</res-type>
         <res-auth>Container</res-auth>
         <res-sharing-scope>Shareable</res-sharing-scope>
       </resource-ref>
       <resource-env-ref>
         <resource-env-ref-name>jms/SampleQueue</resource-env-ref-name>
-        <resource-env-ref-type>javax.jms.Queue</resource-env-ref-type>
+        <resource-env-ref-type>jakarta.jms.Queue</resource-env-ref-type>
       </resource-env-ref>
     </session>
 
diff --git a/appserver/tests/appserv-tests/devtests/transaction/txstress/descriptor/ejb-jar.xml.template b/appserver/tests/appserv-tests/devtests/transaction/txstress/descriptor/ejb-jar.xml.template
index 9f26a3f..fadf853 100755
--- a/appserver/tests/appserv-tests/devtests/transaction/txstress/descriptor/ejb-jar.xml.template
+++ b/appserver/tests/appserv-tests/devtests/transaction/txstress/descriptor/ejb-jar.xml.template
@@ -74,13 +74,13 @@
       </resource-ref>
       <resource-ref>
         <res-ref-name>jms/QCFactory</res-ref-name>
-        <res-type>javax.jms.QueueConnectionFactory</res-type>
+        <res-type>jakarta.jms.QueueConnectionFactory</res-type>
         <res-auth>Container</res-auth>
         <res-sharing-scope>Shareable</res-sharing-scope>
       </resource-ref>
       <resource-env-ref>
         <resource-env-ref-name>jms/SampleQueue</resource-env-ref-name>
-        <resource-env-ref-type>javax.jms.Queue</resource-env-ref-type>
+        <resource-env-ref-type>jakarta.jms.Queue</resource-env-ref-type>
       </resource-env-ref>
     </session>
 
diff --git a/appserver/tests/appserv-tests/devtests/transaction/txstress/ejb/beanB/TxBeanB.java b/appserver/tests/appserv-tests/devtests/transaction/txstress/ejb/beanB/TxBeanB.java
index 429b81f..dbdbfba 100755
--- a/appserver/tests/appserv-tests/devtests/transaction/txstress/ejb/beanB/TxBeanB.java
+++ b/appserver/tests/appserv-tests/devtests/transaction/txstress/ejb/beanB/TxBeanB.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,24 +20,15 @@
 import javax.ejb.SessionContext;
 
 import java.sql.Statement;
-import java.sql.ResultSet;
 import javax.transaction.UserTransaction;
 import java.sql.Connection;
 import javax.sql.DataSource;
 import javax.naming.Context;
 import javax.naming.InitialContext;
-import java.util.Enumeration;
 import java.rmi.RemoteException;
 
-import javax.jms.Queue;
-import javax.jms.Message;
-import javax.jms.TextMessage;
-import javax.jms.QueueSender;
-import javax.jms.QueueSession;
-import javax.jms.JMSException;
-import javax.jms.QueueReceiver;
-import javax.jms.QueueConnection;
-import javax.jms.QueueConnectionFactory;
+import jakarta.jms.Queue;
+import jakarta.jms.QueueConnectionFactory;
 
 
 public class TxBeanB implements SessionBean {
diff --git a/appserver/tests/appserv-tests/devtests/transaction/txstressreadonly/descriptor/ejb-jar.xml b/appserver/tests/appserv-tests/devtests/transaction/txstressreadonly/descriptor/ejb-jar.xml
index 71b7857..66652e1 100644
--- a/appserver/tests/appserv-tests/devtests/transaction/txstressreadonly/descriptor/ejb-jar.xml
+++ b/appserver/tests/appserv-tests/devtests/transaction/txstressreadonly/descriptor/ejb-jar.xml
@@ -2,7 +2,7 @@
 <!DOCTYPE ejb-jar PUBLIC "-//Sun Microsystems, Inc.//DTD Enterprise JavaBeans 2.0//EN" "http://java.sun.com/dtd/ejb-jar_2_0.dtd">
 <!--
 
-    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -74,13 +74,13 @@
       </resource-ref>
       <resource-ref>
         <res-ref-name>jms/QCFactory</res-ref-name>
-        <res-type>javax.jms.QueueConnectionFactory</res-type>
+        <res-type>jakarta.jms.QueueConnectionFactory</res-type>
         <res-auth>Container</res-auth>
         <res-sharing-scope>Shareable</res-sharing-scope>
       </resource-ref>
       <resource-env-ref>
         <resource-env-ref-name>jms/SampleQueue</resource-env-ref-name>
-        <resource-env-ref-type>javax.jms.Queue</resource-env-ref-type>
+        <resource-env-ref-type>jakarta.jms.Queue</resource-env-ref-type>
       </resource-env-ref>
     </session>
 
diff --git a/appserver/tests/appserv-tests/devtests/transaction/txstressreadonly/descriptor/ejb-jar.xml.back b/appserver/tests/appserv-tests/devtests/transaction/txstressreadonly/descriptor/ejb-jar.xml.back
index 22119c9..d6d80a9 100755
--- a/appserver/tests/appserv-tests/devtests/transaction/txstressreadonly/descriptor/ejb-jar.xml.back
+++ b/appserver/tests/appserv-tests/devtests/transaction/txstressreadonly/descriptor/ejb-jar.xml.back
@@ -74,13 +74,13 @@
       </resource-ref>
       <resource-ref>
         <res-ref-name>jms/QCFactory</res-ref-name>
-        <res-type>javax.jms.QueueConnectionFactory</res-type>
+        <res-type>jakarta.jms.QueueConnectionFactory</res-type>
         <res-auth>Container</res-auth>
         <res-sharing-scope>Shareable</res-sharing-scope>
       </resource-ref>
       <resource-env-ref>
         <resource-env-ref-name>jms/SampleQueue</resource-env-ref-name>
-        <resource-env-ref-type>javax.jms.Queue</resource-env-ref-type>
+        <resource-env-ref-type>jakarta.jms.Queue</resource-env-ref-type>
       </resource-env-ref>
     </session>
 
diff --git a/appserver/tests/appserv-tests/devtests/transaction/txstressreadonly/descriptor/ejb-jar.xml.template b/appserver/tests/appserv-tests/devtests/transaction/txstressreadonly/descriptor/ejb-jar.xml.template
index 9f26a3f..fadf853 100755
--- a/appserver/tests/appserv-tests/devtests/transaction/txstressreadonly/descriptor/ejb-jar.xml.template
+++ b/appserver/tests/appserv-tests/devtests/transaction/txstressreadonly/descriptor/ejb-jar.xml.template
@@ -74,13 +74,13 @@
       </resource-ref>
       <resource-ref>
         <res-ref-name>jms/QCFactory</res-ref-name>
-        <res-type>javax.jms.QueueConnectionFactory</res-type>
+        <res-type>jakarta.jms.QueueConnectionFactory</res-type>
         <res-auth>Container</res-auth>
         <res-sharing-scope>Shareable</res-sharing-scope>
       </resource-ref>
       <resource-env-ref>
         <resource-env-ref-name>jms/SampleQueue</resource-env-ref-name>
-        <resource-env-ref-type>javax.jms.Queue</resource-env-ref-type>
+        <resource-env-ref-type>jakarta.jms.Queue</resource-env-ref-type>
       </resource-env-ref>
     </session>
 
diff --git a/appserver/tests/appserv-tests/devtests/transaction/txstressreadonly/ejb/beanB/TxBeanB.java b/appserver/tests/appserv-tests/devtests/transaction/txstressreadonly/ejb/beanB/TxBeanB.java
index 278a5a9..a43e678 100755
--- a/appserver/tests/appserv-tests/devtests/transaction/txstressreadonly/ejb/beanB/TxBeanB.java
+++ b/appserver/tests/appserv-tests/devtests/transaction/txstressreadonly/ejb/beanB/TxBeanB.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -26,18 +26,9 @@
 import javax.sql.DataSource;
 import javax.naming.Context;
 import javax.naming.InitialContext;
-import java.util.Enumeration;
 import java.rmi.RemoteException;
-
-import javax.jms.Queue;
-import javax.jms.Message;
-import javax.jms.TextMessage;
-import javax.jms.QueueSender;
-import javax.jms.QueueSession;
-import javax.jms.JMSException;
-import javax.jms.QueueReceiver;
-import javax.jms.QueueConnection;
-import javax.jms.QueueConnectionFactory;
+import jakarta.jms.Queue;
+import jakarta.jms.QueueConnectionFactory;
 
 
 public class TxBeanB implements SessionBean {
diff --git a/appserver/tests/appserv-tests/devtests/web/ha/cluster-tests/simple-failover-modified-session/SFSBModifiedSession/web/WEB-INF/glassfish-web.xml b/appserver/tests/appserv-tests/devtests/web/ha/cluster-tests/simple-failover-modified-session/SFSBModifiedSession/web/WEB-INF/glassfish-web.xml
new file mode 100644
index 0000000..e83e490
--- /dev/null
+++ b/appserver/tests/appserv-tests/devtests/web/ha/cluster-tests/simple-failover-modified-session/SFSBModifiedSession/web/WEB-INF/glassfish-web.xml
@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+
+    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+
+    This program and the accompanying materials are made available under the
+    terms of the Eclipse Public License v. 2.0, which is available at
+    http://www.eclipse.org/legal/epl-2.0.
+
+    This Source Code may also be made available under the following Secondary
+    Licenses when the conditions for such availability set forth in the
+    Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+    version 2 with the GNU Classpath Exception, which is available at
+    https://www.gnu.org/software/classpath/license.html.
+
+    SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+
+-->
+
+<web-app version="3.0" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
+    <distributable/>
+    <servlet>
+        <servlet-name>SFSBDriverServlet</servlet-name>
+        <servlet-class>net.max.ee.sfsb.SFSBDriverServlet</servlet-class>
+    </servlet>
+    <servlet-mapping>
+        <servlet-name>SFSBDriverServlet</servlet-name>
+        <url-pattern>/SFSBDriverServlet</url-pattern>
+    </servlet-mapping>
+    <session-config>
+        <session-timeout>
+            30
+        </session-timeout>
+    </session-config>
+</web-app>
\ No newline at end of file
diff --git a/appserver/tests/appserv-tests/devtests/web/weblogicDD/referenceDescriptor/build.xml b/appserver/tests/appserv-tests/devtests/web/weblogicDD/referenceDescriptor/build.xml
index c7281ca..fe21857 100644
--- a/appserver/tests/appserv-tests/devtests/web/weblogicDD/referenceDescriptor/build.xml
+++ b/appserver/tests/appserv-tests/devtests/web/weblogicDD/referenceDescriptor/build.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="ISO-8859-1"?>
 <!--
 
-    Copyright (c) 1997, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 1997, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -70,7 +70,7 @@
         <antcall target="asadmin-common-ignore-fail">
             <param name="admin.command" value="create-jms-resource" />
             <param name="operand.props"
-                value="--restype javax.jms.Queue --property imqDestinationName=my_queue jms/myQueue"/>
+                value="--restype jakarta.jms.Queue --property imqDestinationName=my_queue jms/myQueue"/>
         </antcall>
     </target>
 
diff --git a/appserver/tests/appserv-tests/devtests/web/weblogicDD/referenceDescriptor/descriptor/web.xml b/appserver/tests/appserv-tests/devtests/web/weblogicDD/referenceDescriptor/descriptor/web.xml
index 57e558f..269be73 100644
--- a/appserver/tests/appserv-tests/devtests/web/weblogicDD/referenceDescriptor/descriptor/web.xml
+++ b/appserver/tests/appserv-tests/devtests/web/weblogicDD/referenceDescriptor/descriptor/web.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8" standalone="no"?>
 <!--
 
-    Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2010, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,6 +20,6 @@
 <web-app xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" metadata-complete="false" version="3.0" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
     <resource-env-ref>
         <resource-env-ref-name>jms/QueueName</resource-env-ref-name>
-        <resource-env-ref-type>javax.jms.Queue</resource-env-ref-type>
+        <resource-env-ref-type>jakarta.jms.Queue</resource-env-ref-type>
     </resource-env-ref>
 </web-app>
diff --git a/appserver/tests/appserv-tests/devtests/web/weblogicDD/referenceDescriptor/servlet/test/TestServlet.java b/appserver/tests/appserv-tests/devtests/web/weblogicDD/referenceDescriptor/servlet/test/TestServlet.java
index aab9e1f..1f0d031 100644
--- a/appserver/tests/appserv-tests/devtests/web/weblogicDD/referenceDescriptor/servlet/test/TestServlet.java
+++ b/appserver/tests/appserv-tests/devtests/web/weblogicDD/referenceDescriptor/servlet/test/TestServlet.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,7 +20,7 @@
 
 import javax.annotation.Resource;
 import javax.ejb.EJB;
-import javax.jms.Queue;
+import jakarta.jms.Queue;
 import javax.naming.InitialContext;
 import javax.servlet.*;
 import javax.servlet.http.*;
diff --git a/appserver/tests/appserv-tests/devtests/webservice/jbi-serviceengine/ejb-jmsbc/build.properties b/appserver/tests/appserv-tests/devtests/webservice/jbi-serviceengine/ejb-jmsbc/build.properties
index dee679b..d40be86 100644
--- a/appserver/tests/appserv-tests/devtests/webservice/jbi-serviceengine/ejb-jmsbc/build.properties
+++ b/appserver/tests/appserv-tests/devtests/webservice/jbi-serviceengine/ejb-jmsbc/build.properties
@@ -38,5 +38,5 @@
 <property name="jms-consumer-assembly" value="client_ejb_consumer_assembly"/>
 <property name="jms-consumer-su" value="client_ejb_consumer_su"/>
 <property name="jms-consumer-su-dir" value="consumer/jms-binding-su"/>
-<property name="QueueConnectionFactory" value="javax.jms.QueueConnectionFactory"/>
-<property name="Queue" value="javax.jms.Queue"/>
+<property name="QueueConnectionFactory" value="jakarta.jms.QueueConnectionFactory"/>
+<property name="Queue" value="jakarta.jms.Queue"/>
diff --git a/appserver/tests/appserv-tests/devtests/webservice/jbi-serviceengine/soapoverjms/build.properties b/appserver/tests/appserv-tests/devtests/webservice/jbi-serviceengine/soapoverjms/build.properties
index ec13217..6ae49c8 100644
--- a/appserver/tests/appserv-tests/devtests/webservice/jbi-serviceengine/soapoverjms/build.properties
+++ b/appserver/tests/appserv-tests/devtests/webservice/jbi-serviceengine/soapoverjms/build.properties
@@ -38,5 +38,5 @@
 <property name="jms-consumer-assembly" value="client_web_calculator_consumer_assembly"/>
 <property name="jms-consumer-su" value="client_web_calculator_consumer_su"/>
 <property name="jms-consumer-su-dir" value="consumer/jms-binding-su"/>
-<property name="QueueConnectionFactory" value="javax.jms.QueueConnectionFactory"/>
-<property name="Queue" value="javax.jms.Queue"/>
+<property name="QueueConnectionFactory" value="jakarta.jms.QueueConnectionFactory"/>
+<property name="Queue" value="jakarta.jms.Queue"/>
diff --git a/appserver/tests/embedded/maven-plugin/mdb/pom.xml b/appserver/tests/embedded/maven-plugin/mdb/pom.xml
index 402b19b..af1aa78 100644
--- a/appserver/tests/embedded/maven-plugin/mdb/pom.xml
+++ b/appserver/tests/embedded/maven-plugin/mdb/pom.xml
@@ -50,8 +50,8 @@
                         </goals>
                         <configuration>
                             <commands>
-                                <param>create-jms-resource --restype javax.jms.Queue --property imqDestinationName=TestQueue jms/TestQueue</param>
-                                <param>create-jms-resource --restype javax.jms.QueueConnectionFactory jms/TestQueueConnectionFactory</param>
+                                <param>create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=TestQueue jms/TestQueue</param>
+                                <param>create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/TestQueueConnectionFactory</param>
                             </commands>
                         </configuration>
                     </execution>
diff --git a/appserver/tests/embedded/maven-plugin/mdb/src/main/java/org/glassfish/tests/embedded/mdb/MessageProcessorBean.java b/appserver/tests/embedded/maven-plugin/mdb/src/main/java/org/glassfish/tests/embedded/mdb/MessageProcessorBean.java
index 3db92e9..4622718 100644
--- a/appserver/tests/embedded/maven-plugin/mdb/src/main/java/org/glassfish/tests/embedded/mdb/MessageProcessorBean.java
+++ b/appserver/tests/embedded/maven-plugin/mdb/src/main/java/org/glassfish/tests/embedded/mdb/MessageProcessorBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2010, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -18,9 +18,9 @@
 
 import javax.ejb.ActivationConfigProperty;
 import javax.ejb.MessageDriven;
-import javax.jms.Message;
-import javax.jms.MessageListener;
-import javax.jms.TextMessage;
+import jakarta.jms.Message;
+import jakarta.jms.MessageListener;
+import jakarta.jms.TextMessage;
 import java.io.File;
 import java.io.FileOutputStream;
 import java.util.logging.Level;
@@ -32,7 +32,7 @@
 
 @MessageDriven(mappedName = "jms/TestQueue", activationConfig = {
         @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
-        @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Queue")
+        @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Queue")
 })
 public class MessageProcessorBean implements MessageListener {
 
diff --git a/appserver/tests/embedded/maven-plugin/mdb/src/main/java/org/glassfish/tests/embedded/mdb/UnitTest.java b/appserver/tests/embedded/maven-plugin/mdb/src/main/java/org/glassfish/tests/embedded/mdb/UnitTest.java
index 7e2c975..c35a7d5 100644
--- a/appserver/tests/embedded/maven-plugin/mdb/src/main/java/org/glassfish/tests/embedded/mdb/UnitTest.java
+++ b/appserver/tests/embedded/maven-plugin/mdb/src/main/java/org/glassfish/tests/embedded/mdb/UnitTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2010, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,12 +19,12 @@
 import org.junit.Assert;
 import org.junit.Test;
 
-import javax.jms.QueueConnection;
-import javax.jms.QueueConnectionFactory;
-import javax.jms.QueueSender;
-import javax.jms.QueueSession;
-import javax.jms.Session;
-import javax.jms.TextMessage;
+import jakarta.jms.QueueConnection;
+import jakarta.jms.QueueConnectionFactory;
+import jakarta.jms.QueueSender;
+import jakarta.jms.QueueSession;
+import jakarta.jms.Session;
+import jakarta.jms.TextMessage;
 import javax.naming.InitialContext;
 import java.io.File;
 import java.io.FileInputStream;
@@ -44,7 +44,7 @@
 
             QueueConnectionFactory qcf = (QueueConnectionFactory)
                     ic.lookup("jms/TestQueueConnectionFactory");
-            javax.jms.Queue queue = (javax.jms.Queue) ic.lookup("jms/TestQueue");
+            jakarta.jms.Queue queue = (jakarta.jms.Queue) ic.lookup("jms/TestQueue");
 
             queueConnection = qcf.createQueueConnection();
             queueConnection.start();
diff --git a/appserver/tests/embedded/maven-plugin/pom.xml b/appserver/tests/embedded/maven-plugin/pom.xml
index 8c529ed..21e929e 100644
--- a/appserver/tests/embedded/maven-plugin/pom.xml
+++ b/appserver/tests/embedded/maven-plugin/pom.xml
@@ -244,10 +244,10 @@
                 <scope>provided</scope>
             </dependency>                    
             <dependency>
-            <groupId>jakarta.jms</groupId>
-            <artifactId>jakarta.jms-api</artifactId>
+                <groupId>jakarta.jms</groupId>
+                <artifactId>jakarta.jms-api</artifactId>
                 <scope>provided</scope>
-                <version>2.0.2</version>
+                <version>3.0.0-RC1</version>
             </dependency>                    
         </dependencies>
     </dependencyManagement>
diff --git a/appserver/tests/paas/mq-shared-service-test/mq-app/ejb/pom.xml b/appserver/tests/paas/mq-shared-service-test/mq-app/ejb/pom.xml
index 523166c..bf051b9 100644
--- a/appserver/tests/paas/mq-shared-service-test/mq-app/ejb/pom.xml
+++ b/appserver/tests/paas/mq-shared-service-test/mq-app/ejb/pom.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2012, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2012, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -49,9 +49,9 @@
 	</build>
 	<dependencies>
 	<dependency>
-	      <groupId>javax.jms</groupId>
-	      <artifactId>javax.jms-api</artifactId>
-	      <version>2.0.1</version>
+	      <groupId>jakarta.jms</groupId>
+	      <artifactId>jakarta.jms-api</artifactId>
+	      <version>3.0.0-RC1</version>
 	</dependency>
 	<dependency>
 	      <groupId>jakarta.ejb</groupId>
diff --git a/appserver/tests/paas/mq-shared-service-test/mq-app/ejb/src/main/java/com/sun/s1asdev/ejb/ejb30/hello/mdb/MessageBean.java b/appserver/tests/paas/mq-shared-service-test/mq-app/ejb/src/main/java/com/sun/s1asdev/ejb/ejb30/hello/mdb/MessageBean.java
index 13da1a1..0f94108 100644
--- a/appserver/tests/paas/mq-shared-service-test/mq-app/ejb/src/main/java/com/sun/s1asdev/ejb/ejb30/hello/mdb/MessageBean.java
+++ b/appserver/tests/paas/mq-shared-service-test/mq-app/ejb/src/main/java/com/sun/s1asdev/ejb/ejb30/hello/mdb/MessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -18,7 +18,7 @@
 
 import javax.annotation.Resource;
 import javax.ejb.*;
-import javax.jms.*;
+import jakarta.jms.*;
 
 //Messages received from InQueue
 @MessageDriven(mappedName="jms/ejb_ejb30_hello_mdb_InQueue")
diff --git a/appserver/tests/paas/mq-shared-service-test/mq-app/web/pom.xml b/appserver/tests/paas/mq-shared-service-test/mq-app/web/pom.xml
index 97cdce9..6f20460 100644
--- a/appserver/tests/paas/mq-shared-service-test/mq-app/web/pom.xml
+++ b/appserver/tests/paas/mq-shared-service-test/mq-app/web/pom.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2012, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2012, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -43,7 +43,7 @@
         <dependency>
             <groupId>jakarta.jms</groupId>
             <artifactId>jakarta.jms-api</artifactId>
-            <version>2.0.2</version>
+            <version>3.0.0-RC1</version>
         </dependency>
 	<dependency>
 	    <groupId>jakarta.servlet</groupId>
diff --git a/appserver/tests/paas/mq-shared-service-test/mq-app/web/src/main/java/com/sun/s1asdev/ejb/ejb30/hello/mdb/web/TestServlet.java b/appserver/tests/paas/mq-shared-service-test/mq-app/web/src/main/java/com/sun/s1asdev/ejb/ejb30/hello/mdb/web/TestServlet.java
index 12e632d..5511824 100644
--- a/appserver/tests/paas/mq-shared-service-test/mq-app/web/src/main/java/com/sun/s1asdev/ejb/ejb30/hello/mdb/web/TestServlet.java
+++ b/appserver/tests/paas/mq-shared-service-test/mq-app/web/src/main/java/com/sun/s1asdev/ejb/ejb30/hello/mdb/web/TestServlet.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -29,7 +29,7 @@
 
 import java.io.*;
 import java.util.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.annotation.Resource;
 
 
@@ -43,11 +43,11 @@
     
     //Target Queue
     @Resource(mappedName="jms/ejb_ejb30_hello_mdb_InQueue")
-    private javax.jms.Queue msgBeanQueue;
+    private jakarta.jms.Queue msgBeanQueue;
 
     //Reply Queue
     @Resource(mappedName="jms/ejb_ejb30_hello_mdb_OutQueue")
-    private javax.jms.Queue clientQueue;
+    private jakarta.jms.Queue clientQueue;
 
     private QueueConnection queueCon;
     private QueueSession queueSession;
@@ -106,7 +106,7 @@
             t.printStackTrace();
         }
     }
-  public void sendMsgs(javax.jms.Queue queue, int num)
+  public void sendMsgs(jakarta.jms.Queue queue, int num)
         throws JMSException {
         for(int i = 0; i < num; i++) {
             Message message = queueSession.createTextMessage("foo #" + (i + 1));
@@ -121,7 +121,7 @@
 
     public void doTest(int num)
         throws Exception {
-        sendMsgs((javax.jms.Queue) msgBeanQueue, num);
+        sendMsgs((jakarta.jms.Queue) msgBeanQueue, num);
 
         //Now attempt to receive responses to our message
         System.out.println("Waiting for queue message");
diff --git a/appserver/tests/quicklook/ejb/mdb/create_resources.asadmin b/appserver/tests/quicklook/ejb/mdb/create_resources.asadmin
index 47d37b7..0a0b5d2 100755
--- a/appserver/tests/quicklook/ejb/mdb/create_resources.asadmin
+++ b/appserver/tests/quicklook/ejb/mdb/create_resources.asadmin
@@ -14,8 +14,8 @@
 # SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 #
 
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/ejb_ejb30_hello_mdb_QCF
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/ejb_ejb30_hello_mdb_QCF
 create-jmsdest --desttype queue ejb_ejb30_hello_mdb_InQueue 
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=ejb_ejb30_hello_mdb_InQueue jms/ejb_ejb30_hello_mdb_InQueue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=ejb_ejb30_hello_mdb_InQueue jms/ejb_ejb30_hello_mdb_InQueue
 create-jmsdest --desttype queue ejb_ejb30_hello_mdb_OutQueue 
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=ejb_ejb30_hello_mdb_OutQueue jms/ejb_ejb30_hello_mdb_OutQueue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=ejb_ejb30_hello_mdb_OutQueue jms/ejb_ejb30_hello_mdb_OutQueue
diff --git a/appserver/tests/quicklook/ejb/mdb/src/com/sun/mdb/MessageBean.java b/appserver/tests/quicklook/ejb/mdb/src/com/sun/mdb/MessageBean.java
index c20a276..e7797af 100755
--- a/appserver/tests/quicklook/ejb/mdb/src/com/sun/mdb/MessageBean.java
+++ b/appserver/tests/quicklook/ejb/mdb/src/com/sun/mdb/MessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2009, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2009, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,22 +17,19 @@
 package com.sun.mdb;
 
 import javax.ejb.MessageDriven;
-import javax.ejb.EJBException;
 import javax.ejb.NoSuchEJBException;
 import javax.ejb.EJB;
 import javax.ejb.TransactionManagement;
 import javax.ejb.TransactionManagementType;
-import javax.ejb.ActivationConfigProperty;
-
-import javax.jms.MessageListener;
-import javax.jms.Message;
-import javax.jms.Queue;
-import javax.jms.QueueConnectionFactory;
-import javax.jms.QueueConnection;
-import javax.jms.QueueSession;
-import javax.jms.QueueSender;
-import javax.jms.TextMessage;
-import javax.jms.Session;
+import jakarta.jms.MessageListener;
+import jakarta.jms.Message;
+import jakarta.jms.Queue;
+import jakarta.jms.QueueConnectionFactory;
+import jakarta.jms.QueueConnection;
+import jakarta.jms.QueueSession;
+import jakarta.jms.QueueSender;
+import jakarta.jms.TextMessage;
+import jakarta.jms.Session;
 
 import javax.annotation.Resource;
 
diff --git a/appserver/tests/quicklook/ejb/mdb/src/com/sun/mdb/client/Client.java b/appserver/tests/quicklook/ejb/mdb/src/com/sun/mdb/client/Client.java
index 3e7877e..3c0365a 100644
--- a/appserver/tests/quicklook/ejb/mdb/src/com/sun/mdb/client/Client.java
+++ b/appserver/tests/quicklook/ejb/mdb/src/com/sun/mdb/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2009, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2009, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,7 +16,7 @@
 
 package com.sun.mdb.client;
 
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.annotation.Resource;
 import javax.naming.InitialContext;
 
@@ -39,10 +39,10 @@
     private static QueueConnectionFactory queueConFactory;
 
     @Resource(name="MsgBeanQueue", mappedName="jms/ejb_ejb30_hello_mdb_InQueue")
-    private static javax.jms.Queue msgBeanQueue;
+    private static jakarta.jms.Queue msgBeanQueue;
 
     @Resource(name="ClientQueue", mappedName="foo")
-    private static javax.jms.Queue clientQueue;
+    private static jakarta.jms.Queue clientQueue;
 
     private QueueConnection queueCon;
     private QueueSession queueSession;
@@ -65,9 +65,9 @@
 
 		System.out.println("Java SE mode...");
 		InitialContext ic = new InitialContext();
-		queueConFactory = (javax.jms.QueueConnectionFactory) ic.lookup("jms/ejb_ejb30_hello_mdb_QCF");
-		msgBeanQueue = (javax.jms.Queue) ic.lookup("jms/ejb_ejb30_hello_mdb_InQueue");
-		clientQueue = (javax.jms.Queue) ic.lookup("jms/ejb_ejb30_hello_mdb_OutQueue");
+		queueConFactory = (jakarta.jms.QueueConnectionFactory) ic.lookup("jms/ejb_ejb30_hello_mdb_QCF");
+		msgBeanQueue = (jakarta.jms.Queue) ic.lookup("jms/ejb_ejb30_hello_mdb_InQueue");
+		clientQueue = (jakarta.jms.Queue) ic.lookup("jms/ejb_ejb30_hello_mdb_OutQueue");
 		
 	    }
 
@@ -105,7 +105,7 @@
         }
     }
 
-    public void sendMsgs(javax.jms.Queue queue, Message msg, int num) 
+    public void sendMsgs(jakarta.jms.Queue queue, Message msg, int num) 
         throws JMSException {
         for(int i = 0; i < num; i++) {
             System.out.println("Sending message " + i + " to " + queue + 
@@ -125,7 +125,7 @@
 
         message.setBooleanProperty("flag", true);
         message.setIntProperty("num", 2);
-        sendMsgs((javax.jms.Queue) dest, message, num);
+        sendMsgs((jakarta.jms.Queue) dest, message, num);
 
         System.out.println("Waiting for queue message");
         Message recvdmessage = queueReceiver.receive(TIMEOUT);
diff --git a/appserver/tests/quicklook/jms/injection/src/java/SimpleEjb.java b/appserver/tests/quicklook/jms/injection/src/java/SimpleEjb.java
index e873e7f..c9c868f 100644
--- a/appserver/tests/quicklook/jms/injection/src/java/SimpleEjb.java
+++ b/appserver/tests/quicklook/jms/injection/src/java/SimpleEjb.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2013, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -18,7 +18,7 @@
 
 import javax.ejb.*;
 import javax.inject.Inject;
-import javax.jms.*;
+import jakarta.jms.*;
 
 /**
  * @author David Zhao
diff --git a/appserver/tests/v2-tests/appserv-tests/config/properties.xml b/appserver/tests/v2-tests/appserv-tests/config/properties.xml
index f2580c6..43630d2 100644
--- a/appserver/tests/v2-tests/appserv-tests/config/properties.xml
+++ b/appserver/tests/v2-tests/appserv-tests/config/properties.xml
@@ -1,6 +1,6 @@
 <!--
 
-    Copyright (c) 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2018, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -52,9 +52,9 @@
     <property name="dest.type" value="queue"/>
     <property name="dest.name" value="Queue"/>
     <property name="jms.factory.name" value="jms/QCFactory"/>
-    <property name="jms.factory.type" value="javax.jms.QueueConnectionFactory"/>
+    <property name="jms.factory.type" value="jakarta.jms.QueueConnectionFactory"/>
     <property name="jms.resource.name" value="jms/SampleQueue"/>
-    <property name="jms.resource.type" value="javax.jms.Queue"/>
+    <property name="jms.resource.type" value="jakarta.jms.Queue"/>
 
     <property name="jdbc.conpool.name" value="ql-jdbc-pool"/>
     <property name="jdbc.resource.name" value="jdbc/s1qeDB"/>
diff --git a/appserver/tests/v2-tests/appserv-tests/devtests/ee/admin/mbeanapi/deployment/com/sun/enterprise/admin/mbeanapi/deployment/samples/SOAPtoJMSMessageSampleClient/build.xml b/appserver/tests/v2-tests/appserv-tests/devtests/ee/admin/mbeanapi/deployment/com/sun/enterprise/admin/mbeanapi/deployment/samples/SOAPtoJMSMessageSampleClient/build.xml
index 2f13c4b..6a289b2 100644
--- a/appserver/tests/v2-tests/appserv-tests/devtests/ee/admin/mbeanapi/deployment/com/sun/enterprise/admin/mbeanapi/deployment/samples/SOAPtoJMSMessageSampleClient/build.xml
+++ b/appserver/tests/v2-tests/appserv-tests/devtests/ee/admin/mbeanapi/deployment/com/sun/enterprise/admin/mbeanapi/deployment/samples/SOAPtoJMSMessageSampleClient/build.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="iso-8859-1"?>
 <!--
 
-    Copyright (c) 2006, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2006, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Distribution License v. 1.0, which is available at
@@ -52,9 +52,9 @@
   <!-- ============================================================== -->
   <!--           Resource specific properties.                        -->
   <!-- ============================================================== -->
-  <property name="queue.factory.type" value="javax.jms.TopicConnectionFactory" />
+  <property name="queue.factory.type" value="jakarta.jms.TopicConnectionFactory" />
   <property name="queue.factory.jndi.name" value="jms/TopicConnectionFactory" />   
-  <property name="queue.type" value="javax.jms.Topic" />
+  <property name="queue.type" value="jakarta.jms.Topic" />
   <property name="queue.jndi.name" value="jms/TestTopic" />
   <property name="queue.property.name" value="imqDestinationName" />
   <property name="queue.property.value" value="TestTopic" />
diff --git a/appserver/tests/v2-tests/appserv-tests/devtests/ee/admin/mbeanapi/deployment/com/sun/enterprise/admin/mbeanapi/deployment/samples/SOAPtoJMSMessageSampleClient/docs/index.html b/appserver/tests/v2-tests/appserv-tests/devtests/ee/admin/mbeanapi/deployment/com/sun/enterprise/admin/mbeanapi/deployment/samples/SOAPtoJMSMessageSampleClient/docs/index.html
index e10f918..eb27a89 100644
--- a/appserver/tests/v2-tests/appserv-tests/devtests/ee/admin/mbeanapi/deployment/com/sun/enterprise/admin/mbeanapi/deployment/samples/SOAPtoJMSMessageSampleClient/docs/index.html
+++ b/appserver/tests/v2-tests/appserv-tests/devtests/ee/admin/mbeanapi/deployment/com/sun/enterprise/admin/mbeanapi/deployment/samples/SOAPtoJMSMessageSampleClient/docs/index.html
@@ -135,7 +135,7 @@
 <li>Add the following:
 <pre>
 JNDI-Name: jms/TopicConnectionFactory
-Type: javax.jms.TopicConnectionFactory
+Type: jakarta.jms.TopicConnectionFactory
 Resource: Select Enabled checkbox
 </pre>
 
@@ -145,7 +145,7 @@
 <li>Add the following:
 <pre>
 JNDI-Name: jms/TestTopic
-Type: javax.jms.Topic
+Type: jakarta.jms.Topic
 Resource: Select Enabled checkbox
 </pre>
    
@@ -162,7 +162,7 @@
 
 <pre>
 asadmin create-jms-resource --user <i>username</i> --password <i>password</i>
-  --restype javax.jms.TopicConnectionFactory
+  --restype jakarta.jms.TopicConnectionFactory
   jms/TopicConnectionFactory
 </pre>
 
@@ -170,7 +170,7 @@
 Configure destination(topic):
 
 <pre>asadmin create-jms-resource --user <i>username</i> --password <i>password</i>
-  --restype javax.jms.Topic --property Name=TestTopic
+  --restype jakarta.jms.Topic --property Name=TestTopic
   jms/TestTopic
 </pre>
 
diff --git a/appserver/tests/v2-tests/appserv-tests/devtests/ee/admin/mbeanapi/deployment/com/sun/enterprise/admin/mbeanapi/deployment/samples/SOAPtoJMSMessageSampleClient/simple-client/src/java/samples/jms/soaptojms/ReceiveSOAPMessageWithJMS.java b/appserver/tests/v2-tests/appserv-tests/devtests/ee/admin/mbeanapi/deployment/com/sun/enterprise/admin/mbeanapi/deployment/samples/SOAPtoJMSMessageSampleClient/simple-client/src/java/samples/jms/soaptojms/ReceiveSOAPMessageWithJMS.java
index 2fdd040..8470d8b 100644
--- a/appserver/tests/v2-tests/appserv-tests/devtests/ee/admin/mbeanapi/deployment/com/sun/enterprise/admin/mbeanapi/deployment/samples/SOAPtoJMSMessageSampleClient/simple-client/src/java/samples/jms/soaptojms/ReceiveSOAPMessageWithJMS.java
+++ b/appserver/tests/v2-tests/appserv-tests/devtests/ee/admin/mbeanapi/deployment/com/sun/enterprise/admin/mbeanapi/deployment/samples/SOAPtoJMSMessageSampleClient/simple-client/src/java/samples/jms/soaptojms/ReceiveSOAPMessageWithJMS.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2006, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Distribution License v. 1.0, which is available at
@@ -15,16 +15,15 @@
 import javax.xml.soap.AttachmentPart;
 
 import com.sun.messaging.xml.MessageTransformer;
-import javax.jms.TopicConnectionFactory;
+import jakarta.jms.TopicConnectionFactory;
 
-import javax.jms.MessageListener;
-import javax.jms.TopicConnection;
-import javax.jms.TopicSession;
-import javax.jms.Message;
-import javax.jms.Session;
-import javax.jms.Topic;
-import javax.jms.JMSException;
-import javax.jms.TopicSubscriber;
+import jakarta.jms.MessageListener;
+import jakarta.jms.TopicConnection;
+import jakarta.jms.TopicSession;
+import jakarta.jms.Message;
+import jakarta.jms.Session;
+import jakarta.jms.Topic;
+import jakarta.jms.TopicSubscriber;
 
 import java.util.Iterator;
 
diff --git a/appserver/tests/v2-tests/appserv-tests/devtests/ee/admin/mbeanapi/deployment/com/sun/enterprise/admin/mbeanapi/deployment/samples/SOAPtoJMSMessageSampleClient/simple-client/src/java/samples/jms/soaptojms/SOAPMessageWithJMSClient.java b/appserver/tests/v2-tests/appserv-tests/devtests/ee/admin/mbeanapi/deployment/com/sun/enterprise/admin/mbeanapi/deployment/samples/SOAPtoJMSMessageSampleClient/simple-client/src/java/samples/jms/soaptojms/SOAPMessageWithJMSClient.java
index db1ecfa..9d27ec0 100644
--- a/appserver/tests/v2-tests/appserv-tests/devtests/ee/admin/mbeanapi/deployment/com/sun/enterprise/admin/mbeanapi/deployment/samples/SOAPtoJMSMessageSampleClient/simple-client/src/java/samples/jms/soaptojms/SOAPMessageWithJMSClient.java
+++ b/appserver/tests/v2-tests/appserv-tests/devtests/ee/admin/mbeanapi/deployment/com/sun/enterprise/admin/mbeanapi/deployment/samples/SOAPtoJMSMessageSampleClient/simple-client/src/java/samples/jms/soaptojms/SOAPMessageWithJMSClient.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2006, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Distribution License v. 1.0, which is available at
@@ -10,24 +10,6 @@
 
 package samples.jms.soaptojms;
 
-import javax.xml.soap.MessageFactory;
-import javax.xml.soap.SOAPMessage;
-import javax.xml.soap.AttachmentPart;
-
-import com.sun.messaging.xml.MessageTransformer;
-import javax.jms.TopicConnectionFactory;
-
-import javax.jms.MessageListener;
-import javax.jms.TopicConnection;
-import javax.jms.TopicSession;
-import javax.jms.Message;
-import javax.jms.Session;
-import javax.jms.Topic;
-import javax.jms.JMSException;
-import javax.jms.TopicSubscriber;
-
-import java.util.Iterator;
-
 /**
  * This sample program shows a JMS message listener can use the MessageTransformer
  * utility to convert JMS messages back to SOAP messages.
diff --git a/appserver/tests/v2-tests/appserv-tests/devtests/ee/admin/mbeanapi/deployment/com/sun/enterprise/admin/mbeanapi/deployment/samples/SOAPtoJMSMessageSampleClient/simple-client/src/java/samples/jms/soaptojms/SendSOAPMessageWithJMS.java b/appserver/tests/v2-tests/appserv-tests/devtests/ee/admin/mbeanapi/deployment/com/sun/enterprise/admin/mbeanapi/deployment/samples/SOAPtoJMSMessageSampleClient/simple-client/src/java/samples/jms/soaptojms/SendSOAPMessageWithJMS.java
index e31af83..8cf82b4 100644
--- a/appserver/tests/v2-tests/appserv-tests/devtests/ee/admin/mbeanapi/deployment/com/sun/enterprise/admin/mbeanapi/deployment/samples/SOAPtoJMSMessageSampleClient/simple-client/src/java/samples/jms/soaptojms/SendSOAPMessageWithJMS.java
+++ b/appserver/tests/v2-tests/appserv-tests/devtests/ee/admin/mbeanapi/deployment/com/sun/enterprise/admin/mbeanapi/deployment/samples/SOAPtoJMSMessageSampleClient/simple-client/src/java/samples/jms/soaptojms/SendSOAPMessageWithJMS.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2006, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Distribution License v. 1.0, which is available at
@@ -24,15 +24,15 @@
 
 import com.sun.messaging.xml.MessageTransformer;
 //import com.sun.messaging.TopicConnectionFactory;
-import javax.jms.TopicConnectionFactory;
+import jakarta.jms.TopicConnectionFactory;
 
-import javax.jms.TopicConnection;
-import javax.jms.JMSException;
-import javax.jms.Session;
-import javax.jms.Message;
-import javax.jms.TopicSession;
-import javax.jms.Topic;
-import javax.jms.TopicPublisher;
+import jakarta.jms.TopicConnection;
+import jakarta.jms.JMSException;
+import jakarta.jms.Session;
+import jakarta.jms.Message;
+import jakarta.jms.TopicSession;
+import jakarta.jms.Topic;
+import jakarta.jms.TopicPublisher;
 
 import java.util.*;
 import java.io.*;
diff --git a/appserver/tests/v2-tests/appserv-tests/devtests/ee/admin/mbeanapi/deployment/com/sun/enterprise/admin/mbeanapi/deployment/samples/SOAPtoJMSMessageSampleClient/simple-client/src/java/samples/jms/soaptojms/ServiceLocator.java b/appserver/tests/v2-tests/appserv-tests/devtests/ee/admin/mbeanapi/deployment/com/sun/enterprise/admin/mbeanapi/deployment/samples/SOAPtoJMSMessageSampleClient/simple-client/src/java/samples/jms/soaptojms/ServiceLocator.java
index 3bd2f00..19793ec 100644
--- a/appserver/tests/v2-tests/appserv-tests/devtests/ee/admin/mbeanapi/deployment/com/sun/enterprise/admin/mbeanapi/deployment/samples/SOAPtoJMSMessageSampleClient/simple-client/src/java/samples/jms/soaptojms/ServiceLocator.java
+++ b/appserver/tests/v2-tests/appserv-tests/devtests/ee/admin/mbeanapi/deployment/com/sun/enterprise/admin/mbeanapi/deployment/samples/SOAPtoJMSMessageSampleClient/simple-client/src/java/samples/jms/soaptojms/ServiceLocator.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2006, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Distribution License v. 1.0, which is available at
@@ -15,10 +15,10 @@
 
 import javax.ejb.EJBHome;
 import javax.ejb.EJBLocalHome;
-import javax.jms.QueueConnectionFactory;
-import javax.jms.Queue;
-import javax.jms.TopicConnectionFactory;
-import javax.jms.Topic;
+import jakarta.jms.QueueConnectionFactory;
+import jakarta.jms.Queue;
+import jakarta.jms.TopicConnectionFactory;
+import jakarta.jms.Topic;
 import javax.naming.InitialContext;
 import javax.naming.NamingException;
 import javax.rmi.PortableRemoteObject;
diff --git a/appserver/tests/v2-tests/appserv-tests/devtests/ee/admin/notification/lookup/descriptor/ejb-jar.xml b/appserver/tests/v2-tests/appserv-tests/devtests/ee/admin/notification/lookup/descriptor/ejb-jar.xml
index c29c587..791981f 100644
--- a/appserver/tests/v2-tests/appserv-tests/devtests/ee/admin/notification/lookup/descriptor/ejb-jar.xml
+++ b/appserver/tests/v2-tests/appserv-tests/devtests/ee/admin/notification/lookup/descriptor/ejb-jar.xml
@@ -51,7 +51,7 @@
       </resource-ref>
       <resource-ref>
         <res-ref-name>jmsRes</res-ref-name>
-        <res-type>javax.jms.QueueConnectionFactory</res-type>
+        <res-type>jakarta.jms.QueueConnectionFactory</res-type>
         <res-auth>Container</res-auth>
         <res-sharing-scope>Shareable</res-sharing-scope>
       </resource-ref>
diff --git a/appserver/tests/v2-tests/appserv-tests/devtests/ee/admin/synchronization/api/client/client/Client.java b/appserver/tests/v2-tests/appserv-tests/devtests/ee/admin/synchronization/api/client/client/Client.java
index 9220175..915035d 100644
--- a/appserver/tests/v2-tests/appserv-tests/devtests/ee/admin/synchronization/api/client/client/Client.java
+++ b/appserver/tests/v2-tests/appserv-tests/devtests/ee/admin/synchronization/api/client/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,14 +16,10 @@
 
 package com.sun.s1asdev.ejb.stress.passivateactivate.client;
 
-import java.util.ArrayList;
-
-import java.io.Serializable;
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.ejb.*;
 import javax.rmi.PortableRemoteObject;
-import java.rmi.NoSuchObjectException;
 import java.util.Properties;
 
 import com.sun.s1asdev.admin.ee.synchronization.api.client.SynchronizationHome;
diff --git a/appserver/tests/v2-tests/appserv-tests/devtests/ee/admin/synchronization/api/deployment/client/Client.java b/appserver/tests/v2-tests/appserv-tests/devtests/ee/admin/synchronization/api/deployment/client/Client.java
index 56eb8db..0b14db2 100644
--- a/appserver/tests/v2-tests/appserv-tests/devtests/ee/admin/synchronization/api/deployment/client/Client.java
+++ b/appserver/tests/v2-tests/appserv-tests/devtests/ee/admin/synchronization/api/deployment/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,14 +16,10 @@
 
 package com.sun.s1asdev.ejb.stress.passivateactivate.client;
 
-import java.util.ArrayList;
-
-import java.io.Serializable;
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.ejb.*;
 import javax.rmi.PortableRemoteObject;
-import java.rmi.NoSuchObjectException;
 import java.util.Properties;
 
 import com.sun.s1asdev.admin.ee.synchronization.api.deployment.SynchronizationHome;
diff --git a/appserver/tests/v2-tests/appserv-tests/devtests/ee/admin/synchronization/api/security/client/RpaClient.java b/appserver/tests/v2-tests/appserv-tests/devtests/ee/admin/synchronization/api/security/client/RpaClient.java
index 51f6188..be225db 100644
--- a/appserver/tests/v2-tests/appserv-tests/devtests/ee/admin/synchronization/api/security/client/RpaClient.java
+++ b/appserver/tests/v2-tests/appserv-tests/devtests/ee/admin/synchronization/api/security/client/RpaClient.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,14 +16,10 @@
 
 package com.sun.devtest.admin.synchronization.api.security.client;
 
-import java.util.ArrayList;
-
-import java.io.Serializable;
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.ejb.*;
 import javax.rmi.PortableRemoteObject;
-import java.rmi.NoSuchObjectException;
 import java.util.Properties;
 
 import com.sun.devtest.admin.synchronization.api.security.shopping.*;
diff --git a/appserver/tests/v2-tests/appserv-tests/devtests/ee/admin/synchronization/cleaner/application/descriptor/ejb-jar.xml b/appserver/tests/v2-tests/appserv-tests/devtests/ee/admin/synchronization/cleaner/application/descriptor/ejb-jar.xml
index c29c587..791981f 100644
--- a/appserver/tests/v2-tests/appserv-tests/devtests/ee/admin/synchronization/cleaner/application/descriptor/ejb-jar.xml
+++ b/appserver/tests/v2-tests/appserv-tests/devtests/ee/admin/synchronization/cleaner/application/descriptor/ejb-jar.xml
@@ -51,7 +51,7 @@
       </resource-ref>
       <resource-ref>
         <res-ref-name>jmsRes</res-ref-name>
-        <res-type>javax.jms.QueueConnectionFactory</res-type>
+        <res-type>jakarta.jms.QueueConnectionFactory</res-type>
         <res-auth>Container</res-auth>
         <res-sharing-scope>Shareable</res-sharing-scope>
       </resource-ref>
diff --git a/appserver/tests/v2-tests/appserv-tests/devtests/embedded/config/properties-web.xml b/appserver/tests/v2-tests/appserv-tests/devtests/embedded/config/properties-web.xml
index 6538ac4..1e05bbd 100644
--- a/appserver/tests/v2-tests/appserv-tests/devtests/embedded/config/properties-web.xml
+++ b/appserver/tests/v2-tests/appserv-tests/devtests/embedded/config/properties-web.xml
@@ -1,6 +1,6 @@
 <!--
 
-    Copyright (c) 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2018, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -55,9 +55,9 @@
     <property name="dest.type" value="queue"/>
     <property name="dest.name" value="Queue"/>
     <property name="jms.factory.name" value="jms/QCFactory"/>
-    <property name="jms.factory.type" value="javax.jms.QueueConnectionFactory"/>
+    <property name="jms.factory.type" value="jakarta.jms.QueueConnectionFactory"/>
     <property name="jms.resource.name" value="jms/SampleQueue"/>
-    <property name="jms.resource.type" value="javax.jms.Queue"/>
+    <property name="jms.resource.type" value="jakarta.jms.Queue"/>
 
     <property name="jdbc.conpool.name" value="ql-jdbc-pool"/>
     <property name="jdbc.resource.name" value="jdbc/s1qeDB"/>
diff --git a/appserver/tests/v2-tests/appserv-tests/devtests/embedded/config/properties.xml b/appserver/tests/v2-tests/appserv-tests/devtests/embedded/config/properties.xml
index a136830..ccb093f 100644
--- a/appserver/tests/v2-tests/appserv-tests/devtests/embedded/config/properties.xml
+++ b/appserver/tests/v2-tests/appserv-tests/devtests/embedded/config/properties.xml
@@ -1,6 +1,6 @@
 <!--
 
-    Copyright (c) 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2018, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -55,9 +55,9 @@
     <property name="dest.type" value="queue"/>
     <property name="dest.name" value="Queue"/>
     <property name="jms.factory.name" value="jms/QCFactory"/>
-    <property name="jms.factory.type" value="javax.jms.QueueConnectionFactory"/>
+    <property name="jms.factory.type" value="jakarta.jms.QueueConnectionFactory"/>
     <property name="jms.resource.name" value="jms/SampleQueue"/>
-    <property name="jms.resource.type" value="javax.jms.Queue"/>
+    <property name="jms.resource.type" value="jakarta.jms.Queue"/>
 
     <property name="jdbc.conpool.name" value="ql-jdbc-pool"/>
     <property name="jdbc.resource.name" value="jdbc/s1qeDB"/>
diff --git a/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jms-txlookup/create_resources.asadmin b/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jms-txlookup/create_resources.asadmin
index fbc8f79..d8a9575 100644
--- a/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jms-txlookup/create_resources.asadmin
+++ b/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jms-txlookup/create_resources.asadmin
@@ -1,13 +1,13 @@
-create-jms-resource --resourcetype javax.jms.QueueConnectionFactory jms/jms_msgdest_jmsweb_QCF
+create-jms-resource --resourcetype jakarta.jms.QueueConnectionFactory jms/jms_msgdest_jmsweb_QCF
 
 create-jmsdest --desttype queue jms_msgdest_jmsweb_ServletQueue 
-create-jms-resource --resourcetype javax.jms.Queue --property imqDestinationName=jms_msgdest_jmsweb_ServletQueue jms/jms_msgdest_jmsweb_ServletQueue
+create-jms-resource --resourcetype jakarta.jms.Queue --property imqDestinationName=jms_msgdest_jmsweb_ServletQueue jms/jms_msgdest_jmsweb_ServletQueue
 
 
 create-jmsdest --desttype queue jms_msgdest_jmsweb_mdbQueue 
-create-jms-resource --resourcetype javax.jms.Queue --property imqDestinationName=jms_msgdest_jmsweb_mdbQueue jms/jms_msgdest_jmsweb_mdbQueue
+create-jms-resource --resourcetype jakarta.jms.Queue --property imqDestinationName=jms_msgdest_jmsweb_mdbQueue jms/jms_msgdest_jmsweb_mdbQueue
 
 create-jmsdest --desttype queue jms_msgdest_jmsweb_AppclientQueue 
-create-jms-resource --resourcetype javax.jms.Queue --property imqDestinationName=jms_msgdest_jmsweb_AppclientQueue jms/jms_msgdest_jmsweb_AppclientQueue 
+create-jms-resource --resourcetype jakarta.jms.Queue --property imqDestinationName=jms_msgdest_jmsweb_AppclientQueue jms/jms_msgdest_jmsweb_AppclientQueue 
 
 quit
diff --git a/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jms-txlookup/servlet/JmsServlet.java b/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jms-txlookup/servlet/JmsServlet.java
index ace6556..1e6aa0c 100644
--- a/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jms-txlookup/servlet/JmsServlet.java
+++ b/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jms-txlookup/servlet/JmsServlet.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2002, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2002, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -23,7 +23,7 @@
 import javax.naming.*;
 import java.sql.*;
 import javax.sql.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.transaction.*;
 import javax.transaction.xa.*;
 
diff --git a/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jms1/simple/build.xml b/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jms1/simple/build.xml
index e78ef2e..51e747a 100644
--- a/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jms1/simple/build.xml
+++ b/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jms1/simple/build.xml
@@ -2,7 +2,7 @@
 <!DOCTYPE project [
 <!--
 
-    Copyright (c) 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2018, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -61,17 +61,17 @@
         <param name="dest.name" value="SampleQueue"/>
         <param name="dest.type" value="queue"/>
         <param name="jms.resource.name" value="jms/SampleQueue"/>
-        <param name="jms.resource.type" value="javax.jms.Queue"/>
+        <param name="jms.resource.type" value="jakarta.jms.Queue"/>
         <param name="jms.factory.name" value="jms/QCFactory"/>
-        <param name="jms.factory.type" value="javax.jms.QueueConnectionFactory"/>
+        <param name="jms.factory.type" value="jakarta.jms.QueueConnectionFactory"/>
         </antcall>
         <antcall target="deploy-jms-common">
         <param name="dest.name" value="SampleTopic"/>
         <param name="dest.type" value="topic"/>
         <param name="jms.resource.name" value="jms/SampleTopic"/>
-        <param name="jms.resource.type" value="javax.jms.Topic"/>
+        <param name="jms.resource.type" value="jakarta.jms.Topic"/>
         <param name="jms.factory.name" value="jms/TCFactory"/>
-        <param name="jms.factory.type" value="javax.jms.TopicConnectionFactory"/>
+        <param name="jms.factory.type" value="jakarta.jms.TopicConnectionFactory"/>
         </antcall>
     </target>
 
@@ -93,17 +93,17 @@
         <param name="dest.name" value="SampleQueue"/>
         <param name="dest.type" value="queue"/>
         <param name="jms.resource.name" value="jms/SampleQueue"/>
-        <param name="jms.resource.type" value="javax.jms.Queue"/>
+        <param name="jms.resource.type" value="jakarta.jms.Queue"/>
         <param name="jms.factory.name" value="jms/QCFactory"/>
-        <param name="jms.factory.type" value="javax.jms.QueueConnectionFactory"/>
+        <param name="jms.factory.type" value="jakarta.jms.QueueConnectionFactory"/>
         </antcall>
         <antcall target="undeploy-jms-common">
         <param name="dest.name" value="SampleTopic"/>
         <param name="dest.type" value="topic"/>
         <param name="jms.resource.name" value="jms/SampleTopic"/>
-        <param name="jms.resource.type" value="javax.jms.Topic"/>
+        <param name="jms.resource.type" value="jakarta.jms.Topic"/>
         <param name="jms.factory.name" value="jms/TCFactory"/>
-        <param name="jms.factory.type" value="javax.jms.TopicConnectionFactory"/>
+        <param name="jms.factory.type" value="jakarta.jms.TopicConnectionFactory"/>
         </antcall>
     </target>
 
diff --git a/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jms1/simple/client/SimpleMessageClient.java b/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jms1/simple/client/SimpleMessageClient.java
index 224011e..7482436 100644
--- a/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jms1/simple/client/SimpleMessageClient.java
+++ b/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jms1/simple/client/SimpleMessageClient.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,7 +16,7 @@
 
 package com.sun.s1peqe.ejb.mdb.simple.client;
 
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.naming.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jms1/simple/descriptor/application-client.xml b/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jms1/simple/descriptor/application-client.xml
index 7166990..359dff1 100644
--- a/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jms1/simple/descriptor/application-client.xml
+++ b/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jms1/simple/descriptor/application-client.xml
@@ -2,7 +2,7 @@
 <!DOCTYPE application-client PUBLIC '-//Sun Microsystems, Inc.//DTD J2EE Application Client 1.3//EN' 'http://java.sun.com/dtd/application-client_1_3.dtd'>
 <!--
 
-    Copyright (c) 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2018, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -22,22 +22,22 @@
   <display-name>ejb-mdb-simpleClient</display-name>
   <resource-ref>
     <res-ref-name>jms/QCFactory</res-ref-name>
-    <res-type>javax.jms.QueueConnectionFactory</res-type>
+    <res-type>jakarta.jms.QueueConnectionFactory</res-type>
     <res-auth>Container</res-auth>
     <res-sharing-scope>Shareable</res-sharing-scope>
   </resource-ref>
   <resource-ref>
     <res-ref-name>jms/TCFactory</res-ref-name>
-    <res-type>javax.jms.TopicConnectionFactory</res-type>
+    <res-type>jakarta.jms.TopicConnectionFactory</res-type>
     <res-auth>Container</res-auth>
     <res-sharing-scope>Shareable</res-sharing-scope>
   </resource-ref>
   <resource-env-ref>
     <resource-env-ref-name>jms/SampleQueue</resource-env-ref-name>
-    <resource-env-ref-type>javax.jms.Queue</resource-env-ref-type>
+    <resource-env-ref-type>jakarta.jms.Queue</resource-env-ref-type>
   </resource-env-ref>
   <resource-env-ref>
     <resource-env-ref-name>jms/SampleTopic</resource-env-ref-name>
-    <resource-env-ref-type>javax.jms.Topic</resource-env-ref-type>
+    <resource-env-ref-type>jakarta.jms.Topic</resource-env-ref-type>
   </resource-env-ref>
 </application-client>
diff --git a/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jms1/simple/descriptor/ejb-jar.xml b/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jms1/simple/descriptor/ejb-jar.xml
index 1315119..1f77fe8 100644
--- a/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jms1/simple/descriptor/ejb-jar.xml
+++ b/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jms1/simple/descriptor/ejb-jar.xml
@@ -2,7 +2,7 @@
 <!DOCTYPE ejb-jar PUBLIC '-//Sun Microsystems, Inc.//DTD Enterprise JavaBeans 2.0//EN' 'http://java.sun.com/dtd/ejb-jar_2_0.dtd'>
 <!--
 
-    Copyright (c) 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2018, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -28,28 +28,28 @@
       <transaction-type>Container</transaction-type>
       <acknowledge-mode>Auto-acknowledge</acknowledge-mode>
       <message-driven-destination>
-        <destination-type>javax.jms.Queue</destination-type>
+        <destination-type>jakarta.jms.Queue</destination-type>
         <!--<subscription-durability>Durable</subscription-durability>-->
       </message-driven-destination>
      <resource-ref>
     <res-ref-name>jms/QCFactory</res-ref-name>
-    <res-type>javax.jms.QueueConnectionFactory</res-type>
+    <res-type>jakarta.jms.QueueConnectionFactory</res-type>
     <res-auth>Container</res-auth>
     <res-sharing-scope>Shareable</res-sharing-scope>
   </resource-ref>
   <resource-ref>
     <res-ref-name>jms/TCFactory</res-ref-name>
-    <res-type>javax.jms.TopicConnectionFactory</res-type>
+    <res-type>jakarta.jms.TopicConnectionFactory</res-type>
     <res-auth>Container</res-auth>
     <res-sharing-scope>Shareable</res-sharing-scope>
   </resource-ref>
   <resource-env-ref>
     <resource-env-ref-name>jms/SampleQueue</resource-env-ref-name>
-    <resource-env-ref-type>javax.jms.Queue</resource-env-ref-type>
+    <resource-env-ref-type>jakarta.jms.Queue</resource-env-ref-type>
   </resource-env-ref>
   <resource-env-ref>
     <resource-env-ref-name>jms/SampleTopic</resource-env-ref-name>
-    <resource-env-ref-type>javax.jms.Topic</resource-env-ref-type>
+    <resource-env-ref-type>jakarta.jms.Topic</resource-env-ref-type>
   </resource-env-ref>
     </message-driven>
   </enterprise-beans>
diff --git a/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jms1/simple/ejb/SimpleMessageBean.java b/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jms1/simple/ejb/SimpleMessageBean.java
index 2e56422..c5557bc 100644
--- a/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jms1/simple/ejb/SimpleMessageBean.java
+++ b/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jms1/simple/ejb/SimpleMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,14 +16,10 @@
 
 package com.sun.s1peqe.ejb.mdb.simple.ejb;
 
-import java.io.Serializable;
-import java.rmi.RemoteException;
-import javax.ejb.EJBException;
 import javax.ejb.MessageDrivenBean;
 import javax.ejb.MessageDrivenContext;
-import javax.ejb.CreateException;
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import java.util.*;
 
 public class SimpleMessageBean implements MessageDrivenBean,
diff --git a/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jms2/simple/build.xml b/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jms2/simple/build.xml
index 2952d56..2842772 100644
--- a/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jms2/simple/build.xml
+++ b/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jms2/simple/build.xml
@@ -2,7 +2,7 @@
 <!DOCTYPE project [
 <!--
 
-    Copyright (c) 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2018, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -56,9 +56,9 @@
         <param name="dest.name" value="SampleQueue"/>
         <param name="dest.type" value="queue"/>
         <param name="jms.resource.name" value="jms/SampleQueue"/>
-        <param name="jms.resource.type" value="javax.jms.Queue"/>
+        <param name="jms.resource.type" value="jakarta.jms.Queue"/>
         <param name="jms.factory.name" value="jms/QCFactory"/>
-        <param name="jms.factory.type" value="javax.jms.QueueConnectionFactory"/>
+        <param name="jms.factory.type" value="jakarta.jms.QueueConnectionFactory"/>
         </antcall>
     </target>
 
@@ -80,9 +80,9 @@
         <param name="dest.name" value="SampleQueue"/>
         <param name="dest.type" value="queue"/>
         <param name="jms.resource.name" value="jms/SampleQueue"/>
-        <param name="jms.resource.type" value="javax.jms.Queue"/>
+        <param name="jms.resource.type" value="jakarta.jms.Queue"/>
         <param name="jms.factory.name" value="jms/QCFactory"/>
-        <param name="jms.factory.type" value="javax.jms.QueueConnectionFactory"/>
+        <param name="jms.factory.type" value="jakarta.jms.QueueConnectionFactory"/>
         </antcall>
     </target>
 
diff --git a/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jms2/simple/client/SimpleMessageClient.java b/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jms2/simple/client/SimpleMessageClient.java
index 7a0ea06..1a8d6db 100644
--- a/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jms2/simple/client/SimpleMessageClient.java
+++ b/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jms2/simple/client/SimpleMessageClient.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,7 +16,7 @@
 
 package com.sun.s1peqe.ejb.mdb.simple.client;
 
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.naming.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jms2/simple/descriptor/application-client.xml b/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jms2/simple/descriptor/application-client.xml
index 1fccea2..eadf83d 100644
--- a/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jms2/simple/descriptor/application-client.xml
+++ b/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jms2/simple/descriptor/application-client.xml
@@ -2,7 +2,7 @@
 <!DOCTYPE application-client PUBLIC '-//Sun Microsystems, Inc.//DTD J2EE Application Client 1.3//EN' 'http://java.sun.com/dtd/application-client_1_3.dtd'>
 <!--
 
-    Copyright (c) 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2018, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -22,12 +22,12 @@
   <display-name>ejb-mdb-simpleClient</display-name>
   <resource-ref>
     <res-ref-name>jms/QCFactory</res-ref-name>
-    <res-type>javax.jms.QueueConnectionFactory</res-type>
+    <res-type>jakarta.jms.QueueConnectionFactory</res-type>
     <res-auth>Container</res-auth>
     <res-sharing-scope>Shareable</res-sharing-scope>
   </resource-ref>
   <resource-env-ref>
     <resource-env-ref-name>jms/SampleQueue</resource-env-ref-name>
-    <resource-env-ref-type>javax.jms.Queue</resource-env-ref-type>
+    <resource-env-ref-type>jakarta.jms.Queue</resource-env-ref-type>
   </resource-env-ref>
 </application-client>
diff --git a/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jms3/simple/client/SimpleMessageClient.java b/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jms3/simple/client/SimpleMessageClient.java
index 2561998..238d611 100644
--- a/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jms3/simple/client/SimpleMessageClient.java
+++ b/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jms3/simple/client/SimpleMessageClient.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,7 +16,7 @@
 
 package com.sun.s1peqe.ejb.mdb.simple.client;
 
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.naming.*;
 import com.sun.messaging.Queue;
 import com.sun.messaging.QueueConnectionFactory;
diff --git a/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jmsweb/create_resources.asadmin b/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jmsweb/create_resources.asadmin
index fbc8f79..d8a9575 100644
--- a/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jmsweb/create_resources.asadmin
+++ b/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jmsweb/create_resources.asadmin
@@ -1,13 +1,13 @@
-create-jms-resource --resourcetype javax.jms.QueueConnectionFactory jms/jms_msgdest_jmsweb_QCF
+create-jms-resource --resourcetype jakarta.jms.QueueConnectionFactory jms/jms_msgdest_jmsweb_QCF
 
 create-jmsdest --desttype queue jms_msgdest_jmsweb_ServletQueue 
-create-jms-resource --resourcetype javax.jms.Queue --property imqDestinationName=jms_msgdest_jmsweb_ServletQueue jms/jms_msgdest_jmsweb_ServletQueue
+create-jms-resource --resourcetype jakarta.jms.Queue --property imqDestinationName=jms_msgdest_jmsweb_ServletQueue jms/jms_msgdest_jmsweb_ServletQueue
 
 
 create-jmsdest --desttype queue jms_msgdest_jmsweb_mdbQueue 
-create-jms-resource --resourcetype javax.jms.Queue --property imqDestinationName=jms_msgdest_jmsweb_mdbQueue jms/jms_msgdest_jmsweb_mdbQueue
+create-jms-resource --resourcetype jakarta.jms.Queue --property imqDestinationName=jms_msgdest_jmsweb_mdbQueue jms/jms_msgdest_jmsweb_mdbQueue
 
 create-jmsdest --desttype queue jms_msgdest_jmsweb_AppclientQueue 
-create-jms-resource --resourcetype javax.jms.Queue --property imqDestinationName=jms_msgdest_jmsweb_AppclientQueue jms/jms_msgdest_jmsweb_AppclientQueue 
+create-jms-resource --resourcetype jakarta.jms.Queue --property imqDestinationName=jms_msgdest_jmsweb_AppclientQueue jms/jms_msgdest_jmsweb_AppclientQueue 
 
 quit
diff --git a/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jmsweb/descriptor/web.xml b/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jmsweb/descriptor/web.xml
index 7c27c45..8193d80 100644
--- a/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jmsweb/descriptor/web.xml
+++ b/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jmsweb/descriptor/web.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2018, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -33,13 +33,13 @@
   <resource-ref>
      <description>description</description>
      <res-ref-name>jms/MyQueueConnectionFactory</res-ref-name>
-     <res-type>javax.jms.QueueConnectionFactory</res-type>
+     <res-type>jakarta.jms.QueueConnectionFactory</res-type>
      <res-auth>Container</res-auth>
      <res-sharing-scope>Shareable</res-sharing-scope> 
   </resource-ref>
   <resource-env-ref>
      <resource-env-ref-name>jms/MyQueue</resource-env-ref-name>
-     <resource-env-ref-type>javax.jms.Queue</resource-env-ref-type>
+     <resource-env-ref-type>jakarta.jms.Queue</resource-env-ref-type>
   </resource-env-ref>
 </web-app>
 
diff --git a/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jmsweb/servlet/JmsServlet.java b/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jmsweb/servlet/JmsServlet.java
index 42f9a2e..3be067d 100644
--- a/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jmsweb/servlet/JmsServlet.java
+++ b/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/jmsweb/servlet/JmsServlet.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2002, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2002, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -23,7 +23,7 @@
 import javax.naming.*;
 import java.sql.*;
 import javax.sql.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.transaction.*;
 
 public class JmsServlet extends HttpServlet {
diff --git a/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/timer/client/Client.java b/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/timer/client/Client.java
index 678984d..724c6a6 100644
--- a/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/timer/client/Client.java
+++ b/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/timer/client/Client.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,12 +16,10 @@
 
 package com.sun.s1asdev.ejb.timer.restore.client;
 
-import java.io.Serializable;
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.ejb.*;
 import javax.rmi.PortableRemoteObject;
-import java.rmi.NoSuchObjectException;
 import java.util.HashSet;
 import java.util.Set;
 import com.sun.s1asdev.ejb.timer.restore.TimerSession;
diff --git a/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/timer/create_resources.asadmin b/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/timer/create_resources.asadmin
index 730d4db..1e533f7 100644
--- a/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/timer/create_resources.asadmin
+++ b/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/timer/create_resources.asadmin
@@ -1,7 +1,7 @@
-create-jms-resource --restype javax.jms.QueueConnectionFactory jms/ejb_timer_restore_TQCF
+create-jms-resource --restype jakarta.jms.QueueConnectionFactory jms/ejb_timer_restore_TQCF
 
 create-jmsdest --desttype queue ejb_timer_restore_TQueue
-create-jms-resource --restype javax.jms.Queue --property imqDestinationName=ejb_timer_restore_TQueue jms/ejb_timer_restore_TQueue
+create-jms-resource --restype jakarta.jms.Queue --property imqDestinationName=ejb_timer_restore_TQueue jms/ejb_timer_restore_TQueue
 
 
 quit
diff --git a/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/timer/descriptor/application-client.xml b/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/timer/descriptor/application-client.xml
index cb52dbb..527fc37 100644
--- a/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/timer/descriptor/application-client.xml
+++ b/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/timer/descriptor/application-client.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2018, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -29,12 +29,12 @@
   <resource-ref>
     <description>description</description>
     <res-ref-name>jms/MyQueueConnectionFactory</res-ref-name>
-    <res-type>javax.jms.QueueConnectionFactory</res-type>
+    <res-type>jakarta.jms.QueueConnectionFactory</res-type>
     <res-auth>Container</res-auth>
     <res-sharing-scope>Shareable</res-sharing-scope>
   </resource-ref>
   <resource-env-ref>
     <resource-env-ref-name>jms/MyQueue</resource-env-ref-name>
-    <resource-env-ref-type>javax.jms.Queue</resource-env-ref-type>
+    <resource-env-ref-type>jakarta.jms.Queue</resource-env-ref-type>
   </resource-env-ref>
 </application-client>
diff --git a/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/timer/descriptor/ejb-jar.xml b/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/timer/descriptor/ejb-jar.xml
index 0d0f2ff..db85c21 100644
--- a/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/timer/descriptor/ejb-jar.xml
+++ b/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/timer/descriptor/ejb-jar.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2018, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -30,13 +30,13 @@
       <resource-ref>
         <description>description</description>
         <res-ref-name>jms/MyQueueConnectionFactory</res-ref-name>
-        <res-type>javax.jms.QueueConnectionFactory</res-type>
+        <res-type>jakarta.jms.QueueConnectionFactory</res-type>
         <res-auth>Container</res-auth>
         <res-sharing-scope>Shareable</res-sharing-scope>
       </resource-ref>
       <resource-env-ref>
          <resource-env-ref-name>jms/MyQueue</resource-env-ref-name>
-         <resource-env-ref-type>javax.jms.Queue</resource-env-ref-type>
+         <resource-env-ref-type>jakarta.jms.Queue</resource-env-ref-type>
       </resource-env-ref>
       <security-identity>
         <use-caller-identity/>
diff --git a/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/timer/ejb/TimerSessionEJB.java b/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/timer/ejb/TimerSessionEJB.java
index 2456888..f1b8aa3 100644
--- a/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/timer/ejb/TimerSessionEJB.java
+++ b/appserver/tests/v2-tests/appserv-tests/devtests/lazyInit/timer/ejb/TimerSessionEJB.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -17,7 +17,6 @@
 package com.sun.s1asdev.ejb.timer.restore;
 
 import java.util.Iterator;
-import java.util.Collection;
 import java.util.Date;
 
 import javax.ejb.TimedObject;
@@ -26,17 +25,16 @@
 import javax.ejb.TimerService;
 import javax.ejb.SessionBean;
 import javax.ejb.SessionContext;
-import javax.ejb.EJBContext;
 import javax.ejb.EJBException;
-import javax.jms.Session;
+import jakarta.jms.Session;
 import java.rmi.RemoteException;
-import javax.jms.QueueConnectionFactory;
-import javax.jms.QueueConnection;
-import javax.jms.Queue;
-import javax.jms.QueueSender;
-import javax.jms.QueueSession;
-import javax.jms.JMSException;
-import javax.jms.TextMessage;
+import jakarta.jms.QueueConnectionFactory;
+import jakarta.jms.QueueConnection;
+import jakarta.jms.Queue;
+import jakarta.jms.QueueSender;
+import jakarta.jms.QueueSession;
+import jakarta.jms.JMSException;
+import jakarta.jms.TextMessage;
 import javax.naming.*;
 
 import com.sun.ejb.containers.TimerBean;
diff --git a/appserver/tests/v2-tests/appserv-tests/devtestsNG/properties.xml b/appserver/tests/v2-tests/appserv-tests/devtestsNG/properties.xml
index ef92d73..d067039 100644
--- a/appserver/tests/v2-tests/appserv-tests/devtestsNG/properties.xml
+++ b/appserver/tests/v2-tests/appserv-tests/devtestsNG/properties.xml
@@ -1,6 +1,6 @@
 <!--
 
-    Copyright (c) 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2018, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -70,9 +70,9 @@
     <property name="dest.type" value="queue"/>
     <property name="dest.name" value="Queue"/>
     <property name="jms.factory.name" value="jms/QCFactory"/>
-    <property name="jms.factory.type" value="javax.jms.QueueConnectionFactory"/>
+    <property name="jms.factory.type" value="jakarta.jms.QueueConnectionFactory"/>
     <property name="jms.resource.name" value="jms/SampleQueue"/>
-    <property name="jms.resource.type" value="javax.jms.Queue"/>
+    <property name="jms.resource.type" value="jakarta.jms.Queue"/>
 
     <property name="jdbc.conpool.name" value="ql-jdbc-pool"/>
     <property name="jdbc.resource.name" value="jdbc/s1qeDB"/>
diff --git a/appserver/tests/v2-tests/appserv-tests/sqetests/ejb/mdb/simple/build-ng.xml b/appserver/tests/v2-tests/appserv-tests/sqetests/ejb/mdb/simple/build-ng.xml
index dc2c41d..7bb4382 100644
--- a/appserver/tests/v2-tests/appserv-tests/sqetests/ejb/mdb/simple/build-ng.xml
+++ b/appserver/tests/v2-tests/appserv-tests/sqetests/ejb/mdb/simple/build-ng.xml
@@ -2,7 +2,7 @@
 <!DOCTYPE project [
 <!--
 
-    Copyright (c) 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2018, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -59,17 +59,17 @@
         <param name="dest.name" value="SampleQueue"/>
         <param name="dest.type" value="queue"/>
         <param name="jms.resource.name" value="jms/SampleQueue"/>
-        <param name="jms.resource.type" value="javax.jms.Queue"/>
+        <param name="jms.resource.type" value="jakarta.jms.Queue"/>
         <param name="jms.factory.name" value="jms/QCFactory"/>
-        <param name="jms.factory.type" value="javax.jms.QueueConnectionFactory"/>
+        <param name="jms.factory.type" value="jakarta.jms.QueueConnectionFactory"/>
         </antcall>
         <antcall target="deploy-jms-common">
         <param name="dest.name" value="SampleTopic"/>
         <param name="dest.type" value="topic"/>
         <param name="jms.resource.name" value="jms/SampleTopic"/>
-        <param name="jms.resource.type" value="javax.jms.Topic"/>
+        <param name="jms.resource.type" value="jakarta.jms.Topic"/>
         <param name="jms.factory.name" value="jms/TCFactory"/>
-        <param name="jms.factory.type" value="javax.jms.TopicConnectionFactory"/>
+        <param name="jms.factory.type" value="jakarta.jms.TopicConnectionFactory"/>
         </antcall>
     </target>
 
@@ -93,17 +93,17 @@
         <param name="dest.name" value="SampleQueue"/>
         <param name="dest.type" value="queue"/>
         <param name="jms.resource.name" value="jms/SampleQueue"/>
-        <param name="jms.resource.type" value="javax.jms.Queue"/>
+        <param name="jms.resource.type" value="jakarta.jms.Queue"/>
         <param name="jms.factory.name" value="jms/QCFactory"/>
-        <param name="jms.factory.type" value="javax.jms.QueueConnectionFactory"/>
+        <param name="jms.factory.type" value="jakarta.jms.QueueConnectionFactory"/>
         </antcall>
         <antcall target="undeploy-jms-common">
         <param name="dest.name" value="SampleTopic"/>
         <param name="dest.type" value="topic"/>
         <param name="jms.resource.name" value="jms/SampleTopic"/>
-        <param name="jms.resource.type" value="javax.jms.Topic"/>
+        <param name="jms.resource.type" value="jakarta.jms.Topic"/>
         <param name="jms.factory.name" value="jms/TCFactory"/>
-        <param name="jms.factory.type" value="javax.jms.TopicConnectionFactory"/>
+        <param name="jms.factory.type" value="jakarta.jms.TopicConnectionFactory"/>
         </antcall>
     </target>
 
diff --git a/appserver/tests/v2-tests/appserv-tests/sqetests/ejb/mdb/simple/build.xml b/appserver/tests/v2-tests/appserv-tests/sqetests/ejb/mdb/simple/build.xml
index 43931b7..59a2c5f 100644
--- a/appserver/tests/v2-tests/appserv-tests/sqetests/ejb/mdb/simple/build.xml
+++ b/appserver/tests/v2-tests/appserv-tests/sqetests/ejb/mdb/simple/build.xml
@@ -2,7 +2,7 @@
 <!DOCTYPE project [
 <!--
 
-    Copyright (c) 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2018, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -59,17 +59,17 @@
         <param name="dest.name" value="SampleQueue"/>
         <param name="dest.type" value="queue"/>
         <param name="jms.resource.name" value="jms/SampleQueue"/>
-        <param name="jms.resource.type" value="javax.jms.Queue"/>
+        <param name="jms.resource.type" value="jakarta.jms.Queue"/>
         <param name="jms.factory.name" value="jms/QCFactory"/>
-        <param name="jms.factory.type" value="javax.jms.QueueConnectionFactory"/>
+        <param name="jms.factory.type" value="jakarta.jms.QueueConnectionFactory"/>
         </antcall>
         <antcall target="deploy-jms-common">
         <param name="dest.name" value="SampleTopic"/>
         <param name="dest.type" value="topic"/>
         <param name="jms.resource.name" value="jms/SampleTopic"/>
-        <param name="jms.resource.type" value="javax.jms.Topic"/>
+        <param name="jms.resource.type" value="jakarta.jms.Topic"/>
         <param name="jms.factory.name" value="jms/TCFactory"/>
-        <param name="jms.factory.type" value="javax.jms.TopicConnectionFactory"/>
+        <param name="jms.factory.type" value="jakarta.jms.TopicConnectionFactory"/>
         </antcall>
     </target>
 
@@ -90,17 +90,17 @@
         <param name="dest.name" value="SampleQueue"/>
         <param name="dest.type" value="queue"/>
         <param name="jms.resource.name" value="jms/SampleQueue"/>
-        <param name="jms.resource.type" value="javax.jms.Queue"/>
+        <param name="jms.resource.type" value="jakarta.jms.Queue"/>
         <param name="jms.factory.name" value="jms/QCFactory"/>
-        <param name="jms.factory.type" value="javax.jms.QueueConnectionFactory"/>
+        <param name="jms.factory.type" value="jakarta.jms.QueueConnectionFactory"/>
         </antcall>
         <antcall target="undeploy-jms-common">
         <param name="dest.name" value="SampleTopic"/>
         <param name="dest.type" value="topic"/>
         <param name="jms.resource.name" value="jms/SampleTopic"/>
-        <param name="jms.resource.type" value="javax.jms.Topic"/>
+        <param name="jms.resource.type" value="jakarta.jms.Topic"/>
         <param name="jms.factory.name" value="jms/TCFactory"/>
-        <param name="jms.factory.type" value="javax.jms.TopicConnectionFactory"/>
+        <param name="jms.factory.type" value="jakarta.jms.TopicConnectionFactory"/>
         </antcall>
     </target>
 
diff --git a/appserver/tests/v2-tests/appserv-tests/sqetests/ejb/mdb/simple/client/SimpleMessageClient.java b/appserver/tests/v2-tests/appserv-tests/sqetests/ejb/mdb/simple/client/SimpleMessageClient.java
index 224011e..7482436 100644
--- a/appserver/tests/v2-tests/appserv-tests/sqetests/ejb/mdb/simple/client/SimpleMessageClient.java
+++ b/appserver/tests/v2-tests/appserv-tests/sqetests/ejb/mdb/simple/client/SimpleMessageClient.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,7 +16,7 @@
 
 package com.sun.s1peqe.ejb.mdb.simple.client;
 
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.naming.*;
 import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;
 
diff --git a/appserver/tests/v2-tests/appserv-tests/sqetests/ejb/mdb/simple/descriptor/application-client.xml b/appserver/tests/v2-tests/appserv-tests/sqetests/ejb/mdb/simple/descriptor/application-client.xml
index 7166990..359dff1 100644
--- a/appserver/tests/v2-tests/appserv-tests/sqetests/ejb/mdb/simple/descriptor/application-client.xml
+++ b/appserver/tests/v2-tests/appserv-tests/sqetests/ejb/mdb/simple/descriptor/application-client.xml
@@ -2,7 +2,7 @@
 <!DOCTYPE application-client PUBLIC '-//Sun Microsystems, Inc.//DTD J2EE Application Client 1.3//EN' 'http://java.sun.com/dtd/application-client_1_3.dtd'>
 <!--
 
-    Copyright (c) 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2018, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -22,22 +22,22 @@
   <display-name>ejb-mdb-simpleClient</display-name>
   <resource-ref>
     <res-ref-name>jms/QCFactory</res-ref-name>
-    <res-type>javax.jms.QueueConnectionFactory</res-type>
+    <res-type>jakarta.jms.QueueConnectionFactory</res-type>
     <res-auth>Container</res-auth>
     <res-sharing-scope>Shareable</res-sharing-scope>
   </resource-ref>
   <resource-ref>
     <res-ref-name>jms/TCFactory</res-ref-name>
-    <res-type>javax.jms.TopicConnectionFactory</res-type>
+    <res-type>jakarta.jms.TopicConnectionFactory</res-type>
     <res-auth>Container</res-auth>
     <res-sharing-scope>Shareable</res-sharing-scope>
   </resource-ref>
   <resource-env-ref>
     <resource-env-ref-name>jms/SampleQueue</resource-env-ref-name>
-    <resource-env-ref-type>javax.jms.Queue</resource-env-ref-type>
+    <resource-env-ref-type>jakarta.jms.Queue</resource-env-ref-type>
   </resource-env-ref>
   <resource-env-ref>
     <resource-env-ref-name>jms/SampleTopic</resource-env-ref-name>
-    <resource-env-ref-type>javax.jms.Topic</resource-env-ref-type>
+    <resource-env-ref-type>jakarta.jms.Topic</resource-env-ref-type>
   </resource-env-ref>
 </application-client>
diff --git a/appserver/tests/v2-tests/appserv-tests/sqetests/ejb/mdb/simple/descriptor/ejb-jar.xml b/appserver/tests/v2-tests/appserv-tests/sqetests/ejb/mdb/simple/descriptor/ejb-jar.xml
index 1315119..1f77fe8 100644
--- a/appserver/tests/v2-tests/appserv-tests/sqetests/ejb/mdb/simple/descriptor/ejb-jar.xml
+++ b/appserver/tests/v2-tests/appserv-tests/sqetests/ejb/mdb/simple/descriptor/ejb-jar.xml
@@ -2,7 +2,7 @@
 <!DOCTYPE ejb-jar PUBLIC '-//Sun Microsystems, Inc.//DTD Enterprise JavaBeans 2.0//EN' 'http://java.sun.com/dtd/ejb-jar_2_0.dtd'>
 <!--
 
-    Copyright (c) 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2018, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -28,28 +28,28 @@
       <transaction-type>Container</transaction-type>
       <acknowledge-mode>Auto-acknowledge</acknowledge-mode>
       <message-driven-destination>
-        <destination-type>javax.jms.Queue</destination-type>
+        <destination-type>jakarta.jms.Queue</destination-type>
         <!--<subscription-durability>Durable</subscription-durability>-->
       </message-driven-destination>
      <resource-ref>
     <res-ref-name>jms/QCFactory</res-ref-name>
-    <res-type>javax.jms.QueueConnectionFactory</res-type>
+    <res-type>jakarta.jms.QueueConnectionFactory</res-type>
     <res-auth>Container</res-auth>
     <res-sharing-scope>Shareable</res-sharing-scope>
   </resource-ref>
   <resource-ref>
     <res-ref-name>jms/TCFactory</res-ref-name>
-    <res-type>javax.jms.TopicConnectionFactory</res-type>
+    <res-type>jakarta.jms.TopicConnectionFactory</res-type>
     <res-auth>Container</res-auth>
     <res-sharing-scope>Shareable</res-sharing-scope>
   </resource-ref>
   <resource-env-ref>
     <resource-env-ref-name>jms/SampleQueue</resource-env-ref-name>
-    <resource-env-ref-type>javax.jms.Queue</resource-env-ref-type>
+    <resource-env-ref-type>jakarta.jms.Queue</resource-env-ref-type>
   </resource-env-ref>
   <resource-env-ref>
     <resource-env-ref-name>jms/SampleTopic</resource-env-ref-name>
-    <resource-env-ref-type>javax.jms.Topic</resource-env-ref-type>
+    <resource-env-ref-type>jakarta.jms.Topic</resource-env-ref-type>
   </resource-env-ref>
     </message-driven>
   </enterprise-beans>
diff --git a/appserver/tests/v2-tests/appserv-tests/sqetests/ejb/mdb/simple/ejb/SimpleMessageBean.java b/appserver/tests/v2-tests/appserv-tests/sqetests/ejb/mdb/simple/ejb/SimpleMessageBean.java
index 2e56422..c5557bc 100644
--- a/appserver/tests/v2-tests/appserv-tests/sqetests/ejb/mdb/simple/ejb/SimpleMessageBean.java
+++ b/appserver/tests/v2-tests/appserv-tests/sqetests/ejb/mdb/simple/ejb/SimpleMessageBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,14 +16,10 @@
 
 package com.sun.s1peqe.ejb.mdb.simple.ejb;
 
-import java.io.Serializable;
-import java.rmi.RemoteException;
-import javax.ejb.EJBException;
 import javax.ejb.MessageDrivenBean;
 import javax.ejb.MessageDrivenContext;
-import javax.ejb.CreateException;
 import javax.naming.*;
-import javax.jms.*;
+import jakarta.jms.*;
 import java.util.*;
 
 public class SimpleMessageBean implements MessageDrivenBean,
diff --git a/appserver/tests/v2-tests/appserv-tests/sqetests/ejb/mdb/simple/testng-client/SimpleMessageClient.java b/appserver/tests/v2-tests/appserv-tests/sqetests/ejb/mdb/simple/testng-client/SimpleMessageClient.java
index a938003..3e4bfa5 100644
--- a/appserver/tests/v2-tests/appserv-tests/sqetests/ejb/mdb/simple/testng-client/SimpleMessageClient.java
+++ b/appserver/tests/v2-tests/appserv-tests/sqetests/ejb/mdb/simple/testng-client/SimpleMessageClient.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,7 +16,7 @@
 
 package com.sun.s1peqe.ejb.mdb.simple.client;
 
-import javax.jms.*;
+import jakarta.jms.*;
 import javax.naming.*;
 
 import org.testng.Assert;
diff --git a/appserver/tests/v2-tests/appserv-tests/sqetests/ejb/stateful/passivate/ejb/stateful/SessionBean.java b/appserver/tests/v2-tests/appserv-tests/sqetests/ejb/stateful/passivate/ejb/stateful/SessionBean.java
index 0553807..c8483d0 100644
--- a/appserver/tests/v2-tests/appserv-tests/sqetests/ejb/stateful/passivate/ejb/stateful/SessionBean.java
+++ b/appserver/tests/v2-tests/appserv-tests/sqetests/ejb/stateful/passivate/ejb/stateful/SessionBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -22,7 +22,7 @@
 import javax.rmi.*;
 import java.util.HashMap;
 import sqetests.ejb.stateful.passivate.util.*;
-import javax.jms.*;
+import jakarta.jms.*;
 
 
 /**
diff --git a/appserver/tests/v2-tests/appserv-tests/sqetests/security/integration/bankadmin/build.xml b/appserver/tests/v2-tests/appserv-tests/sqetests/security/integration/bankadmin/build.xml
index bc3ea85..bfbcedb 100755
--- a/appserver/tests/v2-tests/appserv-tests/sqetests/security/integration/bankadmin/build.xml
+++ b/appserver/tests/v2-tests/appserv-tests/sqetests/security/integration/bankadmin/build.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="ISO-8859-1"?>
 <!--
 
-    Copyright (c) 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2018, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -184,14 +184,14 @@
       <arg line="delete-jmsdest"/>	
       <arg line="${as.props}"/>
       <arg line="--instance ${appserver.instance.name}"/>
-      <arg line="--desttype javax.jms.Queue"/>
+      <arg line="--desttype jakarta.jms.Queue"/>
       <arg line="MyQueue"/>
     </exec>
     <exec executable="${ASADMIN}" failonerror="false">
       <arg line="delete-jmsdest"/>	
       <arg line="${as.props}"/>
       <arg line="--instance ${appserver.instance.name}"/>
-      <arg line="--desttype javax.jms.Queue"/>
+      <arg line="--desttype jakarta.jms.Queue"/>
       <arg line="adminQueue"/>
     </exec>  
   </target>
@@ -226,19 +226,19 @@
   <!-- Create all the required JMS resources using common target -->
   <target name="create-jmsresources" depends="init-common">
     <antcall target="deploy-jms-common">
-      <param name="jms.factory.type" value="javax.jms.QueueConnectionFactory"/>
+      <param name="jms.factory.type" value="jakarta.jms.QueueConnectionFactory"/>
       <param name="jms.factory.name" value="jms/QueueConnectionFactory"/>
       <param name="dest.type" value="queue" />
       <param name="dest.name" value="adminQueue"/>
-      <param name="jms.resource.type" value="javax.jms.Queue"/>
+      <param name="jms.resource.type" value="jakarta.jms.Queue"/>
       <param name="jms.resource.name" value="jms/adminQueue"/>
     </antcall>
     <antcall target="deploy-jms-common">
-      <param name="jms.factory.type" value="javax.jms.QueueConnectionFactory"/>
+      <param name="jms.factory.type" value="jakarta.jms.QueueConnectionFactory"/>
       <param name="jms.factory.name" value="jms/MyQueueConnectionFactory"/>
       <param name="dest.type" value="queue" />
       <param name="dest.name" value="MyQueue"/>
-      <param name="jms.resource.type" value="javax.jms.Queue"/>
+      <param name="jms.resource.type" value="jakarta.jms.Queue"/>
       <param name="jms.resource.name" value="jms/MyQueue"/>
     </antcall>
     
diff --git a/appserver/tests/v2-tests/appserv-tests/sqetests/transaction/txglobal/descriptor/ejb-jar.xml b/appserver/tests/v2-tests/appserv-tests/sqetests/transaction/txglobal/descriptor/ejb-jar.xml
index 67c7ecd..60347fd 100755
--- a/appserver/tests/v2-tests/appserv-tests/sqetests/transaction/txglobal/descriptor/ejb-jar.xml
+++ b/appserver/tests/v2-tests/appserv-tests/sqetests/transaction/txglobal/descriptor/ejb-jar.xml
@@ -2,7 +2,7 @@
 <!DOCTYPE ejb-jar PUBLIC "-//Sun Microsystems, Inc.//DTD Enterprise JavaBeans 2.0//EN" "http://java.sun.com/dtd/ejb-jar_2_0.dtd">
 <!--
 
-    Copyright (c) 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2018, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -64,13 +64,13 @@
       </resource-ref>
       <resource-ref>
         <res-ref-name>jms/QCFactory</res-ref-name>
-        <res-type>javax.jms.QueueConnectionFactory</res-type>
+        <res-type>jakarta.jms.QueueConnectionFactory</res-type>
         <res-auth>Container</res-auth>
         <res-sharing-scope>Shareable</res-sharing-scope>
       </resource-ref>
       <resource-env-ref>
         <resource-env-ref-name>jms/SampleQueue</resource-env-ref-name>
-        <resource-env-ref-type>javax.jms.Queue</resource-env-ref-type>
+        <resource-env-ref-type>jakarta.jms.Queue</resource-env-ref-type>
       </resource-env-ref>
     </session>
 
diff --git a/appserver/tests/v2-tests/appserv-tests/sqetests/transaction/txglobal/ejb/beanB/TxBeanB.java b/appserver/tests/v2-tests/appserv-tests/sqetests/transaction/txglobal/ejb/beanB/TxBeanB.java
index 74cf151..6876974 100755
--- a/appserver/tests/v2-tests/appserv-tests/sqetests/transaction/txglobal/ejb/beanB/TxBeanB.java
+++ b/appserver/tests/v2-tests/appserv-tests/sqetests/transaction/txglobal/ejb/beanB/TxBeanB.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -25,18 +25,17 @@
 import javax.sql.DataSource;
 import javax.naming.Context;
 import javax.naming.InitialContext;
-import java.util.Enumeration;
 import java.rmi.RemoteException;
 
-import javax.jms.Queue;
-import javax.jms.Message;
-import javax.jms.TextMessage;
-import javax.jms.QueueSender;
-import javax.jms.QueueSession;
-import javax.jms.JMSException;
-import javax.jms.QueueReceiver;
-import javax.jms.QueueConnection;
-import javax.jms.QueueConnectionFactory;
+import jakarta.jms.Queue;
+import jakarta.jms.Message;
+import jakarta.jms.TextMessage;
+import jakarta.jms.QueueSender;
+import jakarta.jms.QueueSession;
+import jakarta.jms.JMSException;
+import jakarta.jms.QueueReceiver;
+import jakarta.jms.QueueConnection;
+import jakarta.jms.QueueConnectionFactory;
 
 
 public class TxBeanB implements SessionBean {
diff --git a/appserver/verifier/verifier-impl/src/main/java/com/sun/enterprise/tools/verifier/tests/appclient/elements/AppClientResourceType.java b/appserver/verifier/verifier-impl/src/main/java/com/sun/enterprise/tools/verifier/tests/appclient/elements/AppClientResourceType.java
index dcc04e8..a9c7fdf 100644
--- a/appserver/verifier/verifier-impl/src/main/java/com/sun/enterprise/tools/verifier/tests/appclient/elements/AppClientResourceType.java
+++ b/appserver/verifier/verifier-impl/src/main/java/com/sun/enterprise/tools/verifier/tests/appclient/elements/AppClientResourceType.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -56,9 +56,9 @@
 		String resType = next.getType();
                 logger.log(Level.FINE, "servlet resType: " + resType);
 		if ((resType.equals("javax.sql.DataSource")) ||
-		    (resType.equals("javax.jms.QueueConnectionFactory")) ||
-		    (resType.equals("javax.jms.TopicConnectionFactory")) ||
-		    (resType.equals("javax.jms.ConnectionFactory")) ||
+		    (resType.equals("jakarta.jms.QueueConnectionFactory")) ||
+		    (resType.equals("jakarta.jms.TopicConnectionFactory")) ||
+		    (resType.equals("jakarta.jms.ConnectionFactory")) ||
 		    (resType.equals("javax.mail.Session")) ||
 		    (resType.equals("java.net.URL"))) {
 		    foundIt = true;
diff --git a/appserver/verifier/verifier-impl/src/main/java/com/sun/enterprise/tools/verifier/tests/dd/ParseDD.java b/appserver/verifier/verifier-impl/src/main/java/com/sun/enterprise/tools/verifier/tests/dd/ParseDD.java
index 11a43cb..a74591e 100644
--- a/appserver/verifier/verifier-impl/src/main/java/com/sun/enterprise/tools/verifier/tests/dd/ParseDD.java
+++ b/appserver/verifier/verifier-impl/src/main/java/com/sun/enterprise/tools/verifier/tests/dd/ParseDD.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -626,12 +626,12 @@
 		if (nodeList != null) {
 		    for (int i = 0; i < nodeList.getLength(); i++) {
 			String value = ((Text)nodeList.item(i).getFirstChild()).getNodeValue();
-			if (!value.equals("javax.jms.Queue")
-			    && !value.equals("javax.jms.Topic")) {
+			if (!value.equals("jakarta.jms.Queue")
+			    && !value.equals("jakarta.jms.Topic")) {
 			    result.failed
 				(smh.getLocalString
 				 (getClass().getName() + ".failedDestinationType",
-				  "[EJB] destination-type cannot be {0}. It has to be either javax.jms.Topic or javax.jms.Queue",
+				  "[EJB] destination-type cannot be {0}. It has to be either jakarta.jms.Topic or jakarta.jms.Queue",
 				  new Object[] {value}));
 			    oneFailed = true;
 			}
diff --git a/appserver/verifier/verifier-impl/src/main/java/com/sun/enterprise/tools/verifier/tests/ejb/messagebean/ImplementsMessageListener.java b/appserver/verifier/verifier-impl/src/main/java/com/sun/enterprise/tools/verifier/tests/ejb/messagebean/ImplementsMessageListener.java
index 7d0a0e2..a796029 100644
--- a/appserver/verifier/verifier-impl/src/main/java/com/sun/enterprise/tools/verifier/tests/ejb/messagebean/ImplementsMessageListener.java
+++ b/appserver/verifier/verifier-impl/src/main/java/com/sun/enterprise/tools/verifier/tests/ejb/messagebean/ImplementsMessageListener.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -43,7 +43,7 @@
 ComponentNameConstructor compName = getVerifierContext().getComponentNameConstructor();
         Class mbc = loadMessageBeanClass(descriptor, result);
         if (descriptor.getEjbBundleDescriptor().getSpecVersion().equals("2.0"))
-            testImplementationOf(mbc, javax.jms.MessageListener.class.getName(), result);
+            testImplementationOf(mbc, jakarta.jms.MessageListener.class.getName(), result);
         else
             testImplementationOf(mbc, descriptor.getMessageListenerType(), result);
         return result;
diff --git a/appserver/verifier/verifier-impl/src/main/java/com/sun/enterprise/tools/verifier/tests/ejb/runtime/resource/ASEjbRRefJndiName.java b/appserver/verifier/verifier-impl/src/main/java/com/sun/enterprise/tools/verifier/tests/ejb/runtime/resource/ASEjbRRefJndiName.java
index c69c239..cb8ecaa 100644
--- a/appserver/verifier/verifier-impl/src/main/java/com/sun/enterprise/tools/verifier/tests/ejb/runtime/resource/ASEjbRRefJndiName.java
+++ b/appserver/verifier/verifier-impl/src/main/java/com/sun/enterprise/tools/verifier/tests/ejb/runtime/resource/ASEjbRRefJndiName.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -73,7 +73,7 @@
                 }
                     /* else  //Fix for bug id 5018617
                     {
-                        if(type.indexOf("javax.jms")>-1) //jms resource
+                        if(type.indexOf("jakarta.jms")>-1) //jms resource
                         {
                             if(refJndiName.startsWith("jms/")) {
                                 addGoodDetails(result, compName);
diff --git a/appserver/verifier/verifier-impl/src/main/java/com/sun/enterprise/tools/verifier/tests/web/WebResourceType.java b/appserver/verifier/verifier-impl/src/main/java/com/sun/enterprise/tools/verifier/tests/web/WebResourceType.java
index 03e143e..246ee0f 100644
--- a/appserver/verifier/verifier-impl/src/main/java/com/sun/enterprise/tools/verifier/tests/web/WebResourceType.java
+++ b/appserver/verifier/verifier-impl/src/main/java/com/sun/enterprise/tools/verifier/tests/web/WebResourceType.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -54,8 +54,8 @@
 		String resType = next.getType();
 		logger.log(Level.FINE, "servlet resType: " + resType);
 		if ((resType.equals("javax.sql.DataSource")) ||
-		    (resType.equals("javax.jms.QueueConnectionFactory")) ||
-		    (resType.equals("javax.jms.TopicConnectionFactory")) ||
+		    (resType.equals("jakarta.jms.QueueConnectionFactory")) ||
+		    (resType.equals("jakarta.jms.TopicConnectionFactory")) ||
 		    (resType.equals("javax.mail.Session")) ||
 		    (resType.equals("java.net.URL"))) { 
 		    foundIt = true;
diff --git a/appserver/verifier/verifier-impl/src/main/resources/com/sun/enterprise/tools/verifier/LocalStrings.properties b/appserver/verifier/verifier-impl/src/main/resources/com/sun/enterprise/tools/verifier/LocalStrings.properties
index fbccab4..46eadb3 100755
--- a/appserver/verifier/verifier-impl/src/main/resources/com/sun/enterprise/tools/verifier/LocalStrings.properties
+++ b/appserver/verifier/verifier-impl/src/main/resources/com/sun/enterprise/tools/verifier/LocalStrings.properties
@@ -207,7 +207,7 @@
 com.sun.enterprise.tools.verifier.tests.dd.ParseDD.passedVersion=\
 Passed [EJB]: version is {0}.
 com.sun.enterprise.tools.verifier.tests.dd.ParseDD.failedDestinationType=\
-[EJB] destination-type cannot be {0}. It has to be either javax.jms.Topic or javax.jms.Queue.
+[EJB] destination-type cannot be {0}. It has to be either jakarta.jms.Topic or jakarta.jms.Queue.
 com.sun.enterprise.tools.verifier.tests.dd.ParseDD.passedDestinationType=\
 Passed [EJB]: destination-type is {0}.
 com.sun.enterprise.tools.verifier.tests.dd.ParseDD.failedMethodIntf=\
diff --git a/appserver/verifier/verifier-impl/src/main/resources/com/sun/enterprise/tools/verifier/config/standard-apis.xml b/appserver/verifier/verifier-impl/src/main/resources/com/sun/enterprise/tools/verifier/config/standard-apis.xml
index 277f16d..af6170c 100644
--- a/appserver/verifier/verifier-impl/src/main/resources/com/sun/enterprise/tools/verifier/config/standard-apis.xml
+++ b/appserver/verifier/verifier-impl/src/main/resources/com/sun/enterprise/tools/verifier/config/standard-apis.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 1997, 2018 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 1997, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -1239,7 +1239,7 @@
     </api> <!-- JSP 2.1-->
     
     <api name_version="JMS_1.0">
-        <classes package="javax.jms">
+        <classes package="jakarta.jms">
             <!--Interfaces -->
             BytesMessage
             Connection
@@ -1314,7 +1314,7 @@
     </api>
     
     <api name_version="JMS_1.1">
-        <classes package="javax.jms">
+        <classes package="jakarta.jms">
             <!-- interfaces-->
             BytesMessage
             Connection
diff --git a/appserver/web/weld-integration/src/main/java/org/glassfish/cdi/CDILoggerInfo.java b/appserver/web/weld-integration/src/main/java/org/glassfish/cdi/CDILoggerInfo.java
index b0a41af..3071b0d 100644
--- a/appserver/web/weld-integration/src/main/java/org/glassfish/cdi/CDILoggerInfo.java
+++ b/appserver/web/weld-integration/src/main/java/org/glassfish/cdi/CDILoggerInfo.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2013, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -19,11 +19,8 @@
 import org.glassfish.logging.annotation.LogMessageInfo;
 import org.glassfish.logging.annotation.LogMessagesResourceBundle;
 import org.glassfish.logging.annotation.LoggerInfo;
-
 import java.util.logging.Logger;
 
-import static java.util.logging.Level.FINE;
-
 /**
  * @author <a href="mailto:j.j.snyder@oracle.com">JJ Snyder</a>
  */
@@ -189,7 +186,7 @@
                      level = "WARNING")
     public static final String WELD_BOOTSTRAP_SHUTDOWN_EXCEPTION = CDI_LOGMSG_PREFIX + "-00036";
 
-    @LogMessageInfo( message = "javax.jms.MessageListener Class available, so need to fire PIT events to MDBs",
+    @LogMessageInfo( message = "jakarta.jms.MessageListener Class available, so need to fire PIT events to MDBs",
                      level = "FINE")
     public static final String JMS_MESSAGElISTENER_AVAILABLE = CDI_LOGMSG_PREFIX + "-00037";
 
diff --git a/appserver/web/weld-integration/src/main/java/org/glassfish/weld/WeldDeployer.java b/appserver/web/weld-integration/src/main/java/org/glassfish/weld/WeldDeployer.java
index 5aa7ae8..7ccf525 100644
--- a/appserver/web/weld-integration/src/main/java/org/glassfish/weld/WeldDeployer.java
+++ b/appserver/web/weld-integration/src/main/java/org/glassfish/weld/WeldDeployer.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2009, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2009, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -332,7 +332,7 @@
         //have a direct dependency on the JMS API
         try {
             messageListenerClass = Thread.currentThread().getContextClassLoader().
-                                            loadClass("javax.jms.MessageListener");
+                                            loadClass("jakarta.jms.MessageListener");
             if (logger.isLoggable(Level.FINE)) {
                 logger.log(Level.FINE, CDILoggerInfo.JMS_MESSAGElISTENER_AVAILABLE);
             }
diff --git a/docs/administration-guide/src/main/jbake/content/connectors.adoc b/docs/administration-guide/src/main/jbake/content/connectors.adoc
index 6fa66d6..64e395c 100644
--- a/docs/administration-guide/src/main/jbake/content/connectors.adoc
+++ b/docs/administration-guide/src/main/jbake/content/connectors.adoc
@@ -184,13 +184,13 @@
 Example 12-1 Creating a Connector Connection Pool
 
 This example creates the new `jms/qConnPool` pool for the
-`javax.jms.QueueConnectionFactory` connector module.
+`jakarta.jms.QueueConnectionFactory` connector module.
 
 [source,oac_no_warn]
 ----
 asadmin> create-connector-connection-pool --steadypoolsize 20 --maxpoolsize 100 
 --poolresize 2 --maxwait 60000 --raname jmsra --connectiondefinition 
-javax.jms.QueueConnectionFactory jms/qConnPool
+jakarta.jms.QueueConnectionFactory jms/qConnPool
 
 Command create-connector-connection-pool executed successfully
 ----
@@ -1111,13 +1111,13 @@
 
 Example 12-20 Creating an Administered Object
 
-For this example, the `javax.jms.Queue` resource type is obtained from
+For this example, the `jakarta.jms.Queue` resource type is obtained from
 the `ra.xml` file. The JNDI name of the new administered object is
 `jms/samplequeue`.
 
 [source,oac_no_warn]
 ----
-asadmin> create-admin-object --restype javax.jms.Queue --raname jmsra
+asadmin> create-admin-object --restype jakarta.jms.Queue --raname jmsra
 --description "sample administered object" --property Name=sample_jmsqueue jms/samplequeue
 Command create-admin-object executed successfully
 ----
diff --git a/docs/administration-guide/src/main/jbake/content/jms.adoc b/docs/administration-guide/src/main/jbake/content/jms.adoc
index b9fb46f..eea7e00 100644
--- a/docs/administration-guide/src/main/jbake/content/jms.adoc
+++ b/docs/administration-guide/src/main/jbake/content/jms.adoc
@@ -685,7 +685,7 @@
 Example 17-5 Creating a JMS Connection Factory
 
 This example creates a connection factory resource of type
-`javax.jms.ConnectionFactory` whose JNDI name is
+`jakarta.jms.ConnectionFactory` whose JNDI name is
 `jms/DurableConnectionFactory`. The `ClientId` property sets a client ID
 on the connection factory so that it can be used for durable
 subscriptions. The JNDI name for a JMS resource customarily includes the
@@ -693,7 +693,7 @@
 
 [source,oac_no_warn]
 ----
-asadmin> create-jms-resource --restype javax.jms.ConnectionFactory
+asadmin> create-jms-resource --restype jakarta.jms.ConnectionFactory
 --description "connection factory for durable subscriptions"
 --property ClientId=MyID jms/DurableConnectionFactory
 Command create-jms-resource executed successfully.
@@ -709,7 +709,7 @@
 
 [source,oac_no_warn]
 ----
-asadmin> create-jms-resource --restype javax.jms.Queue 
+asadmin> create-jms-resource --restype jakarta.jms.Queue 
 --property Name=PhysicalQueue jms/MyQueue
 Command create-jms-resource executed successfully.
 ----
@@ -761,7 +761,7 @@
 
 [source,oac_no_warn]
 ----
-asadmin> list-jms-resources --restype javax.jms.TopicConnectionFactory 
+asadmin> list-jms-resources --restype jakarta.jms.TopicConnectionFactory 
 jms/DurableTopicConnectionFactory 
 jms/TopicConnectionFactory 
 Command list-jms-resources executed successfully.
@@ -1182,37 +1182,37 @@
 (Synchronous) when consuming messages.
 
 |`QueueConnectionFactoryClassName` |A valid class name |None |Class name
-of `javax.jms.QueueConnectionFactory` implementation of the JMS client.
+of `jakarta.jms.QueueConnectionFactory` implementation of the JMS client.
 This class must be made available on the application server classpath.
 Used if `ProviderIntegrationMode` is `javabean`.
 
 |`TopicConnectionFactoryClassName` |A valid class name |None |Class name
-of `javax.jms.TopicConnectionFactory` implementation of the JMS client.
+of `jakarta.jms.TopicConnectionFactory` implementation of the JMS client.
 This class must be made available on the application server classpath.
 Used if `ProviderIntegrationMode` is specified as `javabean`.
 
 |`XAConnectionFactoryClassName` |A valid class name |None |Class name of
-`javax.jms.ConnectionFactory` implementation of the JMS client. This
+`jakarta.jms.ConnectionFactory` implementation of the JMS client. This
 class must be made available on the application server classpath. Used
 if `ProviderIntegrationMode` is specified as `javabean`.
 
 |`XAQueueConnectionFactoryClassName` |A valid class name |None |Class
-name of `javax.jms.``XAQueueConnectionFactory` implementation of the JMS
+name of `jakarta.jms.``XAQueueConnectionFactory` implementation of the JMS
 client. This class must be made available on the application server
 classpath. Used if `ProviderIntegrationMode` is specified as `javabean`.
 
 |`XATopicConnectionFactoryClassName` |A valid class name |None |Class
-name of `javax.jms.``XATopicConnectionFactory` implementation of the JMS
+name of `jakarta.jms.``XATopicConnectionFactory` implementation of the JMS
 client. This class must be made available on the application server
 classpath. Used if `ProviderIntegrationMode` is `javabean`.
 
 |`TopicClassName` |A valid class name |None |Class Name of
-`javax.jms.Topic` implementation of the JMS client. This class must be
+`jakarta.jms.Topic` implementation of the JMS client. This class must be
 made available on the application server classpath. Used if
 `ProviderIntegrationMode` is `javabean`.
 
 |`QueueClassName` |A valid class name |None |Class Name of
-`javax.jms.Queue` implementation of the JMS client. This class must be
+`jakarta.jms.Queue` implementation of the JMS client. This class must be
 made available on the application server classpath. Used if
 `ProviderIntegrationMode` is specified as a `javabean`.
 
@@ -1360,7 +1360,7 @@
 resource adapter to create a connection to receive messages from. Used
 only if `ProviderIntegrationMode` is configured as `jndi`.
 
-|`DestinationType` |`javax.jms.Queue` or `javax.jms.Topic` |Null |Type
+|`DestinationType` |`jakarta.jms.Queue` or `jakarta.jms.Topic` |Null |Type
 of the destination the MDB will listen to.
 
 |`DestinationProperties` |Name-value pairs separated by comma |None
@@ -1609,7 +1609,7 @@
         <ejb-name>SimpleMessageEJB</ejb-name>
         <method-name>onMessage</method-name>
         <method-params>
-          <method-param>javax.jms.Message</method-param>
+          <method-param>jakarta.jms.Message</method-param>
         </method-params>
       </method>
       <trans-attribute>NotSupported</trans-attribute>
@@ -1748,11 +1748,11 @@
       . . .
       <resource-env-ref>
         <resource-env-ref-name>jms/QCFactory</resource-env-ref-name>
-        <resource-env-ref-type>javax.jms.QueueConnectionFactory</resource-env-ref-type>
+        <resource-env-ref-type>jakarta.jms.QueueConnectionFactory</resource-env-ref-type>
       </resource-env-ref>
       <resource-env-ref>
         <resource-env-ref-name>jms/outboundQueue</resource-env-ref-name>
-        <resource-env-ref-type>javax.jms.Queue</resource-env-ref-type>
+        <resource-env-ref-type>jakarta.jms.Queue</resource-env-ref-type>
       </resource-env-ref>
 ----
 3.  Create a Connector Connection Pool and Connector Resource by
@@ -1764,7 +1764,7 @@
 [source,oac_no_warn]
 ----
 asadmin create-connector-connection-pool --host localhost --port 4848
-   --raname genericra --connectiondefinition javax.jms.QueueConnectionFactory 
+   --raname genericra --connectiondefinition jakarta.jms.QueueConnectionFactory 
    --target server --transactionsupport LocalTransaction
    --property ConnectionFactoryJndiName=jms/WLOutboundQueueFactory
      qcpool
@@ -1777,7 +1777,7 @@
 * The connection pool has the JNDI name `jms/WLoutboundQueueFactory` and
 obtains connections from a connection pool named `qcpool`.
 * The connection pool `qcpool` uses the resource adapter `genericra` and
-contains objects of type `javax.jms.QueueConnectionFactory`.
+contains objects of type `jakarta.jms.QueueConnectionFactory`.
 * The `transactionsupport` argument is set to `LocalTransaction`, which
 specifies that the connection will be used in local transactions only.
 You can also specify `NoTransaction`. However, the default setting of
@@ -1804,12 +1804,12 @@
 [source,oac_no_warn]
 ----
 asadmin create-admin-object --host localhost --port 4848 --target server 
-    --restype javax.jms.Queue --property DestinationJndiName=jms/WLOutboundQueue 
+    --restype jakarta.jms.Queue --property DestinationJndiName=jms/WLOutboundQueue 
     --raname genericra jms/outboundQueue
 ----
 This `asadmin` command creates a destination in GlassFish Server.
 * The destination has the JNDI name `jms/outboundQueue`, uses the
-resource adapter `genericra`, and is of type `javax.jms.Queue`.
+resource adapter `genericra`, and is of type `jakarta.jms.Queue`.
 * The destination is configured with the properties specified using the
 `properties` argument; multiple properties are configured as a
 colon-separated list of name-value pairs. Only one property is
@@ -2111,7 +2111,7 @@
 be configured to refer to the physical destination in the WebLogic JNDI
 store.
 
-|`DestinationType` |`javax.jms.Queue` or `javax.jms.Topic` |Null
+|`DestinationType` |`jakarta.jms.Queue` or `jakarta.jms.Topic` |Null
 |Specifies whether the configured `DestinationJndiName` refers to a
 queue or topic.
 
@@ -2535,7 +2535,7 @@
 [source,oac_no_warn]
 ----
      asadmin create-connector-connection-pool -- raname genericra connectiondefinition
-            javax.jms.QueueConnectionFactory --transactionsupport  XATransaction 
+            jakarta.jms.QueueConnectionFactory --transactionsupport  XATransaction 
             --property ConnectionFactoryJndiName=QCF mypool
 ----
 The following `asadmin` command creates a Connection Pool called
@@ -2543,7 +2543,7 @@
 [source,oac_no_warn]
 ----
      asadmin create-connector-connection-pool 
-            -- raname genericra connectiondefinition javax.jms.TopicConnectionFactory 
+            -- raname genericra connectiondefinition jakarta.jms.TopicConnectionFactory 
             --transactionsupport  XATransaction
             --property ConnectionFactoryJndiName=XATCF mypool2
 ----
@@ -2563,20 +2563,20 @@
 3.  Create the JMS destination resources as administered objects. +
 In the image above, `jms/MyQueue` (pointing to `GenericJMSRA` and
 `TQueue`) is created in GlassFish Server. +
-The following `asadmin` command creates a `javax.jms.Queue` administered
+The following `asadmin` command creates a `jakarta.jms.Queue` administered
 object and binds it to the GlassFish Server JNDI tree at `jms/MyQueue`
 and points to the `jms/TQueue` created in WebSphere MQ. +
 [source,oac_no_warn]
 ----
-     asadmin create-admin-object --raname genericra --restype javax.jms.Queue 
+     asadmin create-admin-object --raname genericra --restype jakarta.jms.Queue 
             --property DestinationJndiName=TQueue jms/MyQueue
 ----
-The following `asadmin` command creates a `javax.jms.Topic` administered
+The following `asadmin` command creates a `jakarta.jms.Topic` administered
 object and binds it to the GlassFish Server JNDI tree at `jms/MyTopic`
 and points to the `jms/TTopic` created in WebSphere MQ. +
 [source,oac_no_warn]
 ----
-     asadmin create-admin-object --raname genericra --restype javax.jms.Topic 
+     asadmin create-admin-object --raname genericra --restype jakarta.jms.Topic 
             --property DestinationJndiName=TTopic jms/MyTopic
 ----
 
diff --git a/docs/application-deployment-guide/src/main/jbake/content/dd-elements.adoc b/docs/application-deployment-guide/src/main/jbake/content/dd-elements.adoc
index 9c2c116..370230d 100644
--- a/docs/application-deployment-guide/src/main/jbake/content/dd-elements.adoc
+++ b/docs/application-deployment-guide/src/main/jbake/content/dd-elements.adoc
@@ -2301,14 +2301,14 @@
 |Property |Default |Description
 |`AddressList` |none |Specifies a list of host/port combinations of the
 Message Queue software. For JMS resources of the Type
-`javax.jms.TopicConnectionFactory` or
-`javax.jms.QueueConnectionFactory`.
+`jakarta.jms.TopicConnectionFactory` or
+`jakarta.jms.QueueConnectionFactory`.
 
 |`ClientId` |none a|
 Specifies the JMS Client Identifier to be associated with a `Connection`
 created using the `createTopicConnection` method of the
 `TopicConnectionFactory` class. For JMS resources of the Type
-`javax.jms.TopicConnectionFactory` .
+`jakarta.jms.TopicConnectionFactory` .
 
 Durable subscription names are unique and only valid within the scope of
 a client identifier. To create or reactivate a durable subscriber, the
@@ -2319,13 +2319,13 @@
 
 |`UserName` |`guest` |Specifies the user name for connecting to the
 Message Queue software. For JMS resources of the Type
-`javax.jms.TopicConnectionFactory` or
-`javax.jms.QueueConnectionFactory`.
+`jakarta.jms.TopicConnectionFactory` or
+`jakarta.jms.QueueConnectionFactory`.
 
 |`Password` |`guest` |Specifies the password for connecting to the
 Message Queue software. For JMS resources of the Type
-`javax.jms.TopicConnectionFactory` or
-`javax.jms.QueueConnectionFactory`.
+`jakarta.jms.TopicConnectionFactory` or
+`jakarta.jms.QueueConnectionFactory`.
 
 |`ReconnectAttempts` |`6` |Specifies the number of attempts to connect
 (or reconnect) for each address in the `imqAddressList` before the
diff --git a/docs/application-development-guide/src/main/jbake/content/connectors.adoc b/docs/application-development-guide/src/main/jbake/content/connectors.adoc
index 184df6a..f188911 100644
--- a/docs/application-development-guide/src/main/jbake/content/connectors.adoc
+++ b/docs/application-development-guide/src/main/jbake/content/connectors.adoc
@@ -601,7 +601,7 @@
        destinationType
      </activation-config-property-name>
      <activation-config-property-value>
-       javax.jms.Topic
+       jakarta.jms.Topic
      </activation-config-property-value>
   </activation-config-property>
   <activation-config-property>
diff --git a/docs/application-development-guide/src/main/jbake/content/ejb.adoc b/docs/application-development-guide/src/main/jbake/content/ejb.adoc
index f044ebf..e98191b 100644
--- a/docs/application-development-guide/src/main/jbake/content/ejb.adoc
+++ b/docs/application-development-guide/src/main/jbake/content/ejb.adoc
@@ -1347,7 +1347,7 @@
 container protection.
 
 A message-driven bean's `onMessage` method can use the
-`javax.jms.Message.getJMSRedelivered` method to check whether a received
+`jakarta.jms.Message.getJMSRedelivered` method to check whether a received
 message is a redelivered message.
 
 
diff --git a/docs/application-development-guide/src/main/jbake/content/osgi.adoc b/docs/application-development-guide/src/main/jbake/content/osgi.adoc
index 8b0ac39..8d40538 100644
--- a/docs/application-development-guide/src/main/jbake/content/osgi.adoc
+++ b/docs/application-development-guide/src/main/jbake/content/osgi.adoc
@@ -299,14 +299,14 @@
 [width="100%",cols="12%,39%,12%,37%",options="header",]
 |=======================================================================
 |JMS Object |Service Interface |Service Properties |Comments
-|JMS Queue destination |`javax.jms.Queue` |`jndi-name` |`jndi-name` is
+|JMS Queue destination |`jakarta.jms.Queue` |`jndi-name` |`jndi-name` is
 set to the JNDI name of the queue
 
-|JMS Topic destination |`javax.jms.Topic` |`jndi-name` |`jndi-name` is
+|JMS Topic destination |`jakarta.jms.Topic` |`jndi-name` |`jndi-name` is
 set to the JNDI name of the topic
 
-|JMS connection factory |`javax.jms.QueueConnectionFactory` or
-`javax.jms.TopicConnectionFactory` or `javax.jms.ConnectionFactory`
+|JMS connection factory |`jakarta.jms.QueueConnectionFactory` or
+`jakarta.jms.TopicConnectionFactory` or `jakarta.jms.ConnectionFactory`
 |`jndi-name` a|
 `jndi-name` is set to the JNDI name of the topic.
 
diff --git a/docs/error-messages-reference/src/main/jbake/content/error-messages.adoc b/docs/error-messages-reference/src/main/jbake/content/error-messages.adoc
index 06c0223..e7453f8 100644
--- a/docs/error-messages-reference/src/main/jbake/content/error-messages.adoc
+++ b/docs/error-messages-reference/src/main/jbake/content/error-messages.adoc
@@ -4802,7 +4802,7 @@
   Cause: As described in the message. +
   Action: Resolve the situation described in the message, if necessary.
 
-[[sthref1154]]AS-CDI-00037 javax.jms.MessageListener Class available, so need to fire PIT events to MDBs ::
+[[sthref1154]]AS-CDI-00037 jakarta.jms.MessageListener Class available, so need to fire PIT events to MDBs ::
   Cause: As described in the message. +
   Action: Resolve the situation described in the message, if necessary.
 
diff --git a/docs/reference-manual/src/main/jbake/content/create-admin-object.adoc b/docs/reference-manual/src/main/jbake/content/create-admin-object.adoc
index 2c5a472..d733573 100644
--- a/docs/reference-manual/src/main/jbake/content/create-admin-object.adoc
+++ b/docs/reference-manual/src/main/jbake/content/create-admin-object.adoc
@@ -116,11 +116,11 @@
 Example 1   Creating an Administered Object
 
 In this example, `jmsra` is a system resource adapter with the admin
-object interfaces, `javax.jms.Queue` and `javax.jms.Topic`.
+object interfaces, `jakarta.jms.Queue` and `jakarta.jms.Topic`.
 
 [source,oac_no_warn]
 ----
-asadmin> create-admin-object --restype javax.jms.Queue
+asadmin> create-admin-object --restype jakarta.jms.Queue
 --raname jmsra --description "sample administered object"
 --property Name=sample_jmsqueue jms/samplequeue
 Command create-admin-object executed successfully
diff --git a/docs/reference-manual/src/main/jbake/content/create-connector-connection-pool.adoc b/docs/reference-manual/src/main/jbake/content/create-connector-connection-pool.adoc
index bbb5714..7dc475b 100644
--- a/docs/reference-manual/src/main/jbake/content/create-connector-connection-pool.adoc
+++ b/docs/reference-manual/src/main/jbake/content/create-connector-connection-pool.adoc
@@ -244,7 +244,7 @@
 [source,oac_no_warn]
 ----
 asadmin> create-connector-connection-pool --raname jmsra 
---connectiondefinition javax.jms.QueueConnectionFactory --steadypoolsize 20 
+--connectiondefinition jakarta.jms.QueueConnectionFactory --steadypoolsize 20 
 --maxpoolsize 100 --poolresize 2 --maxwait 60000 jms/qConnPool
 Command create-connector-connection-pool executed successfully
 ----
diff --git a/docs/reference-manual/src/main/jbake/content/create-jms-resource.adoc b/docs/reference-manual/src/main/jbake/content/create-jms-resource.adoc
index 06e287d..39ed67e 100644
--- a/docs/reference-manual/src/main/jbake/content/create-jms-resource.adoc
+++ b/docs/reference-manual/src/main/jbake/content/create-jms-resource.adoc
@@ -51,10 +51,10 @@
 `-?`::
   Displays the help text for the subcommand.
 `--restype`::
-  The JMS resource type, which can be `javax.jms.Topic`,
-  `javax.jms.Queue`, `javax.jms.ConnectionFactory`,
-  `javax.jms.TopicConnectionFactory`, or
-  `javax.jms.QueueConnectionFactory`.
+  The JMS resource type, which can be `jakarta.jms.Topic`,
+  `jakarta.jms.Queue`, `jakarta.jms.ConnectionFactory`,
+  `jakarta.jms.TopicConnectionFactory`, or
+  `jakarta.jms.QueueConnectionFactory`.
 `--target`::
   Creates the JMS resource only for the specified target. Valid values
   are as follows: +
@@ -178,7 +178,7 @@
 subscriptions
 
 The following subcommand creates a connection factory resource of type
-`javax.jms.ConnectionFactory` whose JNDI name is
+`jakarta.jms.ConnectionFactory` whose JNDI name is
 `jms/DurableConnectionFactory`. The `ClientId` property sets a client ID
 on the connection factory so that it can be used for durable
 subscriptions. The JNDI name for a JMS resource customarily includes the
@@ -186,7 +186,7 @@
 
 [source,oac_no_warn]
 ----
-asadmin> create-jms-resource --restype javax.jms.ConnectionFactory
+asadmin> create-jms-resource --restype jakarta.jms.ConnectionFactory
 --description "connection factory for durable subscriptions"
 --property ClientId=MyID jms/DurableConnectionFactory
 Connector resource jms/DurableConnectionFactory created.
@@ -203,7 +203,7 @@
 
 [source,oac_no_warn]
 ----
-asadmin> create-jms-resource --restype javax.jms.Queue
+asadmin> create-jms-resource --restype jakarta.jms.Queue
 --property Name=PhysicalQueue jms/MyQueue
 Administered object jms/MyQueue created.
 Command create-jms-resource executed successfully.
diff --git a/docs/reference-manual/src/main/jbake/content/list-jms-resources.adoc b/docs/reference-manual/src/main/jbake/content/list-jms-resources.adoc
index 1ceb695..1a43014 100644
--- a/docs/reference-manual/src/main/jbake/content/list-jms-resources.adoc
+++ b/docs/reference-manual/src/main/jbake/content/list-jms-resources.adoc
@@ -46,9 +46,9 @@
 `-?`::
   Displays the help text for the subcommand.
 `--restype`::
-  The JMS resource type can be `javax.jms.Topic`, `javax.jms.Queue`,
-  `javax.jms.ConnectionFactory`, `javax.jms.TopicConnectionFactory`, or
-  `javax.jms.QueueConnectionFactory`.
+  The JMS resource type can be `jakarta.jms.Topic`, `jakarta.jms.Queue`,
+  `jakarta.jms.ConnectionFactory`, `jakarta.jms.TopicConnectionFactory`, or
+  `jakarta.jms.QueueConnectionFactory`.
 
 [[sthref1578]]
 
@@ -92,12 +92,12 @@
 
 Example 2   Listing JMS resources of a specified type
 
-The following subcommand lists all `javax.jms.ConnectionFactory`
+The following subcommand lists all `jakarta.jms.ConnectionFactory`
 resources.
 
 [source,oac_no_warn]
 ----
-asadmin> list-jms-resources --restype javax.jms.ConnectionFactory
+asadmin> list-jms-resources --restype jakarta.jms.ConnectionFactory
 jms/ConnectionFactory
 jms/DurableConnectionFactory
 Command list-jms-resources executed successfully.
diff --git a/nucleus/admin/server-mgmt/src/main/java/com/sun/enterprise/admin/servermgmt/RepositoryManager.java b/nucleus/admin/server-mgmt/src/main/java/com/sun/enterprise/admin/servermgmt/RepositoryManager.java
index 8df9335..782353e 100644
--- a/nucleus/admin/server-mgmt/src/main/java/com/sun/enterprise/admin/servermgmt/RepositoryManager.java
+++ b/nucleus/admin/server-mgmt/src/main/java/com/sun/enterprise/admin/servermgmt/RepositoryManager.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -29,7 +29,6 @@
 import com.sun.enterprise.admin.servermgmt.pe.PEFileLayout;
 import com.sun.enterprise.admin.servermgmt.pe.PEDomainsManager;
 import com.sun.enterprise.util.i18n.StringManager;
-import com.sun.enterprise.admin.util.AdminConstants;
 import com.sun.enterprise.security.store.PasswordAdapter;
 
 //import com.sun.enterprise.admin.common.Status;
@@ -47,10 +46,9 @@
 //iMQ imports
 //import com.sun.enterprise.jms.IASJmsUtil;
 //import com.sun.messaging.jmq.jmsspi.JMSAdmin;
-//import javax.jms.JMSException;
+//import jakarta.jms.JMSException;
 
 import com.sun.enterprise.util.SystemPropertyConstants;
-import org.glassfish.security.common.FileRealmHelper;
 //import com.sun.enterprise.util.ExecException;
 
 /**
diff --git a/nucleus/resources/src/main/java/org/glassfish/resourcebase/resources/api/ResourceConstants.java b/nucleus/resources/src/main/java/org/glassfish/resourcebase/resources/api/ResourceConstants.java
index 084aac7..b1910ab 100644
--- a/nucleus/resources/src/main/java/org/glassfish/resourcebase/resources/api/ResourceConstants.java
+++ b/nucleus/resources/src/main/java/org/glassfish/resourcebase/resources/api/ResourceConstants.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -86,11 +86,11 @@
     /** resource type residing in an external JNDI repository */
     public static final String EXT_JNDI_RES_TYPE = "external-jndi-resource";
 
-    public static final String JMS_QUEUE = "javax.jms.Queue";
-    public static final String JMS_TOPIC = "javax.jms.Topic";
-    public static final String JMS_QUEUE_CONNECTION_FACTORY = "javax.jms.QueueConnectionFactory";
-    public static final String JMS_TOPIC_CONNECTION_FACTORY = "javax.jms.TopicConnectionFactory";
-    public static final String JMS_MESSAGE_LISTENER = "javax.jms.MessageListener";
+    public static final String JMS_QUEUE = "jakarta.jms.Queue";
+    public static final String JMS_TOPIC = "jakarta.jms.Topic";
+    public static final String JMS_QUEUE_CONNECTION_FACTORY = "jakarta.jms.QueueConnectionFactory";
+    public static final String JMS_TOPIC_CONNECTION_FACTORY = "jakarta.jms.TopicConnectionFactory";
+    public static final String JMS_MESSAGE_LISTENER = "jakarta.jms.MessageListener";
 
     //TODO should be refactored to non-resources module
     /**
diff --git a/nucleus/tests/admin/src/test/java/org/glassfish/nucleus/admin/rest/JmsTest.java b/nucleus/tests/admin/src/test/java/org/glassfish/nucleus/admin/rest/JmsTest.java
index ff103e3..a5346a1 100644
--- a/nucleus/tests/admin/src/test/java/org/glassfish/nucleus/admin/rest/JmsTest.java
+++ b/nucleus/tests/admin/src/test/java/org/glassfish/nucleus/admin/rest/JmsTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2010, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -45,7 +45,7 @@
         Map<String, String> ccp_attrs = new HashMap<String, String>() {
             {
                 put("name", poolName);
-                put("connectiondefinition", "javax.jms.ConnectionFactory");
+                put("connectiondefinition", "jakarta.jms.ConnectionFactory");
                 put("raname", "jmsra");
             }
         };
@@ -116,7 +116,7 @@
             {
                 put("id", jndiName);
                 put("raname", "jmsra");
-                put("restype", "javax.jms.Topic");
+                put("restype", "jakarta.jms.Topic");
             }
         };
 
