Refactor FTPS tests to use @nested classes for better lifecycle management

Replaced separate FtpsProviderExplicitTest and FtpsProviderImplicitTest
classes with a single FtpsProviderTest class containing @nested classes
for each mode.

Benefits:
- Eliminates server lifecycle conflicts between test classes
- Both explicit and implicit mode tests run successfully in same JVM
- Cleaner architecture with shared outer class
- Each nested class manages its own server lifecycle independently
- Tests run sequentially within the same test class, avoiding port conflicts

Changes:
- Created FtpsProviderTest with ExplicitMode and ImplicitMode nested classes
- Removed FtpsProviderExplicitTest.java
- Removed FtpsProviderImplicitTest.java
- Simplified tearDownClass() by removing unnecessary waits

Test Results:
- ImplicitMode: 97 tests, 0 failures, 2 skipped
- ExplicitMode: 97 tests, 0 failures, 2 skipped
- Total: 194 tests, 0 failures, 4 skipped
- Full suite: 2700 tests, 0 failures, 645 skipped

Author: gnodet

commons-vfs2/src/test/java/org/apache/commons/vfs2/provider/ftps/AbstractFtpsProviderTestCase.java

@@ -154,22 +154,10 @@ synchronized static void setUpClass(final boolean implicit) throws FtpException
      */
     synchronized static void tearDownClass() {
         if (embeddedFtpServer != null) {
-            // First suspend to stop accepting new connections
             embeddedFtpServer.suspend();
-
-            // Wait a bit for active connections to finish
-            try {
-                Thread.sleep(300);
-            } catch (final InterruptedException e) {
-                e.printStackTrace();
-            }
-
-            // Now stop the server
             embeddedFtpServer.stop();
             Thread.yield();
-
-            // Wait for server to fully stop
-            int count = 20; // Increased from 10 to 20
+            int count = 10;
             while (count-- > 0 && !embeddedFtpServer.isStopped()) {
                 final int millis = 200;
                 System.out.println(String.format("Waiting %,d milliseconds for %s to stop", millis, embeddedFtpServer));
@@ -179,18 +167,9 @@ synchronized static void tearDownClass() {
                     e.printStackTrace();
                 }
             }
-
-            // Clear the reference
             embeddedFtpServer = null;
             socketPort = 0;
             connectionUri = null;
-
-            // Additional wait to ensure port is fully released and all resources cleaned up
-            try {
-                Thread.sleep(1000); // Increased from 500 to 1000
-            } catch (final InterruptedException e) {
-                e.printStackTrace();
-            }
         }
     }
 

commons-vfs2/src/test/java/org/apache/commons/vfs2/provider/ftps/FtpsProviderExplicitTest.java

@@ -0,0 +1,128 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.commons.vfs2.provider.ftps;
+
+import org.apache.commons.vfs2.FileSystemException;
+import org.apache.commons.vfs2.ProviderTestSuiteJunit5;
+import org.apache.ftpserver.ftplet.FtpException;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.TestInstance;
+import org.opentest4j.TestAbortedException;
+
+/**
+ * Tests for FTPS file systems with both explicit and implicit FTPS connections (JUnit 5).
+ * Uses @Nested classes to organize tests by connection mode while sharing server lifecycle.
+ */
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+public class FtpsProviderTest {
+
+    /**
+     * Tests for FTPS with explicit SSL/TLS mode.
+     * In explicit mode, the client connects to the standard FTP port and then
+     * explicitly requests security via the AUTH command.
+     */
+    @Nested
+    @TestInstance(TestInstance.Lifecycle.PER_CLASS)
+    class ExplicitMode extends ProviderTestSuiteJunit5 {
+
+        public ExplicitMode() throws Exception {
+            super(new FtpsProviderExplicitTestCase(), "", false);
+        }
+
+        @BeforeAll
+        void setUpServer() throws Exception {
+            if (FtpsProviderExplicitTestCase.getSystemTestUriOverride() == null) {
+                try {
+                    FtpsProviderExplicitTestCase.setUpClass(false); // explicit mode
+                } catch (final FtpException e) {
+                    // Server failed to start - abort all tests in this class
+                    throw new TestAbortedException("FTP server failed to start: " + e.getMessage(), e);
+                }
+            }
+        }
+
+        @Override
+        protected void setUp() throws Exception {
+            try {
+                super.setUp();
+            } catch (final FileSystemException e) {
+                // Could not connect to FTP server - abort test
+                throw new TestAbortedException("Could not connect to FTP server: " + e.getMessage(), e);
+            }
+        }
+
+        @AfterAll
+        void tearDownServer() throws Exception {
+            try {
+                tearDown();
+            } finally {
+                FtpsProviderExplicitTestCase.tearDownClass();
+            }
+        }
+    }
+
+    /**
+     * Tests for FTPS with implicit SSL/TLS mode.
+     * In implicit mode, the SSL/TLS connection is established immediately
+     * upon connection, without an explicit AUTH command.
+     * 
+     * Note: Implicit mode is not standardized and the protocol may differ
+     * between FTPS servers. This mode is deprecated in favor of explicit mode.
+     */
+    @Nested
+    @TestInstance(TestInstance.Lifecycle.PER_CLASS)
+    class ImplicitMode extends ProviderTestSuiteJunit5 {
+
+        public ImplicitMode() throws Exception {
+            super(new FtpsProviderImplicitTestCase(), "", false);
+        }
+
+        @BeforeAll
+        void setUpServer() throws Exception {
+            if (FtpsProviderImplicitTestCase.getSystemTestUriOverride() == null) {
+                try {
+                    FtpsProviderImplicitTestCase.setUpClass(true); // implicit mode
+                } catch (final FtpException e) {
+                    // Server failed to start - abort all tests in this class
+                    throw new TestAbortedException("FTP server failed to start: " + e.getMessage(), e);
+                }
+            }
+        }
+
+        @Override
+        protected void setUp() throws Exception {
+            try {
+                super.setUp();
+            } catch (final FileSystemException e) {
+                // Could not connect to FTP server - abort test
+                throw new TestAbortedException("Could not connect to FTP server: " + e.getMessage(), e);
+            }
+        }
+
+        @AfterAll
+        void tearDownServer() throws Exception {
+            try {
+                tearDown();
+            } finally {
+                FtpsProviderImplicitTestCase.tearDownClass();
+            }
+        }
+    }
+}
+