Add SSL initialization tests

Added TestSSL with 10 tests for SSL initialization, OpenSSL version
detection, FIPS mode checking, error handling, and validation of SSL
constants including protocol modes, flags, and verification levels.

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: csutherl

test/org/apache/tomcat/jni/TestSSL.java

@@ -0,0 +1,135 @@
+/*
+ * 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
+ *
+ *      http://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.tomcat.jni;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * Tests for SSL initialization and basic operations.
+ */
+public class TestSSL extends BaseTest {
+
+    @Before
+    public void checkLibrary() {
+        requireLibrary();
+    }
+
+    @Test
+    public void testSSLInitialization() throws Exception {
+        // SSL.initialize should be safe to call multiple times
+        int result = SSL.initialize(null);
+        Assert.assertEquals("SSL initialization should succeed", 0, result);
+    }
+
+    @Test
+    public void testSSLVersion() {
+        int version = SSL.version();
+        Assert.assertTrue("OpenSSL version should be positive", version > 0);
+
+        // OpenSSL 3.x should have version >= 0x30000000
+        // But we'll just check it's reasonable
+        Assert.assertTrue("OpenSSL version should be reasonable", version > 0x10000000);
+    }
+
+    @Test
+    public void testSSLVersionString() {
+        String versionString = SSL.versionString();
+        Assert.assertNotNull("Version string should not be null", versionString);
+        Assert.assertTrue("Version string should not be empty", versionString.length() > 0);
+
+        // Should contain "OpenSSL"
+        Assert.assertTrue("Version string should contain OpenSSL",
+            versionString.toUpperCase().contains("OPENSSL"));
+    }
+
+    @Test
+    public void testFIPSModeGet() throws Exception {
+        // Just verify we can call this without crashing
+        // It may throw if FIPS is not available, which is fine
+        try {
+            int fipsMode = SSL.fipsModeGet();
+            Assert.assertTrue("FIPS mode should be 0 or 1", fipsMode == 0 || fipsMode == 1);
+        } catch (Exception e) {
+            // FIPS may not be available - that's acceptable
+            Assert.assertTrue("FIPS not available is acceptable", true);
+        }
+    }
+
+    @Test
+    public void testErrorStringHandling() {
+        // Get an error string for error code 0 (no error)
+        String errorString = SSL.getErrorString(0);
+        Assert.assertNotNull("Error string should not be null even for code 0", errorString);
+    }
+
+    @Test
+    public void testLastErrorNumber() {
+        // Should be able to get last error number without crashing
+        int lastError = SSL.getLastErrorNumber();
+        // Error number 0 means no error
+        Assert.assertTrue("Last error number should be non-negative", lastError >= 0);
+    }
+
+    @Test
+    public void testSSLConstants() {
+        // Verify important constants are defined correctly
+        Assert.assertEquals("SSL_PROTOCOL_NONE should be 0", 0, SSL.SSL_PROTOCOL_NONE);
+        Assert.assertEquals("SSL_MODE_CLIENT should be 0", 0, SSL.SSL_MODE_CLIENT);
+        Assert.assertEquals("SSL_MODE_SERVER should be 1", 1, SSL.SSL_MODE_SERVER);
+        Assert.assertEquals("SSL_MODE_COMBINED should be 2", 2, SSL.SSL_MODE_COMBINED);
+
+        // Verify protocol flags are powers of 2 (bitfields)
+        Assert.assertEquals("SSL_PROTOCOL_TLSV1 should be 0x04", 0x04, SSL.SSL_PROTOCOL_TLSV1);
+        Assert.assertEquals("SSL_PROTOCOL_TLSV1_1 should be 0x08", 0x08, SSL.SSL_PROTOCOL_TLSV1_1);
+        Assert.assertEquals("SSL_PROTOCOL_TLSV1_2 should be 0x10", 0x10, SSL.SSL_PROTOCOL_TLSV1_2);
+        Assert.assertEquals("SSL_PROTOCOL_TLSV1_3 should be 0x20", 0x20, SSL.SSL_PROTOCOL_TLSV1_3);
+
+        // Verify SSL_PROTOCOL_ALL includes modern TLS versions
+        int allProtocols = SSL.SSL_PROTOCOL_ALL;
+        Assert.assertTrue("SSL_PROTOCOL_ALL should include TLSv1",
+            (allProtocols & SSL.SSL_PROTOCOL_TLSV1) != 0);
+        Assert.assertTrue("SSL_PROTOCOL_ALL should include TLSv1.3",
+            (allProtocols & SSL.SSL_PROTOCOL_TLSV1_3) != 0);
+    }
+
+    @Test
+    public void testSSLVerifyConstants() {
+        // Test verification level constants
+        Assert.assertEquals("SSL_CVERIFY_NONE should be 0", 0, SSL.SSL_CVERIFY_NONE);
+        Assert.assertEquals("SSL_CVERIFY_OPTIONAL should be 1", 1, SSL.SSL_CVERIFY_OPTIONAL);
+        Assert.assertEquals("SSL_CVERIFY_REQUIRE should be 2", 2, SSL.SSL_CVERIFY_REQUIRE);
+        Assert.assertEquals("SSL_CVERIFY_OPTIONAL_NO_CA should be 3", 3, SSL.SSL_CVERIFY_OPTIONAL_NO_CA);
+    }
+
+    @Test
+    public void testSSLErrorConstants() {
+        // Verify error code constants
+        Assert.assertEquals("SSL_ERROR_NONE should be 0", 0, SSL.SSL_ERROR_NONE);
+        Assert.assertEquals("SSL_ERROR_SSL should be 1", 1, SSL.SSL_ERROR_SSL);
+        Assert.assertEquals("SSL_ERROR_WANT_READ should be 2", 2, SSL.SSL_ERROR_WANT_READ);
+        Assert.assertEquals("SSL_ERROR_WANT_WRITE should be 3", 3, SSL.SSL_ERROR_WANT_WRITE);
+    }
+
+    @Test
+    public void testSSLSessionCacheConstants() {
+        // Verify session cache mode constants
+        Assert.assertEquals("SSL_SESS_CACHE_OFF should be 0", 0, SSL.SSL_SESS_CACHE_OFF);
+        Assert.assertEquals("SSL_SESS_CACHE_SERVER should be 2", 2, SSL.SSL_SESS_CACHE_SERVER);
+    }
+}