diff --git a/tests/bc_2_0_0/src/test/resources/pulsar.xml b/tests/bc_2_0_0/src/test/resources/pulsar.xml
index cd1f78e..4b2a9bc 100644
--- a/tests/bc_2_0_0/src/test/resources/pulsar.xml
+++ b/tests/bc_2_0_0/src/test/resources/pulsar.xml
@@ -18,7 +18,7 @@
     under the License.
 
 -->
-<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >
+<!DOCTYPE suite SYSTEM "https://testng.org/testng-1.0.dtd" >
 <!-- TODO: we have to put suite files in one file to avoid executing TESTNG test suites multiple times.
            see {@link https://github.com/cbeust/testng/issues/508} -->
 <suite name="Pulsar Standalone Tests" verbose="2" annotations="JDK">
diff --git a/tests/bc_2_0_1/src/test/resources/pulsar.xml b/tests/bc_2_0_1/src/test/resources/pulsar.xml
index cd1f78e..4b2a9bc 100644
--- a/tests/bc_2_0_1/src/test/resources/pulsar.xml
+++ b/tests/bc_2_0_1/src/test/resources/pulsar.xml
@@ -18,7 +18,7 @@
     under the License.
 
 -->
-<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >
+<!DOCTYPE suite SYSTEM "https://testng.org/testng-1.0.dtd" >
 <!-- TODO: we have to put suite files in one file to avoid executing TESTNG test suites multiple times.
            see {@link https://github.com/cbeust/testng/issues/508} -->
 <suite name="Pulsar Standalone Tests" verbose="2" annotations="JDK">
diff --git a/tests/integration/src/test/resources/pulsar-backwards-compatibility.xml b/tests/integration/src/test/resources/pulsar-backwards-compatibility.xml
index f0fc615..b50af74 100644
--- a/tests/integration/src/test/resources/pulsar-backwards-compatibility.xml
+++ b/tests/integration/src/test/resources/pulsar-backwards-compatibility.xml
@@ -18,7 +18,7 @@
     under the License.
 
 -->
-<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >
+<!DOCTYPE suite SYSTEM "https://testng.org/testng-1.0.dtd" >
 <suite name="Pulsar Messaging Backwards Compatibility Tests" verbose="2" annotations="JDK">
     <test name="messaging-backwards-compatibility-suite" preserve-order="true">
         <classes>
diff --git a/tests/integration/src/test/resources/pulsar-cli-suite.xml b/tests/integration/src/test/resources/pulsar-cli-suite.xml
index 2d413a6..ec07208 100644
--- a/tests/integration/src/test/resources/pulsar-cli-suite.xml
+++ b/tests/integration/src/test/resources/pulsar-cli-suite.xml
@@ -18,7 +18,7 @@
     under the License.
 
 -->
-<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >
+<!DOCTYPE suite SYSTEM "https://testng.org/testng-1.0.dtd" >
 <!-- TODO: we have to put suite files in one file to avoid executing TESTNG test suites multiple times.
            see {@link https://github.com/cbeust/testng/issues/508} -->
 <suite name="Pulsar Test Suite" parallel="instances" thread-count="1">
diff --git a/tests/integration/src/test/resources/pulsar-cli.xml b/tests/integration/src/test/resources/pulsar-cli.xml
index a5b8605..1be3a1d 100644
--- a/tests/integration/src/test/resources/pulsar-cli.xml
+++ b/tests/integration/src/test/resources/pulsar-cli.xml
@@ -18,7 +18,7 @@
     under the License.
 
 -->
-<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >
+<!DOCTYPE suite SYSTEM "https://testng.org/testng-1.0.dtd" >
 <suite name="Pulsar CLI Integration Tests" verbose="2" annotations="JDK">
     <test name="pulsar-cli-test-suite" preserve-order="true" >
         <classes>
diff --git a/tests/integration/src/test/resources/pulsar-function-state.xml b/tests/integration/src/test/resources/pulsar-function-state.xml
index a95b3f5..56ff01b 100644
--- a/tests/integration/src/test/resources/pulsar-function-state.xml
+++ b/tests/integration/src/test/resources/pulsar-function-state.xml
@@ -18,7 +18,7 @@
     under the License.
 
 -->
-<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >
+<!DOCTYPE suite SYSTEM "https://testng.org/testng-1.0.dtd" >
 <suite name="Pulsar Function State Integration Tests" verbose="2" annotations="JDK">
     <test name="pulsar-function-state-test-suite" preserve-order="true" >
         <classes>
diff --git a/tests/integration/src/test/resources/pulsar-messaging.xml b/tests/integration/src/test/resources/pulsar-messaging.xml
index dcd9b71..4af0a33 100644
--- a/tests/integration/src/test/resources/pulsar-messaging.xml
+++ b/tests/integration/src/test/resources/pulsar-messaging.xml
@@ -18,7 +18,7 @@
     under the License.
 
 -->
-<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >
+<!DOCTYPE suite SYSTEM "https://testng.org/testng-1.0.dtd" >
 <suite name="Pulsar (Messaging) Integration Tests" verbose="2" annotations="JDK">
     <test name="messaging-test-suite" preserve-order="true">
         <classes>
diff --git a/tests/integration/src/test/resources/pulsar-process-suite.xml b/tests/integration/src/test/resources/pulsar-process-suite.xml
index 34e5534..5c65e2d 100644
--- a/tests/integration/src/test/resources/pulsar-process-suite.xml
+++ b/tests/integration/src/test/resources/pulsar-process-suite.xml
@@ -18,7 +18,7 @@
     under the License.
 
 -->
-<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >
+<!DOCTYPE suite SYSTEM "https://testng.org/testng-1.0.dtd" >
 <!-- TODO: we have to put suite files in one file to avoid executing TESTNG test suites multiple times.
            see {@link https://github.com/cbeust/testng/issues/508} -->
 <suite name="Pulsar Test Suite" parallel="instances" thread-count="1">
diff --git a/tests/integration/src/test/resources/pulsar-process.xml b/tests/integration/src/test/resources/pulsar-process.xml
index 7a24ea5..c3db70c 100644
--- a/tests/integration/src/test/resources/pulsar-process.xml
+++ b/tests/integration/src/test/resources/pulsar-process.xml
@@ -18,7 +18,7 @@
     under the License.
 
 -->
-<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >
+<!DOCTYPE suite SYSTEM "https://testng.org/testng-1.0.dtd" >
 <suite name="Pulsar Function Process Integration Tests" verbose="2" annotations="JDK">
     <test name="pulsar-function-process-test-suite" preserve-order="true" >
         <classes>
diff --git a/tests/integration/src/test/resources/pulsar-schema-suite.xml b/tests/integration/src/test/resources/pulsar-schema-suite.xml
index 8379226..ed0a003 100644
--- a/tests/integration/src/test/resources/pulsar-schema-suite.xml
+++ b/tests/integration/src/test/resources/pulsar-schema-suite.xml
@@ -18,7 +18,7 @@
     under the License.
 
 -->
-<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >
+<!DOCTYPE suite SYSTEM "https://testng.org/testng-1.0.dtd" >
 <!-- TODO: we have to put suite files in one file to avoid executing TESTNG test suites multiple times.
            see {@link https://github.com/cbeust/testng/issues/508} -->
 <suite name="Pulsar Test Suite" parallel="instances" thread-count="1">
diff --git a/tests/integration/src/test/resources/pulsar-schema.xml b/tests/integration/src/test/resources/pulsar-schema.xml
index 5917805..c24b4fa 100644
--- a/tests/integration/src/test/resources/pulsar-schema.xml
+++ b/tests/integration/src/test/resources/pulsar-schema.xml
@@ -18,7 +18,7 @@
     under the License.
 
 -->
-<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >
+<!DOCTYPE suite SYSTEM "https://testng.org/testng-1.0.dtd" >
 <suite name="Pulsar Schema Integration Tests" verbose="2" annotations="JDK">
     <test name="pulsar-schema-test-suite" preserve-order="true" >
         <classes>
diff --git a/tests/integration/src/test/resources/pulsar-sql-suite.xml b/tests/integration/src/test/resources/pulsar-sql-suite.xml
index b1e5381..78b6268 100644
--- a/tests/integration/src/test/resources/pulsar-sql-suite.xml
+++ b/tests/integration/src/test/resources/pulsar-sql-suite.xml
@@ -18,7 +18,7 @@
     under the License.
 
 -->
-<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >
+<!DOCTYPE suite SYSTEM "https://testng.org/testng-1.0.dtd" >
 <!-- TODO: we have to put suite files in one file to avoid executing TESTNG test suites multiple times.
            see {@link https://github.com/cbeust/testng/issues/508} -->
 <suite name="Pulsar Test Suite" parallel="instances" thread-count="1">
diff --git a/tests/integration/src/test/resources/pulsar-sql.xml b/tests/integration/src/test/resources/pulsar-sql.xml
index 7623b76..46762f6 100644
--- a/tests/integration/src/test/resources/pulsar-sql.xml
+++ b/tests/integration/src/test/resources/pulsar-sql.xml
@@ -18,7 +18,7 @@
     under the License.
 
 -->
-<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >
+<!DOCTYPE suite SYSTEM "https://testng.org/testng-1.0.dtd" >
 <suite name="Pulsar SQL Integration Tests" verbose="2" annotations="JDK">
     <test name="pulsar-sql-test-suite" preserve-order="true" >
         <classes>
diff --git a/tests/integration/src/test/resources/pulsar-standalone.xml b/tests/integration/src/test/resources/pulsar-standalone.xml
index 8a5a823..d8892c0 100644
--- a/tests/integration/src/test/resources/pulsar-standalone.xml
+++ b/tests/integration/src/test/resources/pulsar-standalone.xml
@@ -18,7 +18,7 @@
     under the License.
 
 -->
-<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >
+<!DOCTYPE suite SYSTEM "https://testng.org/testng-1.0.dtd" >
 <suite name="Pulsar Standalone Tests" verbose="2" annotations="JDK">
     <test name="pulsar-standalone-suite" preserve-order="true" >
         <classes>
diff --git a/tests/integration/src/test/resources/pulsar-thread-suite.xml b/tests/integration/src/test/resources/pulsar-thread-suite.xml
index 6eca6a6..00f7220 100644
--- a/tests/integration/src/test/resources/pulsar-thread-suite.xml
+++ b/tests/integration/src/test/resources/pulsar-thread-suite.xml
@@ -18,7 +18,7 @@
     under the License.
 
 -->
-<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >
+<!DOCTYPE suite SYSTEM "https://testng.org/testng-1.0.dtd" >
 <!-- TODO: we have to put suite files in one file to avoid executing TESTNG test suites multiple times.
            see {@link https://github.com/cbeust/testng/issues/508} -->
 <suite name="Pulsar Test Suite" parallel="instances" thread-count="1">
diff --git a/tests/integration/src/test/resources/pulsar-thread.xml b/tests/integration/src/test/resources/pulsar-thread.xml
index 14a908f..6f520df 100644
--- a/tests/integration/src/test/resources/pulsar-thread.xml
+++ b/tests/integration/src/test/resources/pulsar-thread.xml
@@ -18,7 +18,7 @@
     under the License.
 
 -->
-<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >
+<!DOCTYPE suite SYSTEM "https://testng.org/testng-1.0.dtd" >
 <suite name="Pulsar (Thread Function Worker) Integration Tests" verbose="2" annotations="JDK">
     <test name="pulsar-thread-test-suite" preserve-order="true">
         <classes>
diff --git a/tests/integration/src/test/resources/pulsar.xml b/tests/integration/src/test/resources/pulsar.xml
index 44a46fa..debfed2 100644
--- a/tests/integration/src/test/resources/pulsar.xml
+++ b/tests/integration/src/test/resources/pulsar.xml
@@ -18,7 +18,7 @@
     under the License.
 
 -->
-<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >
+<!DOCTYPE suite SYSTEM "https://testng.org/testng-1.0.dtd" >
 <!-- TODO: we have to put suite files in one file to avoid executing TESTNG test suites multiple times.
            see {@link https://github.com/cbeust/testng/issues/508} -->
 <suite name="Pulsar Test Suite" parallel="instances" thread-count="1">
diff --git a/tests/integration/src/test/resources/tiered-file-system-suite.xml b/tests/integration/src/test/resources/tiered-file-system-suite.xml
index e5ec338..46c2c35 100644
--- a/tests/integration/src/test/resources/tiered-file-system-suite.xml
+++ b/tests/integration/src/test/resources/tiered-file-system-suite.xml
@@ -18,7 +18,7 @@
     under the License.
 
 -->
-<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >
+<!DOCTYPE suite SYSTEM "https://testng.org/testng-1.0.dtd" >
 <!-- TODO: we have to put suite files in one file to avoid executing TESTNG test suites multiple times.
            see {@link https://github.com/cbeust/testng/issues/508} -->
 <suite name="Pulsar (Jcloud Tiered Storage)Test Suite" parallel="instances" thread-count="1">
diff --git a/tests/integration/src/test/resources/tiered-filesystem-storage.xml b/tests/integration/src/test/resources/tiered-filesystem-storage.xml
index b6279e3..b140775 100644
--- a/tests/integration/src/test/resources/tiered-filesystem-storage.xml
+++ b/tests/integration/src/test/resources/tiered-filesystem-storage.xml
@@ -18,7 +18,7 @@
     under the License.
 
 -->
-<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >
+<!DOCTYPE suite SYSTEM "https://testng.org/testng-1.0.dtd" >
 <suite name="Pulsar (Filesystem Tiered Storage) Integration Tests" verbose="2" annotations="JDK">
     <test name="tiered-storage-filesystem-test-suite" preserve-order="true">
         <classes>
diff --git a/tests/integration/src/test/resources/tiered-jcloud-storage.xml b/tests/integration/src/test/resources/tiered-jcloud-storage.xml
index a727144..f61f9f5 100644
--- a/tests/integration/src/test/resources/tiered-jcloud-storage.xml
+++ b/tests/integration/src/test/resources/tiered-jcloud-storage.xml
@@ -18,7 +18,7 @@
     under the License.
 
 -->
-<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >
+<!DOCTYPE suite SYSTEM "https://testng.org/testng-1.0.dtd" >
 <suite name="Pulsar (Jcloud Tiered Storage) Integration Tests" verbose="2" annotations="JDK">
     <test name="tiered-storage-jcloud-test-suite" preserve-order="true">
         <classes>
diff --git a/tests/integration/src/test/resources/tiered-storage-jcloud-suite.xml b/tests/integration/src/test/resources/tiered-storage-jcloud-suite.xml
index bd49803..be7fa98 100644
--- a/tests/integration/src/test/resources/tiered-storage-jcloud-suite.xml
+++ b/tests/integration/src/test/resources/tiered-storage-jcloud-suite.xml
@@ -18,7 +18,7 @@
     under the License.
 
 -->
-<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >
+<!DOCTYPE suite SYSTEM "https://testng.org/testng-1.0.dtd" >
 <!-- TODO: we have to put suite files in one file to avoid executing TESTNG test suites multiple times.
            see {@link https://github.com/cbeust/testng/issues/508} -->
 <suite name="Pulsar Test Suite" parallel="instances" thread-count="1">
