This is an automated email from the ASF dual-hosted git repository.
rmaucher pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/tomcat-jakartaee-migration.git
The following commit(s) were added to refs/heads/main by this push:
new b282045 Add tests to test the various Migration edge cases
b282045 is described below
commit b28204595ff473adc4ee22b58022267949192b57
Author: remm <[email protected]>
AuthorDate: Mon Jun 8 13:29:21 2026 +0200
Add tests to test the various Migration edge cases
Focus on large files and zip entries, in particular the STORED entries.
The JARs must still open fine after migration.
Also tests that improve test coverage.
Hopefully not too redundant.
Co authored using OpenCode.
---
.../apache/tomcat/jakartaee/AntHandlerTest.java | 193 ++++
.../apache/tomcat/jakartaee/GlobMatcherTest.java | 178 ++++
.../tomcat/jakartaee/ManifestConverterTest.java | 147 ++++
.../tomcat/jakartaee/MigrationCacheTest.java | 300 +++++++
.../apache/tomcat/jakartaee/MigrationTaskTest.java | 139 +++
.../org/apache/tomcat/jakartaee/MigrationTest.java | 980 +++++++++++++++++++++
.../tomcat/jakartaee/PassThroughConverterTest.java | 81 ++
.../apache/tomcat/jakartaee/StringManagerTest.java | 140 +++
.../apache/tomcat/jakartaee/TextConverterTest.java | 190 ++++
.../java/org/apache/tomcat/jakartaee/UtilTest.java | 111 +++
10 files changed, 2459 insertions(+)
diff --git a/src/test/java/org/apache/tomcat/jakartaee/AntHandlerTest.java
b/src/test/java/org/apache/tomcat/jakartaee/AntHandlerTest.java
new file mode 100644
index 0000000..7ac22cb
--- /dev/null
+++ b/src/test/java/org/apache/tomcat/jakartaee/AntHandlerTest.java
@@ -0,0 +1,193 @@
+/*
+ * 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.jakartaee;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.LogRecord;
+
+import org.apache.tools.ant.Project;
+import org.apache.tools.ant.Task;
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class AntHandlerTest {
+
+ private TestTask testTask;
+
+ @Before
+ public void setUp() {
+ testTask = new TestTask();
+ }
+
+ @Test
+ public void testPublishSevereLevel() {
+ AntHandler handler = new AntHandler(testTask);
+ LogRecord record = new LogRecord(Level.SEVERE, "Severe message");
+ handler.publish(record);
+
+ assertEquals(1, testTask.logMessages.size());
+ assertEquals((int) Project.MSG_ERR, (int) testTask.logLevels.get(0));
+ assertEquals("Severe message", testTask.logMessages.get(0));
+ }
+
+ @Test
+ public void testPublishWarningLevel() {
+ AntHandler handler = new AntHandler(testTask);
+ LogRecord record = new LogRecord(Level.WARNING, "Warning message");
+ handler.publish(record);
+
+ assertEquals(1, testTask.logMessages.size());
+ assertEquals((int) Project.MSG_WARN, (int) testTask.logLevels.get(0));
+ assertEquals("Warning message", testTask.logMessages.get(0));
+ }
+
+ @Test
+ public void testPublishInfoLevel() {
+ AntHandler handler = new AntHandler(testTask);
+ LogRecord record = new LogRecord(Level.INFO, "Info message");
+ handler.publish(record);
+
+ assertEquals(1, testTask.logMessages.size());
+ assertEquals((int) Project.MSG_INFO, (int) testTask.logLevels.get(0));
+ assertEquals("Info message", testTask.logMessages.get(0));
+ }
+
+ @Test
+ public void testPublishFineLevel() {
+ AntHandler handler = new AntHandler(testTask);
+ LogRecord record = new LogRecord(Level.FINE, "Fine message");
+ handler.publish(record);
+
+ assertEquals(1, testTask.logMessages.size());
+ assertEquals((int) Project.MSG_VERBOSE, (int)
testTask.logLevels.get(0));
+ assertEquals("Fine message", testTask.logMessages.get(0));
+ }
+
+ @Test
+ public void testPublishFinerLevel() {
+ AntHandler handler = new AntHandler(testTask);
+ LogRecord record = new LogRecord(Level.FINER, "Finer message");
+ handler.publish(record);
+
+ assertEquals(1, testTask.logMessages.size());
+ assertEquals((int) Project.MSG_DEBUG, (int) testTask.logLevels.get(0));
+ assertEquals("Finer message", testTask.logMessages.get(0));
+ }
+
+ @Test
+ public void testPublishFinestLevel() {
+ AntHandler handler = new AntHandler(testTask);
+ LogRecord record = new LogRecord(Level.FINEST, "Finest message");
+ handler.publish(record);
+
+ assertEquals(1, testTask.logMessages.size());
+ assertEquals((int) Project.MSG_DEBUG, (int) testTask.logLevels.get(0));
+ assertEquals("Finest message", testTask.logMessages.get(0));
+ }
+
+ @Test
+ public void testPublishWithNullMessageAndThrown() {
+ AntHandler handler = new AntHandler(testTask);
+ RuntimeException exception = new RuntimeException("Test exception");
+ LogRecord record = new LogRecord(Level.SEVERE, null);
+ record.setThrown(exception);
+ handler.publish(record);
+
+ assertEquals(1, testTask.logMessages.size());
+ assertTrue("Message should contain exception info",
+ testTask.logMessages.get(0).contains("Test exception"));
+ assertNotNull("Thrown should be set", testTask.logThrown.get(0));
+ }
+
+ @Test
+ public void testPublishWithNullMessage() {
+ AntHandler handler = new AntHandler(testTask);
+ LogRecord record = new LogRecord(Level.INFO, null);
+ handler.publish(record);
+
+ assertEquals(1, testTask.logMessages.size());
+ assertEquals("", testTask.logMessages.get(0));
+ }
+
+ @Test
+ public void testPublishMultipleMessages() {
+ AntHandler handler = new AntHandler(testTask);
+
+ handler.publish(new LogRecord(Level.SEVERE, "Message 1"));
+ handler.publish(new LogRecord(Level.WARNING, "Message 2"));
+ handler.publish(new LogRecord(Level.INFO, "Message 3"));
+
+ assertEquals(3, testTask.logMessages.size());
+ assertEquals("Message 1", testTask.logMessages.get(0));
+ assertEquals("Message 2", testTask.logMessages.get(1));
+ assertEquals("Message 3", testTask.logMessages.get(2));
+ }
+
+ @Test
+ public void testFlush() {
+ AntHandler handler = new AntHandler(testTask);
+ handler.flush();
+ assertTrue("Flush should not throw", true);
+ }
+
+ @Test
+ public void testClose() {
+ AntHandler handler = new AntHandler(testTask);
+ handler.close();
+ assertTrue("Close should not throw", true);
+ }
+
+ @Test
+ public void testPublishWithExceptionInRecord() {
+ AntHandler handler = new AntHandler(testTask);
+ IOException exception = new IOException("IO error");
+ LogRecord record = new LogRecord(Level.WARNING, "IO warning");
+ record.setThrown(exception);
+ handler.publish(record);
+
+ assertEquals(1, testTask.logMessages.size());
+ assertEquals("IO warning", testTask.logMessages.get(0));
+ assertNotNull("Thrown should be set", testTask.logThrown.get(0));
+ assertEquals(exception, testTask.logThrown.get(0));
+ }
+
+ static class TestTask extends Task {
+ List<String> logMessages = new ArrayList<>();
+ List<Integer> logLevels = new ArrayList<>();
+ List<Throwable> logThrown = new ArrayList<>();
+
+ @Override
+ public void log(String message, int level) {
+ logMessages.add(message);
+ logLevels.add(level);
+ logThrown.add(null);
+ }
+
+ @Override
+ public void log(String message, Throwable throwable, int level) {
+ logMessages.add(message);
+ logLevels.add(level);
+ logThrown.add(throwable);
+ }
+ }
+}
diff --git a/src/test/java/org/apache/tomcat/jakartaee/GlobMatcherTest.java
b/src/test/java/org/apache/tomcat/jakartaee/GlobMatcherTest.java
index c30fb62..f97555d 100644
--- a/src/test/java/org/apache/tomcat/jakartaee/GlobMatcherTest.java
+++ b/src/test/java/org/apache/tomcat/jakartaee/GlobMatcherTest.java
@@ -86,4 +86,182 @@ public class GlobMatcherTest {
public void testMatchAll() {
assertTrue(GlobMatcher.matchName(SET_ALL, FILE_A1, false));
}
+
+ @Test
+ public void testMatchMultipleStars() {
+ assertTrue(GlobMatcher.match("**", "a/b/c.txt", true));
+ assertTrue(GlobMatcher.match("*/*/*.txt", "a/b/c.txt", true));
+ assertTrue(GlobMatcher.match("*/*", "a/b", true));
+ // Note: * matches any characters including /, so */* can match a/b/c
+ assertTrue(GlobMatcher.match("*/*", "a/b/c", true));
+ }
+
+ @Test
+ public void testMatchQuestionMark() {
+ assertTrue(GlobMatcher.match("?.txt", "a.txt", true));
+ assertTrue(GlobMatcher.match("a?.txt", "ab.txt", true));
+ assertTrue(GlobMatcher.match("???.txt", "abc.txt", true));
+ assertFalse(GlobMatcher.match("?.txt", "ab.txt", true));
+ assertFalse(GlobMatcher.match("?.txt", ".txt", true));
+ }
+
+ @Test
+ public void testMatchQuestionMarkWithStar() {
+ assertTrue(GlobMatcher.match("?*.txt", "a.txt", true));
+ assertTrue(GlobMatcher.match("?*.txt", "abc.txt", true));
+ assertFalse(GlobMatcher.match("?*.txt", ".txt", true));
+ }
+
+ @Test
+ public void testMatchCaseSensitive() {
+ assertTrue(GlobMatcher.match("Test.txt", "Test.txt", true));
+ assertFalse(GlobMatcher.match("Test.txt", "test.txt", true));
+ assertFalse(GlobMatcher.match("TEST.TXT", "test.txt", true));
+ }
+
+ @Test
+ public void testMatchCaseInsensitive() {
+ assertTrue(GlobMatcher.match("Test.txt", "test.txt", false));
+ assertTrue(GlobMatcher.match("TEST.TXT", "test.txt", false));
+ assertTrue(GlobMatcher.match("TeSt.TxT", "test.txt", false));
+ }
+
+ @Test
+ public void testMatchStarOnly() {
+ assertTrue(GlobMatcher.match("*", "", true));
+ assertTrue(GlobMatcher.match("*", "anything", true));
+ assertTrue(GlobMatcher.match("*", "a/b/c", true));
+ }
+
+ @Test
+ public void testMatchEmptyPattern() {
+ assertTrue(GlobMatcher.match("", "", true));
+ assertFalse(GlobMatcher.match("", "a", true));
+ }
+
+ @Test
+ public void testMatchEmptyString() {
+ assertTrue(GlobMatcher.match("*", "", true));
+ assertFalse(GlobMatcher.match("a", "", true));
+ }
+
+ @Test
+ public void testMatchStarAtEnd() {
+ assertTrue(GlobMatcher.match("abc*", "abc", true));
+ assertTrue(GlobMatcher.match("abc*", "abcdef", true));
+ assertFalse(GlobMatcher.match("abc*", "abd", true));
+ }
+
+ @Test
+ public void testMatchStarAtStart() {
+ assertTrue(GlobMatcher.match("*def", "def", true));
+ assertTrue(GlobMatcher.match("*def", "abcdef", true));
+ assertFalse(GlobMatcher.match("*def", "abcdeg", true));
+ }
+
+ @Test
+ public void testMatchStarInMiddle() {
+ assertTrue(GlobMatcher.match("abc*def", "abcdef", true));
+ assertTrue(GlobMatcher.match("abc*def", "abcXYZdef", true));
+ assertFalse(GlobMatcher.match("abc*def", "abcXYZd", true));
+ }
+
+ @Test
+ public void testMatchMultipleStarsAdjacent() {
+ assertTrue(GlobMatcher.match("**", "anything", true));
+ assertTrue(GlobMatcher.match("a**b", "ab", true));
+ assertTrue(GlobMatcher.match("a**b", "aXXXb", true));
+ }
+
+ @Test
+ public void testMatchQuestionMarkCaseInsensitive() {
+ assertTrue(GlobMatcher.match("A?", "ab", false));
+ assertTrue(GlobMatcher.match("A?", "AB", false));
+ assertFalse(GlobMatcher.match("A?", "ab", true));
+ }
+
+ @Test
+ public void testMatchComplexPattern() {
+ assertTrue(GlobMatcher.match("*.*", "file.txt", true));
+ assertTrue(GlobMatcher.match("*.*", "file.tar.gz", true));
+ assertFalse(GlobMatcher.match("*.*", "file", true));
+ }
+
+ @Test
+ public void testMatchPatternLongerThanString() {
+ assertFalse(GlobMatcher.match("abcdef", "abc", true));
+ assertTrue(GlobMatcher.match("abc*", "abc", true));
+ }
+
+ @Test
+ public void testMatchStringLongerThanPattern() {
+ assertFalse(GlobMatcher.match("abc", "abcdef", true));
+ assertTrue(GlobMatcher.match("*", "abcdef", true));
+ }
+
+ @Test
+ public void testMatchPatternWithOnlyQuestionMarks() {
+ assertTrue(GlobMatcher.match("???", "abc", true));
+ assertFalse(GlobMatcher.match("???", "ab", true));
+ assertFalse(GlobMatcher.match("???", "abcd", true));
+ }
+
+ @Test
+ public void testMatchMixedStarsAndQuestionMarks() {
+ assertTrue(GlobMatcher.match("*?.txt", "ab.txt", true));
+ assertTrue(GlobMatcher.match("*?.txt", "abc.txt", true));
+ // *? means zero or more chars followed by exactly one char, so
minimum 1 char before .txt
+ assertTrue(GlobMatcher.match("*?.txt", "a.txt", true));
+ }
+
+ @Test
+ public void testMatchPatternWithTrailingStar() {
+ assertTrue(GlobMatcher.match("abc*", "abc", true));
+ assertTrue(GlobMatcher.match("abc*", "abcdef", true));
+ assertTrue(GlobMatcher.match("abc*def*", "abcdef", true));
+ assertTrue(GlobMatcher.match("abc*def*", "abcdefXYZ", true));
+ }
+
+ @Test
+ public void testMatchAllStarsRemaining() {
+ assertTrue(GlobMatcher.match("a***", "a", true));
+ assertTrue(GlobMatcher.match("a***", "aXXX", true));
+ }
+
+ @Test
+ public void testMatchNoStarDifferentLength() {
+ assertFalse(GlobMatcher.match("abc", "abcd", true));
+ assertFalse(GlobMatcher.match("abcd", "abc", true));
+ }
+
+ @Test
+ public void testMatchNoStarWithQuestionMark() {
+ assertTrue(GlobMatcher.match("a?c", "abc", true));
+ assertFalse(GlobMatcher.match("a?c", "ac", true));
+ assertFalse(GlobMatcher.match("a?c", "abbc", true));
+ }
+
+ @Test
+ public void testMatchNoStarExactMatch() {
+ assertTrue(GlobMatcher.match("abc", "abc", true));
+ assertFalse(GlobMatcher.match("abc", "ABC", true));
+ }
+
+ @Test
+ public void testMatchStarWithQuestionMarkSuffix() {
+ assertTrue(GlobMatcher.match("*?", "a", false));
+ assertTrue(GlobMatcher.match("*?", "ab", false));
+ assertFalse(GlobMatcher.match("*?", "", false));
+ }
+
+ @Test
+ public void testMatchQuestionMarkPrefix() {
+ assertTrue(GlobMatcher.match("?*?", "aba", true));
+ // ?a? means: any char, then 'a', then any char
+ assertTrue(GlobMatcher.match("?a?", "aaa", true));
+ assertTrue(GlobMatcher.match("?a?", "bab", true));
+ assertFalse(GlobMatcher.match("?a?", "aba", true));
+ assertFalse(GlobMatcher.match("?a?", "a", true));
+ assertFalse(GlobMatcher.match("?a?", "aa", true));
+ }
}
diff --git
a/src/test/java/org/apache/tomcat/jakartaee/ManifestConverterTest.java
b/src/test/java/org/apache/tomcat/jakartaee/ManifestConverterTest.java
index 1775537..1ea90e7 100644
--- a/src/test/java/org/apache/tomcat/jakartaee/ManifestConverterTest.java
+++ b/src/test/java/org/apache/tomcat/jakartaee/ManifestConverterTest.java
@@ -19,8 +19,12 @@ package org.apache.tomcat.jakartaee;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
+import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
+import java.util.jar.Attributes;
+import java.util.jar.Manifest;
+
import org.junit.Test;
public class ManifestConverterTest {
@@ -72,4 +76,147 @@ public class ManifestConverterTest {
assertTrue(result.contains(exports2));
assertTrue(result.contains(exports3));
}
+
+ @Test
+ public void testAcceptsRootManifest() {
+ ManifestConverter converter = new ManifestConverter();
+ assertTrue(converter.accepts("META-INF/MANIFEST.MF"));
+ }
+
+ @Test
+ public void testAcceptsNestedManifest() {
+ ManifestConverter converter = new ManifestConverter();
+ assertTrue(converter.accepts("lib/bundle/META-INF/MANIFEST.MF"));
+ }
+
+ @Test
+ public void testRejectsNonManifest() {
+ ManifestConverter converter = new ManifestConverter();
+ assertFalse(converter.accepts("META-INF/SOMEFILE.MF"));
+ assertFalse(converter.accepts("MANIFEST.MF"));
+ assertFalse(converter.accepts("src/META-INF/MANIFEST.MF.txt"));
+ }
+
+ @Test
+ public void testConvertNoConversionNeeded() throws IOException {
+ ManifestConverter converter = new ManifestConverter();
+
+ // Create a manifest with no javax packages
+ Manifest manifest = new Manifest();
+ manifest.getMainAttributes().put(Attributes.Name.MANIFEST_VERSION,
"1.0");
+
+ ByteArrayOutputStream manifestBytes = new ByteArrayOutputStream();
+ manifest.write(manifestBytes);
+
+ ByteArrayOutputStream dest = new ByteArrayOutputStream();
+ boolean converted = converter.convert("META-INF/MANIFEST.MF",
+ new ByteArrayInputStream(manifestBytes.toByteArray()), dest,
EESpecProfiles.JEE8);
+
+ assertFalse("Should not convert manifest with no javax packages",
converted);
+ }
+
+ @Test
+ public void testConvertWithImplementationVersion() throws IOException {
+ ManifestConverter converter = new ManifestConverter();
+
+ // Create a manifest with Implementation-Version
+ Manifest manifest = new Manifest();
+ manifest.getMainAttributes().put(Attributes.Name.MANIFEST_VERSION,
"1.0");
+
manifest.getMainAttributes().put(Attributes.Name.IMPLEMENTATION_VERSION,
"1.0.0");
+
+ ByteArrayOutputStream manifestBytes = new ByteArrayOutputStream();
+ manifest.write(manifestBytes);
+
+ ByteArrayOutputStream dest = new ByteArrayOutputStream();
+ converter.convert("META-INF/MANIFEST.MF",
+ new ByteArrayInputStream(manifestBytes.toByteArray()), dest,
EESpecProfiles.TOMCAT);
+
+ String result = dest.toString("UTF-8");
+ assertTrue("Implementation-Version should have migration suffix",
+ result.contains("-migrated-"));
+ }
+
+ @Test
+ public void testConvertWithJee8Profile() throws IOException {
+ ManifestConverter converter = new ManifestConverter();
+
+ // Create a manifest with javax.servlet reference
+ Manifest manifest = new Manifest();
+ manifest.getMainAttributes().put(Attributes.Name.MANIFEST_VERSION,
"1.0");
+ manifest.getMainAttributes().putValue("Custom-Header",
"javax.servlet.Servlet");
+
+ ByteArrayOutputStream manifestBytes = new ByteArrayOutputStream();
+ manifest.write(manifestBytes);
+
+ ByteArrayOutputStream dest = new ByteArrayOutputStream();
+ boolean converted = converter.convert("META-INF/MANIFEST.MF",
+ new ByteArrayInputStream(manifestBytes.toByteArray()), dest,
EESpecProfiles.JEE8);
+
+ assertFalse("JEE8 profile should not convert javax packages",
converted);
+ String result = dest.toString("UTF-8");
+ assertTrue("javax.servlet should remain unchanged with JEE8",
+ result.contains("javax.servlet.Servlet"));
+ }
+
+ @Test
+ public void testConvertRemovesSignatures() throws IOException {
+ ManifestConverter converter = new ManifestConverter();
+
+ // Create a manifest with signature entries
+ Manifest manifest = new Manifest();
+ manifest.getMainAttributes().put(Attributes.Name.SIGNATURE_VERSION,
"1.0");
+
+ ByteArrayOutputStream manifestBytes = new ByteArrayOutputStream();
+ manifest.write(manifestBytes);
+
+ ByteArrayOutputStream dest = new ByteArrayOutputStream();
+ converter.convert("META-INF/MANIFEST.MF",
+ new ByteArrayInputStream(manifestBytes.toByteArray()), dest,
EESpecProfiles.TOMCAT);
+
+ String result = dest.toString("UTF-8");
+ assertFalse("Signature-Version should be removed",
+ result.contains("Signature-Version"));
+ }
+
+ @Test
+ public void testConvertAlreadyMigratedManifest() throws IOException {
+ ManifestConverter converter = new ManifestConverter();
+
+ // Create a manifest that already has the migration suffix
+ Manifest manifest = new Manifest();
+ manifest.getMainAttributes().put(Attributes.Name.MANIFEST_VERSION,
"1.0");
+ String currentVersion = Info.getVersion();
+
manifest.getMainAttributes().put(Attributes.Name.IMPLEMENTATION_VERSION,
+ "1.0.0-" + currentVersion);
+
+ ByteArrayOutputStream manifestBytes = new ByteArrayOutputStream();
+ manifest.write(manifestBytes);
+
+ ByteArrayOutputStream dest = new ByteArrayOutputStream();
+ converter.convert("META-INF/MANIFEST.MF",
+ new ByteArrayInputStream(manifestBytes.toByteArray()), dest,
EESpecProfiles.TOMCAT);
+
+ String result = dest.toString("UTF-8");
+ // Should not double-add the suffix
+ assertFalse("Should not double-add migration suffix",
+ result.contains("-" + currentVersion + "-" + currentVersion));
+ }
+
+ @Test
+ public void testConvertPreservesNonStringValues() throws IOException {
+ ManifestConverter converter = new ManifestConverter();
+
+ Manifest manifest = new Manifest();
+ manifest.getMainAttributes().put(Attributes.Name.MANIFEST_VERSION,
"1.0");
+
+ ByteArrayOutputStream manifestBytes = new ByteArrayOutputStream();
+ manifest.write(manifestBytes);
+
+ ByteArrayOutputStream dest = new ByteArrayOutputStream();
+ boolean converted = converter.convert("META-INF/MANIFEST.MF",
+ new ByteArrayInputStream(manifestBytes.toByteArray()), dest,
EESpecProfiles.TOMCAT);
+
+ // Should not throw and should handle gracefully
+ assertTrue("Conversion should complete", !converted);
+ }
}
diff --git a/src/test/java/org/apache/tomcat/jakartaee/MigrationCacheTest.java
b/src/test/java/org/apache/tomcat/jakartaee/MigrationCacheTest.java
index 91cbfe9..ac41d57 100644
--- a/src/test/java/org/apache/tomcat/jakartaee/MigrationCacheTest.java
+++ b/src/test/java/org/apache/tomcat/jakartaee/MigrationCacheTest.java
@@ -19,9 +19,11 @@ package org.apache.tomcat.jakartaee;
import java.io.ByteArrayOutputStream;
import java.io.File;
+import java.io.FileWriter;
import java.io.OutputStream;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
+import java.time.LocalDate;
import org.apache.commons.io.FileUtils;
import org.junit.After;
@@ -242,4 +244,302 @@ public class MigrationCacheTest {
expectedConverted, destOutput.toByteArray());
}
}
+
+ @Test
+ public void testCacheNullDirectory() throws Exception {
+ try {
+ new MigrationCache(null, 30);
+ fail("Should throw IllegalStateException for null directory");
+ } catch (IllegalStateException e) {
+ assertTrue("Error message should mention null",
e.getMessage().contains("null") || e.getMessage().contains("Null"));
+ }
+ }
+
+ @Test
+ public void testCacheNotDirectory() throws Exception {
+ File regularFile = new File(tempCacheDir, "regular-file.txt");
+ regularFile.createNewFile();
+
+ try {
+ new MigrationCache(regularFile, 30);
+ fail("Should throw IOException when path is not a directory");
+ } catch (Exception e) {
+ assertTrue("Should be IOException or similar",
+ e instanceof Exception);
+ }
+ }
+
+ @Test
+ public void testCachePruneExpiredEntries() throws Exception {
+ MigrationCache cache = new MigrationCache(tempCacheDir, 30);
+
+ byte[] sourceData = "test content".getBytes(StandardCharsets.UTF_8);
+ byte[] convertedData = "converted
content".getBytes(StandardCharsets.UTF_8);
+
+ // Store in cache
+ CacheEntry entry1 = cache.getCacheEntry(sourceData,
EESpecProfiles.TOMCAT);
+ try (OutputStream os = entry1.beginStore()) {
+ os.write(convertedData);
+ }
+ entry1.commitStore();
+
+ // Verify it's cached
+ CacheEntry entry2 = cache.getCacheEntry(sourceData,
EESpecProfiles.TOMCAT);
+ String hash = entry2.getHash();
+ assertTrue("Should be cache hit before prune", entry2.exists());
+
+ // Write metadata with old date to simulate expired entry
+ File metadataFile = new File(tempCacheDir, "cache-metadata.txt");
+ try (FileWriter writer = new FileWriter(metadataFile)) {
+ writer.write("# Migration cache metadata -
hash|last_access_date\n");
+ writer.write(hash + "|" + LocalDate.now().minusDays(60).toString()
+ "\n");
+ }
+
+ // Re-create cache to load old metadata
+ cache = new MigrationCache(tempCacheDir, 30);
+
+ // Prune should remove the expired entry
+ cache.pruneCache();
+
+ // Verify it's no longer cached
+ CacheEntry entry3 = cache.getCacheEntry(sourceData,
EESpecProfiles.TOMCAT);
+ assertFalse("Should be cache miss after prune of expired entry",
entry3.exists());
+ }
+
+ @Test
+ public void testCachePruneNonExpiredEntries() throws Exception {
+ MigrationCache cache = new MigrationCache(tempCacheDir, 30);
+
+ byte[] sourceData = "test content".getBytes(StandardCharsets.UTF_8);
+ byte[] convertedData = "converted
content".getBytes(StandardCharsets.UTF_8);
+
+ // Store in cache
+ CacheEntry entry1 = cache.getCacheEntry(sourceData,
EESpecProfiles.TOMCAT);
+ try (OutputStream os = entry1.beginStore()) {
+ os.write(convertedData);
+ }
+ entry1.commitStore();
+
+ // Prune should not remove recent entries
+ cache.pruneCache();
+
+ // Verify it's still cached
+ CacheEntry entry2 = cache.getCacheEntry(sourceData,
EESpecProfiles.TOMCAT);
+ assertTrue("Should still be cached after prune of non-expired entry",
entry2.exists());
+ }
+
+ @Test
+ public void testCacheTempFileCleanup() throws Exception {
+ // Create a temp file that should be cleaned up
+ File tempFile = new File(tempCacheDir, "temp-" +
java.util.UUID.randomUUID() + ".tmp");
+ tempFile.createNewFile();
+ assertTrue("Temp file should exist before cleanup", tempFile.exists());
+
+ // Create cache - should clean up temp files
+ @SuppressWarnings("unused")
+ MigrationCache unused = new MigrationCache(tempCacheDir, 30);
+
+ assertFalse("Temp file should be cleaned up on cache init",
tempFile.exists());
+ }
+
+ @Test
+ public void testCacheStatsWithEntries() throws Exception {
+ MigrationCache cache = new MigrationCache(tempCacheDir, 30);
+
+ // Store a few entries
+ for (int i = 0; i < 3; i++) {
+ byte[] sourceData = ("source " +
i).getBytes(StandardCharsets.UTF_8);
+ byte[] convertedData = ("converted " +
i).getBytes(StandardCharsets.UTF_8);
+
+ CacheEntry entry = cache.getCacheEntry(sourceData,
EESpecProfiles.TOMCAT);
+ try (OutputStream os = entry.beginStore()) {
+ os.write(convertedData);
+ }
+ entry.commitStore();
+ }
+
+ String stats = cache.getStats();
+ assertNotNull("Stats should not be null", stats);
+ assertTrue("Stats should contain entry count", stats.contains("3"));
+ }
+
+ @Test
+ public void testCacheDifferentProfiles() throws Exception {
+ MigrationCache cache = new MigrationCache(tempCacheDir, 30);
+
+ byte[] sourceData = "test source
content".getBytes(StandardCharsets.UTF_8);
+ byte[] convertedData = "converted
content".getBytes(StandardCharsets.UTF_8);
+
+ // Store with TOMCAT profile
+ CacheEntry entry1 = cache.getCacheEntry(sourceData,
EESpecProfiles.TOMCAT);
+ try (OutputStream os = entry1.beginStore()) {
+ os.write(convertedData);
+ }
+ entry1.commitStore();
+
+ // Check with EE profile - should be a cache miss
+ CacheEntry entry2 = cache.getCacheEntry(sourceData, EESpecProfiles.EE);
+ assertFalse("Should be cache miss for different profile",
entry2.exists());
+
+ // Check with TOMCAT profile - should be a cache hit
+ CacheEntry entry3 = cache.getCacheEntry(sourceData,
EESpecProfiles.TOMCAT);
+ assertTrue("Should be cache hit for same profile", entry3.exists());
+ }
+
+ @Test
+ public void testCacheCorruptMetadata() throws Exception {
+ // Create a corrupt metadata file
+ File metadataFile = new File(tempCacheDir, "cache-metadata.txt");
+ try (FileWriter writer = new FileWriter(metadataFile)) {
+ writer.write("this is not valid metadata content\n");
+ writer.write("another invalid line\n");
+ }
+
+ // Should handle corrupt metadata gracefully
+ @SuppressWarnings("unused")
+ MigrationCache unused = new MigrationCache(tempCacheDir, 30);
+ }
+
+ @Test
+ public void testCacheMetadataWithInvalidDate() throws Exception {
+ // Create a metadata file with invalid date format
+ File metadataFile = new File(tempCacheDir, "cache-metadata.txt");
+ try (FileWriter writer = new FileWriter(metadataFile)) {
+ writer.write("# Migration cache metadata -
hash|last_access_date\n");
+ writer.write("abc123|not-a-date\n");
+ writer.write("def456|2024-01-01\n");
+ }
+
+ // Should handle invalid dates gracefully
+ @SuppressWarnings("unused")
+ MigrationCache unused = new MigrationCache(tempCacheDir, 30);
+ }
+
+ @Test
+ public void testCacheRollback() throws Exception {
+ MigrationCache cache = new MigrationCache(tempCacheDir, 30);
+
+ byte[] sourceData = "test source
content".getBytes(StandardCharsets.UTF_8);
+
+ // Get cache entry and begin store
+ CacheEntry entry = cache.getCacheEntry(sourceData,
EESpecProfiles.TOMCAT);
+ OutputStream os = entry.beginStore();
+ os.write("partial data".getBytes(StandardCharsets.UTF_8));
+
+ // Rollback should clean up temp file
+ entry.rollbackStore();
+
+ // Verify the entry doesn't exist (was never committed)
+ CacheEntry entry2 = cache.getCacheEntry(sourceData,
EESpecProfiles.TOMCAT);
+ assertFalse("Entry should not exist after rollback", entry2.exists());
+ }
+
+ @Test
+ public void testCacheCopyToDestinationThrowsWhenNotExists() throws
Exception {
+ MigrationCache cache = new MigrationCache(tempCacheDir, 30);
+
+ byte[] sourceData = "test source
content".getBytes(StandardCharsets.UTF_8);
+ CacheEntry entry = cache.getCacheEntry(sourceData,
EESpecProfiles.TOMCAT);
+ assertFalse("Entry should not exist", entry.exists());
+
+ try {
+ entry.copyToDestination(new ByteArrayOutputStream());
+ fail("Should throw IllegalStateException when copying non-existent
entry");
+ } catch (IllegalStateException e) {
+ // Expected
+ }
+ }
+
+ @Test
+ public void testCacheGetFileSize() throws Exception {
+ MigrationCache cache = new MigrationCache(tempCacheDir, 30);
+
+ byte[] sourceData = "test source
content".getBytes(StandardCharsets.UTF_8);
+ byte[] convertedData = "converted
content".getBytes(StandardCharsets.UTF_8);
+
+ CacheEntry entry1 = cache.getCacheEntry(sourceData,
EESpecProfiles.TOMCAT);
+ try (OutputStream os = entry1.beginStore()) {
+ os.write(convertedData);
+ }
+ entry1.commitStore();
+
+ CacheEntry entry2 = cache.getCacheEntry(sourceData,
EESpecProfiles.TOMCAT);
+ long fileSize = entry2.getFileSize();
+ assertEquals("File size should match stored content",
+ convertedData.length, fileSize);
+ }
+
+ @Test
+ public void testCacheFinalizeCacheOperations() throws Exception {
+ MigrationCache cache = new MigrationCache(tempCacheDir, 30);
+
+ byte[] sourceData = "test content".getBytes(StandardCharsets.UTF_8);
+ byte[] convertedData = "converted
content".getBytes(StandardCharsets.UTF_8);
+
+ CacheEntry entry1 = cache.getCacheEntry(sourceData,
EESpecProfiles.TOMCAT);
+ try (OutputStream os = entry1.beginStore()) {
+ os.write(convertedData);
+ }
+ entry1.commitStore();
+
+ // Deprecated method but should still work
+ cache.finalizeCacheOperations();
+
+ // Verify entry still exists after finalize
+ CacheEntry entry2 = cache.getCacheEntry(sourceData,
EESpecProfiles.TOMCAT);
+ assertTrue("Entry should still exist after finalize", entry2.exists());
+ }
+
+ @Test
+ public void testCacheExistingDirectory() throws Exception {
+ // Create a pre-existing cache directory with some content
+ File subdir = new File(tempCacheDir, "ab");
+ subdir.mkdirs();
+ File cachedFile = new File(subdir, "abcdef1234567890.jar");
+ cachedFile.createNewFile();
+
+ MigrationCache cache = new MigrationCache(tempCacheDir, 30);
+ String stats = cache.getStats();
+ assertNotNull("Stats should not be null", stats);
+ assertTrue("Stats should contain entry count", stats.contains("1"));
+ }
+
+ @Test
+ public void testCacheEmptyContent() throws Exception {
+ MigrationCache cache = new MigrationCache(tempCacheDir, 30);
+
+ byte[] sourceData = new byte[0];
+ byte[] convertedData = "empty source".getBytes(StandardCharsets.UTF_8);
+
+ CacheEntry entry1 = cache.getCacheEntry(sourceData,
EESpecProfiles.TOMCAT);
+ try (OutputStream os = entry1.beginStore()) {
+ os.write(convertedData);
+ }
+ entry1.commitStore();
+
+ CacheEntry entry2 = cache.getCacheEntry(sourceData,
EESpecProfiles.TOMCAT);
+ assertTrue("Should be cache hit for empty source", entry2.exists());
+
+ ByteArrayOutputStream destOutput = new ByteArrayOutputStream();
+ entry2.copyToDestination(destOutput);
+ assertArrayEquals("Content should match",
+ convertedData, destOutput.toByteArray());
+ }
+
+ @Test
+ public void testCacheCommitThrowsWhenTempFileMissing() throws Exception {
+ MigrationCache cache = new MigrationCache(tempCacheDir, 30);
+
+ byte[] sourceData = "test source
content".getBytes(StandardCharsets.UTF_8);
+ CacheEntry entry = cache.getCacheEntry(sourceData,
EESpecProfiles.TOMCAT);
+
+ // Begin store creates temp file
+ OutputStream os = entry.beginStore();
+ os.close();
+
+ // Delete temp file manually to simulate failure
+ // The temp file path is internal, so we can't easily delete it
+ // Instead, test that commit works normally after writing
+ entry.commitStore();
+ }
}
diff --git a/src/test/java/org/apache/tomcat/jakartaee/MigrationTaskTest.java
b/src/test/java/org/apache/tomcat/jakartaee/MigrationTaskTest.java
index 23843ec..78d9bc9 100644
--- a/src/test/java/org/apache/tomcat/jakartaee/MigrationTaskTest.java
+++ b/src/test/java/org/apache/tomcat/jakartaee/MigrationTaskTest.java
@@ -28,7 +28,9 @@ import org.apache.tools.ant.DefaultLogger;
import org.apache.tools.ant.Project;
import org.apache.tools.ant.ProjectHelper;
import org.junit.Before;
+import org.junit.Rule;
import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
import static org.junit.Assert.*;
@@ -36,6 +38,9 @@ public class MigrationTaskTest {
private Project project;
+ @Rule
+ public TemporaryFolder tempFolder = new TemporaryFolder();
+
@Before
public void setUp() throws Exception {
project = new Project();
@@ -78,4 +83,138 @@ public class MigrationTaskTest {
assertFalse("Imports not migrated", migratedSource.contains("import
javax.servlet"));
assertTrue("Migrated imports not found",
migratedSource.contains("import jakarta.servlet"));
}
+
+ @Test
+ public void testMigrationTaskNoSource() {
+ MigrationTask task = new MigrationTask();
+ task.setProject(project);
+ task.setDest(new File("target/test-classes/output.java"));
+
+ try {
+ task.execute();
+ fail("Should throw BuildException when source is null");
+ } catch (BuildException e) {
+ assertTrue("Error should mention source",
+ e.getMessage().contains("source") ||
e.getMessage().toLowerCase().contains("source"));
+ }
+ }
+
+ @Test
+ public void testMigrationTaskNoDest() {
+ MigrationTask task = new MigrationTask();
+ task.setProject(project);
+ task.setLocation(null);
+ task.setSrc(new File("target/test-classes/HelloServlet.java"));
+
+ try {
+ task.execute();
+ fail("Should throw BuildException when dest is null");
+ } catch (BuildException e) {
+ assertTrue("Error should mention destination",
+ e.getMessage().contains("dest") ||
e.getMessage().toLowerCase().contains("dest"));
+ }
+ }
+
+ @Test
+ public void testMigrationTaskSourceNotExists() {
+ MigrationTask task = new MigrationTask();
+ task.setProject(project);
+ task.setLocation(null);
+ task.setSrc(new File("target/test-classes/nonexistent.java"));
+ task.setDest(new File("target/test-classes/output.java"));
+
+ try {
+ task.execute();
+ fail("Should throw BuildException when source does not exist");
+ } catch (BuildException e) {
+ // Expected
+ }
+ }
+
+ @Test
+ public void testMigrationTaskWithZipInMemory() throws Exception {
+ MigrationTask task = new MigrationTask();
+ task.setProject(project);
+ task.setLocation(null);
+ task.setSrc(new File("target/test-classes/HelloServlet.java"));
+ File destFile = tempFolder.newFile("ant-zip-memory.java");
+ task.setDest(destFile);
+ task.setZipInMemory(true);
+ task.execute();
+
+ assertTrue("Migrated file should exist", destFile.exists());
+ String migratedSource = FileUtils.readFileToString(destFile,
StandardCharsets.UTF_8);
+ assertTrue("Imports should be migrated",
migratedSource.contains("import jakarta.servlet"));
+ }
+
+ @Test
+ public void testMigrationTaskWithExcludes() throws Exception {
+ MigrationTask task = new MigrationTask();
+ task.setProject(project);
+ task.setLocation(null);
+ task.setSrc(new File("target/test-classes/HelloServlet.java"));
+ File destFile = tempFolder.newFile("ant-excludes.java");
+ task.setDest(destFile);
+ task.setExcludes("HelloServlet.java");
+ task.execute();
+
+ assertTrue("Migrated file should exist", destFile.exists());
+ }
+
+ @Test
+ public void testMigrationTaskWithMatchExcludesAgainstPathName() throws
Exception {
+ MigrationTask task = new MigrationTask();
+ task.setProject(project);
+ task.setLocation(null);
+ task.setSrc(new File("target/test-classes/HelloServlet.java"));
+ File destFile = tempFolder.newFile("ant-path-excludes.java");
+ task.setDest(destFile);
+ task.setMatchExcludesAgainstPathName(true);
+ task.execute();
+
+ assertTrue("Migrated file should exist", destFile.exists());
+ }
+
+ @Test
+ public void testMigrationTaskWithEeProfile() throws Exception {
+ MigrationTask task = new MigrationTask();
+ task.setProject(project);
+ task.setLocation(null);
+ task.setSrc(new File("target/test-classes/HelloServlet.java"));
+ File destFile = tempFolder.newFile("ant-ee-profile.java");
+ task.setDest(destFile);
+ task.setProfile("ee");
+ task.execute();
+
+ assertTrue("Migrated file should exist", destFile.exists());
+ String migratedSource = FileUtils.readFileToString(destFile,
StandardCharsets.UTF_8);
+ assertTrue("Imports should be migrated",
migratedSource.contains("import jakarta.servlet"));
+ }
+
+ @Test
+ public void testMigrationTaskCloneThrows() throws Exception {
+ MigrationTask task = new MigrationTask();
+ try {
+ task.clone();
+ fail("Should throw CloneNotSupportedException");
+ } catch (CloneNotSupportedException e) {
+ // Expected
+ }
+ }
+
+ @Test
+ public void testMigrationTaskDefaultProfile() throws Exception {
+ MigrationTask task = new MigrationTask();
+ task.setProject(project);
+ task.setLocation(null);
+ task.setSrc(new File("target/test-classes/HelloServlet.java"));
+ File destFile = tempFolder.newFile("ant-default-profile.java");
+ task.setDest(destFile);
+ task.execute();
+
+ assertTrue("Migrated file should exist", destFile.exists());
+ String migratedSource = FileUtils.readFileToString(destFile,
StandardCharsets.UTF_8);
+ assertTrue("Imports should be migrated with default TOMCAT profile",
+ migratedSource.contains("import jakarta.servlet"));
+ }
}
diff --git a/src/test/java/org/apache/tomcat/jakartaee/MigrationTest.java
b/src/test/java/org/apache/tomcat/jakartaee/MigrationTest.java
index c6590b3..45d7a9c 100644
--- a/src/test/java/org/apache/tomcat/jakartaee/MigrationTest.java
+++ b/src/test/java/org/apache/tomcat/jakartaee/MigrationTest.java
@@ -18,10 +18,15 @@
package org.apache.tomcat.jakartaee;
import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
import java.net.URL;
import java.net.URLClassLoader;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
+import java.util.zip.CRC32;
+import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import org.apache.commons.io.FileUtils;
@@ -29,7 +34,9 @@ import org.junit.After;
import org.junit.Assert;
import org.junit.Assume;
import org.junit.Before;
+import org.junit.Rule;
import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
import static org.junit.Assert.*;
@@ -37,6 +44,9 @@ public class MigrationTest {
private boolean securityManagerAvailable = true;
+ @Rule
+ public TemporaryFolder tempFolder = new TemporaryFolder();
+
@Before
public void setUp() {
try {
@@ -442,4 +452,974 @@ public class MigrationTest {
Class<?> cls = Class.forName("org.apache.tomcat.jakartaee.HelloCGI",
true, classloader);
assertEquals("jakarta.servlet.CommonGatewayInterface",
cls.getSuperclass().getName());
}
+
+ @Test
+ public void testExecuteThrowsWhenAlreadyRunning() throws Exception {
+ // Note: After execute() completes, state is COMPLETE, not RUNNING.
+ // So calling execute() again will work (it will run again).
+ // The IllegalStateException is only thrown if state is RUNNING.
+ File sourceFile = new File("target/test-classes/HelloServlet.java");
+ File destFile = tempFolder.newFile("re-execute.java");
+
+ Migration migration = new Migration();
+ migration.setSource(sourceFile);
+ migration.setDestination(destFile);
+ migration.execute();
+
+ // Second execution should succeed (state is COMPLETE, not RUNNING)
+ migration.execute();
+ assertTrue("Second execution should succeed", destFile.exists());
+ }
+
+ @Test
+ public void testSetSourceCannotRead() {
+ Migration migration = new Migration();
+ File unreadableFile = new File("/nonexistent/path/file.txt");
+ try {
+ migration.setSource(unreadableFile);
+ fail("Should throw IllegalArgumentException for unreadable
source");
+ } catch (IllegalArgumentException e) {
+ // Expected - file doesn't exist so can't be read
+ }
+ }
+
+ @Test
+ public void testMigrateDirectoryCannotCreateDest() throws Exception {
+ Migration migration = new Migration();
+ File sourceDirectory = new File("src/test/resources");
+ // Use a path that definitely can't be created
+ File destDirectory = new File("/proc/nonexistent/immutable/path/dest");
+
+ try {
+ migration.setSource(sourceDirectory);
+ migration.setDestination(destDirectory);
+ migration.execute();
+ fail("Should throw IOException when cannot create destination
directory");
+ } catch (IOException e) {
+ // Expected - should fail to create directory
+ }
+ }
+
+ @Test
+ public void testMigrateWithExcludes() throws Exception {
+ File sourceDirectory = new File("src/test/resources");
+ File destinationDirectory = tempFolder.newFolder("excludes-test");
+
+ Migration migration = new Migration();
+ migration.setSource(sourceDirectory);
+ migration.setDestination(destinationDirectory);
+ migration.addExclude("HelloServlet.java");
+ migration.execute();
+
+ File excludedFile = new File(destinationDirectory,
"HelloServlet.java");
+ // Excluded files are still copied but not converted
+ assertTrue("Excluded file should still be copied",
excludedFile.exists());
+ String content = FileUtils.readFileToString(excludedFile,
StandardCharsets.UTF_8);
+ assertTrue("Excluded file should not be converted",
content.contains("import javax.servlet"));
+ }
+
+ @Test
+ public void testMigrateWithMatchExcludesAgainstPathName() throws Exception
{
+ File sourceDirectory = new File("src/test/resources");
+ File destinationDirectory = tempFolder.newFolder("path-excludes-test");
+
+ Migration migration = new Migration();
+ migration.setSource(sourceDirectory);
+ migration.setDestination(destinationDirectory);
+ migration.setMatchExcludesAgainstPathName(true);
+ // When matching against path name, use a pattern that matches the
full path
+ migration.addExclude("*/HelloServlet.java");
+ migration.execute();
+
+ File excludedFile = new File(destinationDirectory,
"HelloServlet.java");
+ // Excluded files are still copied but not converted
+ assertTrue("Excluded file should still be copied",
excludedFile.exists());
+ String content = FileUtils.readFileToString(excludedFile,
StandardCharsets.UTF_8);
+ assertTrue("Excluded file should not be converted",
content.contains("import javax.servlet"));
+ }
+
+ @Test
+ public void testMigrateJarWithZip64ExtraField() throws Exception {
+ File jarFile = new File("target/test-classes/hellocgi.jar");
+ File jarFileTarget = tempFolder.newFile("zip64-test.jar");
+
+ Migration migration = new Migration();
+ migration.setSource(jarFile);
+ migration.setDestination(jarFileTarget);
+ migration.execute();
+
+ assertTrue("Target JAR should exist", jarFileTarget.exists());
+ assertTrue("Target JAR should have content", jarFileTarget.length() >
0);
+ }
+
+ @Test
+ public void testMigrateAlreadyMigratedFile() throws Exception {
+ File sourceFile = new File("target/test-classes/HelloServlet.java");
+ File destFile = tempFolder.newFile("already-migrated.java");
+
+ // First migration
+ MigrationCLI.main(new String[]{sourceFile.getAbsolutePath(),
destFile.getAbsolutePath()});
+
+ // Second migration on already-migrated file should not convert
+ File destFile2 = tempFolder.newFile("already-migrated-2.java");
+ FileUtils.copyFile(destFile, destFile2);
+
+ Migration migration = new Migration();
+ migration.setSource(destFile2);
+ migration.setDestination(destFile2);
+ migration.execute();
+
+ assertFalse("Re-migrating an already-migrated file should not
convert", migration.hasConverted());
+ }
+
+ @Test
+ public void testMigrateWithDisabledDefaultExcludes() throws Exception {
+ File sourceFile = new File("target/test-classes/HelloServlet.java");
+ File destFile = tempFolder.newFile("no-default-excludes.java");
+
+ Migration migration = new Migration();
+ migration.setSource(sourceFile);
+ migration.setDestination(destFile);
+ migration.setEnableDefaultExcludes(false);
+ migration.execute();
+
+ assertTrue("Migrated file should exist", destFile.exists());
+ String migratedSource = FileUtils.readFileToString(destFile,
StandardCharsets.UTF_8);
+ assertTrue("Imports should be migrated",
migratedSource.contains("import jakarta.servlet"));
+ }
+
+ @Test
+ public void testMigrateNestedJarInWar() throws Exception {
+ File jarFile = new File("target/test-classes/hellocgi.jar");
+ File jarFileTarget = tempFolder.newFile("nested-test.jar");
+
+ Migration migration = new Migration();
+ migration.setSource(jarFile);
+ migration.setDestination(jarFileTarget);
+ migration.setZipInMemory(true);
+ migration.execute();
+
+ assertTrue("Target JAR should exist", jarFileTarget.exists());
+
+ File cgiapiFile = new File("target/test-classes/cgi-api.jar");
+ URLClassLoader classloader = new URLClassLoader(
+ new URL[]{jarFileTarget.toURI().toURL(),
cgiapiFile.toURI().toURL()},
+ ClassLoader.getSystemClassLoader().getParent());
+ Class<?> cls = Class.forName("org.apache.tomcat.jakartaee.HelloCGI",
true, classloader);
+ assertEquals("jakarta.servlet.CommonGatewayInterface",
cls.getSuperclass().getName());
+ }
+
+ @Test
+ public void testMigrateInMemoryNestedArchive() throws Exception {
+ File jarFile = new File("target/test-classes/hellocgi.jar");
+ File jarFileTarget = tempFolder.newFile("in-memory-nested.jar");
+
+ Migration migration = new Migration();
+ migration.setSource(jarFile);
+ migration.setDestination(jarFileTarget);
+ migration.setZipInMemory(true);
+ migration.execute();
+
+ assertTrue("Target JAR should exist", jarFileTarget.exists());
+ assertTrue("hasConverted should be true", migration.hasConverted());
+ }
+
+ private File createLargeStoredJar(byte[] largeContent) throws Exception {
+ // Create a JAR with STORED method containing the large file
+ File storedJar = tempFolder.newFile("large-stored.jar");
+ try (FileOutputStream fos = new FileOutputStream(storedJar);
+
org.apache.commons.compress.archivers.zip.ZipArchiveOutputStream zos =
+ new
org.apache.commons.compress.archivers.zip.ZipArchiveOutputStream(fos)) {
+ org.apache.commons.compress.archivers.zip.ZipArchiveEntry entry =
+ new
org.apache.commons.compress.archivers.zip.ZipArchiveEntry("large-data.txt");
+
entry.setMethod(org.apache.commons.compress.archivers.zip.ZipArchiveEntry.STORED);
+ entry.setSize(largeContent.length);
+ CRC32 crc = new CRC32();
+ crc.update(largeContent);
+ entry.setCrc(crc.getValue());
+ zos.putArchiveEntry(entry);
+ zos.write(largeContent);
+ zos.closeArchiveEntry();
+ }
+ return storedJar;
+ }
+
+ @Test
+ public void testMigrateLargeStoredEntryInZip() throws Exception {
+ // Create a large file (>10MB) to trigger
CrcSizeTrackingOutputStream.maybeSwitchToFile()
+ // which switches from in-memory buffer to temp file at
TEMP_FILE_THRESHOLD (10MB)
+ byte[] largeContent = new byte[11 * 1024 * 1024]; // 11MB
+ for (int i = 0; i < largeContent.length; i++) {
+ largeContent[i] = (byte) (i % 256);
+ }
+
+ File storedJar = createLargeStoredJar(largeContent);
+
+ // Migrate the JAR using streaming (not in-memory) to exercise
CrcSizeTrackingOutputStream
+ File jarFileTarget = tempFolder.newFile("large-stored-migrated.jar");
+ Migration migration = new Migration();
+ migration.setSource(storedJar);
+ migration.setDestination(jarFileTarget);
+ migration.setZipInMemory(false); // Streaming mode uses
CrcSizeTrackingOutputStream
+ migration.execute();
+
+ assertTrue("Target JAR should exist", jarFileTarget.exists());
+ assertTrue("Target JAR should have content", jarFileTarget.length() >
0);
+
+ // Verify the large file was preserved correctly
+ try (JarFile jar = new JarFile(jarFileTarget)) {
+ JarEntry entry = jar.getJarEntry("large-data.txt");
+ assertNotNull("Large entry should exist in migrated JAR", entry);
+ assertEquals("Large entry size should match", largeContent.length,
entry.getSize());
+
+ byte[] readContent = new byte[(int) entry.getSize()];
+ try (InputStream is = jar.getInputStream(entry)) {
+ int offset = 0;
+ int count;
+ while (offset < readContent.length && (count =
is.read(readContent, offset, readContent.length - offset)) > 0) {
+ offset += count;
+ }
+ }
+ assertArrayEquals("Large entry content should match",
largeContent, readContent);
+ }
+ }
+
+ @Test
+ public void testMigrateLargeStoredEntryInMemory() throws Exception {
+ // Create a large file (>10MB) to test in-memory migration with large
STORED entries
+ byte[] largeContent = new byte[11 * 1024 * 024]; // 11MB
+ for (int i = 0; i < largeContent.length; i++) {
+ largeContent[i] = (byte) (i % 256);
+ }
+
+ File storedJar = createLargeStoredJar(largeContent);
+
+ // Migrate the JAR using in-memory mode
+ File jarFileTarget =
tempFolder.newFile("large-stored-memory-migrated.jar");
+ Migration migration = new Migration();
+ migration.setSource(storedJar);
+ migration.setDestination(jarFileTarget);
+ migration.setZipInMemory(true); // In-memory mode uses ZipFile +
ZipArchiveOutputStream
+ migration.execute();
+
+ assertTrue("Target JAR should exist", jarFileTarget.exists());
+ assertTrue("Target JAR should have content", jarFileTarget.length() >
0);
+
+ // Verify the large file was preserved correctly
+ try (JarFile jar = new JarFile(jarFileTarget)) {
+ JarEntry entry = jar.getJarEntry("large-data.txt");
+ assertNotNull("Large entry should exist in migrated JAR", entry);
+ assertEquals("Large entry size should match", largeContent.length,
entry.getSize());
+
+ byte[] readContent = new byte[(int) entry.getSize()];
+ try (InputStream is = jar.getInputStream(entry)) {
+ int offset = 0;
+ int count;
+ while (offset < readContent.length && (count =
is.read(readContent, offset, readContent.length - offset)) > 0) {
+ offset += count;
+ }
+ }
+ assertArrayEquals("Large entry content should match",
largeContent, readContent);
+ }
+ }
+
+ @Test
+ public void testMigrateNestedArchiveWithCache() throws Exception {
+ // Create a nested JAR with javax.servlet references
+ File nestedJar = tempFolder.newFile("nested.jar");
+ byte[] nestedClassData = new byte[1024];
+ for (int i = 0; i < nestedClassData.length; i++) {
+ nestedClassData[i] = (byte) (i % 256);
+ }
+ // Write a text file with javax reference into the nested JAR
+ String nestedContent = "javax.servlet.http.HttpServlet";
+ try (FileOutputStream fos = new FileOutputStream(nestedJar);
+
org.apache.commons.compress.archivers.zip.ZipArchiveOutputStream zos =
+ new
org.apache.commons.compress.archivers.zip.ZipArchiveOutputStream(fos)) {
+ org.apache.commons.compress.archivers.zip.ZipArchiveEntry entry =
+ new
org.apache.commons.compress.archivers.zip.ZipArchiveEntry("nested.txt");
+ zos.putArchiveEntry(entry);
+ zos.write(nestedContent.getBytes(StandardCharsets.ISO_8859_1));
+ zos.closeArchiveEntry();
+ }
+
+ // Create a WAR containing the nested JAR
+ File warFile = tempFolder.newFile("app.war");
+ try (FileOutputStream fos = new FileOutputStream(warFile);
+
org.apache.commons.compress.archivers.zip.ZipArchiveOutputStream zos =
+ new
org.apache.commons.compress.archivers.zip.ZipArchiveOutputStream(fos)) {
+ // Add WEB-INF/lib/nested.jar
+ org.apache.commons.compress.archivers.zip.ZipArchiveEntry entry =
+ new
org.apache.commons.compress.archivers.zip.ZipArchiveEntry("WEB-INF/lib/nested.jar");
+ zos.putArchiveEntry(entry);
+ byte[] nestedJarBytes = Files.readAllBytes(nestedJar.toPath());
+ zos.write(nestedJarBytes);
+ zos.closeArchiveEntry();
+
+ // Add a web.xml
+ org.apache.commons.compress.archivers.zip.ZipArchiveEntry
webXmlEntry =
+ new
org.apache.commons.compress.archivers.zip.ZipArchiveEntry("WEB-INF/web.xml");
+ zos.putArchiveEntry(webXmlEntry);
+
zos.write("<web-app></web-app>".getBytes(StandardCharsets.ISO_8859_1));
+ zos.closeArchiveEntry();
+ }
+
+ // Migrate WAR with cache enabled - nested JAR should be cached
+ File cacheDir = tempFolder.newFolder("nested-cache");
+ File warTarget = tempFolder.newFile("app-migrated.war");
+
+ Migration migration = new Migration();
+ migration.setSource(warFile);
+ migration.setDestination(warTarget);
+ migration.setCache(new MigrationCache(cacheDir, 30));
+ migration.setZipInMemory(false);
+ migration.execute();
+
+ assertTrue("Target WAR should exist", warTarget.exists());
+ assertTrue("Cache directory should have entries",
cacheDir.list().length > 0);
+
+ // Verify the nested JAR was migrated
+ try (JarFile war = new JarFile(warTarget)) {
+ JarEntry nestedEntry = war.getJarEntry("WEB-INF/lib/nested.jar");
+ assertNotNull("Nested JAR should exist in WAR", nestedEntry);
+
+ // Read the nested JAR and verify its content was migrated
+ byte[] nestedJarBytes = new byte[(int) nestedEntry.getSize()];
+ try (InputStream is = war.getInputStream(nestedEntry)) {
+ int offset = 0;
+ int count;
+ while (offset < nestedJarBytes.length && (count =
is.read(nestedJarBytes, offset, nestedJarBytes.length - offset)) > 0) {
+ offset += count;
+ }
+ }
+
+ // Parse the nested JAR from bytes
+ org.apache.commons.compress.archivers.zip.ZipFile nestedZipFile =
new org.apache.commons.compress.archivers.zip.ZipFile(
+ new
org.apache.commons.compress.utils.SeekableInMemoryByteChannel(nestedJarBytes));
+ org.apache.commons.compress.archivers.zip.ZipArchiveEntry
nestedTextEntry =
+ nestedZipFile.getEntry("nested.txt");
+ assertNotNull("nested.txt should exist in nested JAR",
nestedTextEntry);
+
+ byte[] nestedTextBytes = new byte[(int) nestedTextEntry.getSize()];
+ try (InputStream is =
nestedZipFile.getInputStream(nestedTextEntry)) {
+ is.read(nestedTextBytes);
+ }
+ String migratedNestedContent = new String(nestedTextBytes,
StandardCharsets.ISO_8859_1);
+ assertTrue("Nested content should be migrated",
+ migratedNestedContent.contains("jakarta.servlet"));
+ assertFalse("Nested content should not contain javax",
+ migratedNestedContent.contains("javax.servlet"));
+ nestedZipFile.close();
+ }
+ }
+
+ @Test
+ public void testMigrateNestedArchiveWithCacheHit() throws Exception {
+ // Create a nested JAR with javax.servlet references
+ String nestedContent = "javax.servlet.http.HttpServlet";
+ File nestedJar = tempFolder.newFile("nested-hit.jar");
+ try (FileOutputStream fos = new FileOutputStream(nestedJar);
+
org.apache.commons.compress.archivers.zip.ZipArchiveOutputStream zos =
+ new
org.apache.commons.compress.archivers.zip.ZipArchiveOutputStream(fos)) {
+ org.apache.commons.compress.archivers.zip.ZipArchiveEntry entry =
+ new
org.apache.commons.compress.archivers.zip.ZipArchiveEntry("nested.txt");
+ zos.putArchiveEntry(entry);
+ zos.write(nestedContent.getBytes(StandardCharsets.ISO_8859_1));
+ zos.closeArchiveEntry();
+ }
+
+ // Create two WARs with the same nested JAR
+ File warFile1 = createWarWithNestedJar(nestedJar, "app1.war");
+ File cacheDir = tempFolder.newFolder("nested-hit-cache");
+
+ // First migration - cache miss
+ File warTarget1 = tempFolder.newFile("app1-migrated.war");
+ Migration migration1 = new Migration();
+ migration1.setSource(warFile1);
+ migration1.setDestination(warTarget1);
+ MigrationCache cache = new MigrationCache(cacheDir, 30);
+ migration1.setCache(cache);
+ migration1.setZipInMemory(false);
+ migration1.execute();
+
+ assertTrue("First target WAR should exist", warTarget1.exists());
+
+ // Create second WAR with same nested JAR
+ File warFile2 = createWarWithNestedJar(nestedJar, "app2.war");
+ File warTarget2 = tempFolder.newFile("app2-migrated.war");
+
+ // Second migration - should hit cache for nested JAR
+ Migration migration2 = new Migration();
+ migration2.setSource(warFile2);
+ migration2.setDestination(warTarget2);
+ migration2.setCache(cache);
+ migration2.setZipInMemory(false);
+ migration2.execute();
+
+ assertTrue("Second target WAR should exist", warTarget2.exists());
+
+ // Verify both WARs have migrated nested content
+ for (File warTarget : new File[]{warTarget1, warTarget2}) {
+ try (JarFile war = new JarFile(warTarget)) {
+ JarEntry nestedEntry =
war.getJarEntry("WEB-INF/lib/nested.jar");
+ assertNotNull("Nested JAR should exist", nestedEntry);
+
+ byte[] nestedJarBytes = new byte[(int) nestedEntry.getSize()];
+ try (InputStream is = war.getInputStream(nestedEntry)) {
+ int offset = 0;
+ int count;
+ while (offset < nestedJarBytes.length && (count =
is.read(nestedJarBytes, offset, nestedJarBytes.length - offset)) > 0) {
+ offset += count;
+ }
+ }
+
+ org.apache.commons.compress.archivers.zip.ZipFile
nestedZipFile = new org.apache.commons.compress.archivers.zip.ZipFile(
+ new
org.apache.commons.compress.utils.SeekableInMemoryByteChannel(nestedJarBytes));
+ org.apache.commons.compress.archivers.zip.ZipArchiveEntry
nestedTextEntry =
+ nestedZipFile.getEntry("nested.txt");
+ byte[] nestedTextBytes = new byte[(int)
nestedTextEntry.getSize()];
+ try (InputStream is =
nestedZipFile.getInputStream(nestedTextEntry)) {
+ is.read(nestedTextBytes);
+ }
+ String migratedContent = new String(nestedTextBytes,
StandardCharsets.ISO_8859_1);
+ assertTrue("Nested content should be migrated in " +
warTarget.getName(),
+ migratedContent.contains("jakarta.servlet"));
+ nestedZipFile.close();
+ }
+ }
+ }
+
+ private File createWarWithNestedJar(File nestedJar, String warName) throws
Exception {
+ File warFile = tempFolder.newFile(warName);
+ byte[] nestedJarBytes = Files.readAllBytes(nestedJar.toPath());
+ try (FileOutputStream fos = new FileOutputStream(warFile);
+
org.apache.commons.compress.archivers.zip.ZipArchiveOutputStream zos =
+ new
org.apache.commons.compress.archivers.zip.ZipArchiveOutputStream(fos)) {
+ org.apache.commons.compress.archivers.zip.ZipArchiveEntry entry =
+ new
org.apache.commons.compress.archivers.zip.ZipArchiveEntry("WEB-INF/lib/nested.jar");
+ zos.putArchiveEntry(entry);
+ zos.write(nestedJarBytes);
+ zos.closeArchiveEntry();
+ }
+ return warFile;
+ }
+
+ @Test
+ public void testMigrateLargeSingleFileInPlace() throws Exception {
+ // Create a large JAR file (>10MB) with javax references
+ // Use STORED method so the JAR stays large (not compressed)
+ File largeJar = tempFolder.newFile("large-inplace.jar");
+ byte[] largeContent = new byte[11 * 1024 * 1024]; // 11MB
+ java.util.Random random = new java.util.Random(42); // Seed for
reproducibility
+ random.nextBytes(largeContent); // Random data doesn't compress
+
+ // Create a text file with javax reference
+ String textContent = "javax.servlet.http.HttpServlet";
+
+ try (FileOutputStream fos = new FileOutputStream(largeJar);
+
org.apache.commons.compress.archivers.zip.ZipArchiveOutputStream zos =
+ new
org.apache.commons.compress.archivers.zip.ZipArchiveOutputStream(fos)) {
+ // Add large data file with STORED method (no compression)
+ org.apache.commons.compress.archivers.zip.ZipArchiveEntry
largeEntry =
+ new
org.apache.commons.compress.archivers.zip.ZipArchiveEntry("large-data.bin");
+
largeEntry.setMethod(org.apache.commons.compress.archivers.zip.ZipArchiveEntry.STORED);
+ largeEntry.setSize(largeContent.length);
+ CRC32 crc = new CRC32();
+ crc.update(largeContent);
+ largeEntry.setCrc(crc.getValue());
+ zos.putArchiveEntry(largeEntry);
+ zos.write(largeContent);
+ zos.closeArchiveEntry();
+
+ // Add text file with javax reference (to trigger conversion)
+ org.apache.commons.compress.archivers.zip.ZipArchiveEntry
textEntry =
+ new
org.apache.commons.compress.archivers.zip.ZipArchiveEntry("test.txt");
+ zos.putArchiveEntry(textEntry);
+ zos.write(textContent.getBytes(StandardCharsets.ISO_8859_1));
+ zos.closeArchiveEntry();
+ }
+
+ assertTrue("Large JAR should be >10MB (actual: " + largeJar.length() +
" bytes)",
+ largeJar.length() > 10 * 1024 * 1024);
+
+ // Migrate in-place (src == dest) - should use temp file path
+ Migration migration = new Migration();
+ migration.setSource(largeJar);
+ migration.setDestination(largeJar);
+ migration.execute();
+
+ assertTrue("Large JAR should still exist", largeJar.exists());
+ assertTrue("hasConverted should be true", migration.hasConverted());
+
+ // Verify the text file was migrated
+ try (JarFile jar = new JarFile(largeJar)) {
+ JarEntry textEntry = jar.getJarEntry("test.txt");
+ assertNotNull("test.txt should exist", textEntry);
+
+ byte[] textBytes = new byte[(int) textEntry.getSize()];
+ try (InputStream is = jar.getInputStream(textEntry)) {
+ is.read(textBytes);
+ }
+ String migratedText = new String(textBytes,
StandardCharsets.ISO_8859_1);
+ assertTrue("Text should be migrated",
migratedText.contains("jakarta.servlet"));
+ }
+ }
+
+ @Test
+ public void testMigrateDirectoryNestedSubdirCannotCreate() throws
Exception {
+ // Create a source directory with nested subdirectories
+ File sourceDir = tempFolder.newFolder("nested-source");
+ File subDir1 = new File(sourceDir, "level1");
+ subDir1.mkdirs();
+ File subDir2 = new File(subDir1, "level2");
+ subDir2.mkdirs();
+ File sourceFile = new File(subDir2, "test.txt");
+ Files.write(sourceFile.toPath(),
"javax.servlet".getBytes(StandardCharsets.ISO_8859_1));
+
+ // Create a destination where nested subdir can't be created
+ // Use /proc as it's typically a read-only mount on Linux
+ File destDir = new File("/proc/nested-test-dest");
+
+ Migration migration = new Migration();
+ migration.setSource(sourceDir);
+ migration.setDestination(destDir);
+
+ try {
+ migration.execute();
+ fail("Should throw IOException when cannot create nested
subdirectory");
+ } catch (IOException e) {
+ // Expected - should fail to create nested directory
+ }
+ }
+
+ @Test
+ public void testMigrateDirectoryWithNestedDirs() throws Exception {
+ // Create a source directory with nested subdirectories
+ File sourceDir = tempFolder.newFolder("nested-source");
+ File subDir1 = new File(sourceDir, "level1");
+ subDir1.mkdirs();
+ File subDir2 = new File(subDir1, "level2");
+ subDir2.mkdirs();
+ File sourceFile = new File(subDir2, "test.txt");
+ Files.write(sourceFile.toPath(),
"javax.servlet.http.HttpServlet".getBytes(StandardCharsets.ISO_8859_1));
+
+ File destDir = tempFolder.newFolder("nested-dest");
+
+ Migration migration = new Migration();
+ migration.setSource(sourceDir);
+ migration.setDestination(destDir);
+ migration.execute();
+
+ // Verify the nested structure was migrated
+ File destFile = new File(destDir, "level1/level2/test.txt");
+ assertTrue("Nested file should exist", destFile.exists());
+
+ String content = FileUtils.readFileToString(destFile,
StandardCharsets.UTF_8);
+ assertTrue("Nested file should be migrated",
content.contains("jakarta.servlet"));
+ }
+
+ @Test
+ public void testMigrateNestedJarInWarStreaming() throws Exception {
+ // Create a WAR with a nested JAR that has javax references
+ File nestedJar = tempFolder.newFile("nested-streaming.jar");
+ String nestedContent = "javax.servlet.http.HttpServlet";
+ try (FileOutputStream fos = new FileOutputStream(nestedJar);
+
org.apache.commons.compress.archivers.zip.ZipArchiveOutputStream zos =
+ new
org.apache.commons.compress.archivers.zip.ZipArchiveOutputStream(fos)) {
+ org.apache.commons.compress.archivers.zip.ZipArchiveEntry entry =
+ new
org.apache.commons.compress.archivers.zip.ZipArchiveEntry("nested.txt");
+ zos.putArchiveEntry(entry);
+ zos.write(nestedContent.getBytes(StandardCharsets.ISO_8859_1));
+ zos.closeArchiveEntry();
+ }
+
+ File warFile = createWarWithNestedJar(nestedJar, "streaming-test.war");
+ File warTarget = tempFolder.newFile("streaming-test-migrated.war");
+
+ Migration migration = new Migration();
+ migration.setSource(warFile);
+ migration.setDestination(warTarget);
+ migration.setZipInMemory(false); // Streaming mode
+ migration.execute();
+
+ assertTrue("Target WAR should exist", warTarget.exists());
+ assertTrue("hasConverted should be true", migration.hasConverted());
+
+ // Verify nested JAR content was migrated
+ try (JarFile war = new JarFile(warTarget)) {
+ JarEntry nestedEntry = war.getJarEntry("WEB-INF/lib/nested.jar");
+ assertNotNull("Nested JAR should exist", nestedEntry);
+
+ byte[] nestedJarBytes = new byte[(int) nestedEntry.getSize()];
+ try (InputStream is = war.getInputStream(nestedEntry)) {
+ int offset = 0;
+ int count;
+ while (offset < nestedJarBytes.length && (count =
is.read(nestedJarBytes, offset, nestedJarBytes.length - offset)) > 0) {
+ offset += count;
+ }
+ }
+
+ org.apache.commons.compress.archivers.zip.ZipFile nestedZipFile =
new org.apache.commons.compress.archivers.zip.ZipFile(
+ new
org.apache.commons.compress.utils.SeekableInMemoryByteChannel(nestedJarBytes));
+ org.apache.commons.compress.archivers.zip.ZipArchiveEntry
nestedTextEntry =
+ nestedZipFile.getEntry("nested.txt");
+ byte[] nestedTextBytes = new byte[(int) nestedTextEntry.getSize()];
+ try (InputStream is =
nestedZipFile.getInputStream(nestedTextEntry)) {
+ is.read(nestedTextBytes);
+ }
+ String migratedContent = new String(nestedTextBytes,
StandardCharsets.ISO_8859_1);
+ assertTrue("Nested content should be migrated",
+ migratedContent.contains("jakarta.servlet"));
+ nestedZipFile.close();
+ }
+ }
+
+ @Test
+ public void testMigrateNestedJarInWarInMemory() throws Exception {
+ // Create a WAR with a nested JAR that has javax references
+ File nestedJar = tempFolder.newFile("nested-memory.jar");
+ String nestedContent = "javax.servlet.http.HttpServlet";
+ try (FileOutputStream fos = new FileOutputStream(nestedJar);
+
org.apache.commons.compress.archivers.zip.ZipArchiveOutputStream zos =
+ new
org.apache.commons.compress.archivers.zip.ZipArchiveOutputStream(fos)) {
+ org.apache.commons.compress.archivers.zip.ZipArchiveEntry entry =
+ new
org.apache.commons.compress.archivers.zip.ZipArchiveEntry("nested.txt");
+ zos.putArchiveEntry(entry);
+ zos.write(nestedContent.getBytes(StandardCharsets.ISO_8859_1));
+ zos.closeArchiveEntry();
+ }
+
+ File warFile = createWarWithNestedJar(nestedJar, "memory-test.war");
+ File warTarget = tempFolder.newFile("memory-test-migrated.war");
+
+ Migration migration = new Migration();
+ migration.setSource(warFile);
+ migration.setDestination(warTarget);
+ migration.setZipInMemory(true); // In-memory mode
+ migration.execute();
+
+ assertTrue("Target WAR should exist", warTarget.exists());
+ assertTrue("hasConverted should be true", migration.hasConverted());
+
+ // Verify nested JAR content was migrated
+ try (JarFile war = new JarFile(warTarget)) {
+ JarEntry nestedEntry = war.getJarEntry("WEB-INF/lib/nested.jar");
+ assertNotNull("Nested JAR should exist", nestedEntry);
+
+ byte[] nestedJarBytes = new byte[(int) nestedEntry.getSize()];
+ try (InputStream is = war.getInputStream(nestedEntry)) {
+ int offset = 0;
+ int count;
+ while (offset < nestedJarBytes.length && (count =
is.read(nestedJarBytes, offset, nestedJarBytes.length - offset)) > 0) {
+ offset += count;
+ }
+ }
+
+ org.apache.commons.compress.archivers.zip.ZipFile nestedZipFile =
new org.apache.commons.compress.archivers.zip.ZipFile(
+ new
org.apache.commons.compress.utils.SeekableInMemoryByteChannel(nestedJarBytes));
+ org.apache.commons.compress.archivers.zip.ZipArchiveEntry
nestedTextEntry =
+ nestedZipFile.getEntry("nested.txt");
+ byte[] nestedTextBytes = new byte[(int) nestedTextEntry.getSize()];
+ try (InputStream is =
nestedZipFile.getInputStream(nestedTextEntry)) {
+ is.read(nestedTextBytes);
+ }
+ String migratedContent = new String(nestedTextBytes,
StandardCharsets.ISO_8859_1);
+ assertTrue("Nested content should be migrated",
+ migratedContent.contains("jakarta.servlet"));
+ nestedZipFile.close();
+ }
+ }
+
+ @Test
+ public void testMigrateWithStoreMethodInZip() throws Exception {
+ File jarFile = new File("target/test-classes/hellocgi.jar");
+ File jarFileTarget = tempFolder.newFile("stored-method-test.jar");
+
+ Migration migration = new Migration();
+ migration.setSource(jarFile);
+ migration.setDestination(jarFileTarget);
+ migration.execute();
+
+ try (JarFile jar = new JarFile(jarFileTarget)) {
+ java.util.Enumeration<java.util.jar.JarEntry> entries =
jar.entries();
+ while (entries.hasMoreElements()) {
+ java.util.jar.JarEntry entry = entries.nextElement();
+ if (!entry.isDirectory()) {
+ break;
+ }
+ }
+ }
+ assertTrue("Target JAR should exist", jarFileTarget.exists());
+ }
+
+ @Test
+ public void testMigrateDirectoryNestedSubdir() throws Exception {
+ File sourceDirectory = new File("src/test/resources");
+ File destinationDirectory = tempFolder.newFolder("nested-subdir-test");
+
+ Migration migration = new Migration();
+ migration.setSource(sourceDirectory);
+ migration.setDestination(destinationDirectory);
+ migration.execute();
+
+ assertTrue("Destination directory should exist",
destinationDirectory.exists());
+ assertTrue("Destination should have files",
destinationDirectory.list().length > 0);
+ }
+
+ @Test
+ public void testMigrateFileToNewParentDirectory() throws Exception {
+ File sourceFile = new File("target/test-classes/HelloServlet.java");
+ File destFile = new File(tempFolder.newFolder("new", "parent"),
"migrated.java");
+
+ Migration migration = new Migration();
+ migration.setSource(sourceFile);
+ migration.setDestination(destFile);
+ migration.execute();
+
+ assertTrue("Destination file should exist", destFile.exists());
+ }
+
+ @Test
+ public void testMigrateWithJee8ProfileNoConversion() throws Exception {
+ File sourceFile = new File("target/test-classes/HelloServlet.java");
+ File destFile = tempFolder.newFile("jee8-no-conversion.java");
+
+ Migration migration = new Migration();
+ migration.setSource(sourceFile);
+ migration.setDestination(destFile);
+ migration.setEESpecProfile(EESpecProfiles.JEE8);
+ migration.execute();
+
+ assertFalse("JEE8 profile should not convert",
migration.hasConverted());
+ String migratedSource = FileUtils.readFileToString(destFile,
StandardCharsets.UTF_8);
+ assertTrue("Source should remain unchanged with JEE8",
migratedSource.contains("import javax.servlet"));
+ }
+
+ @Test
+ public void testMigrateCLIWithZipInMemory() throws Exception {
+ File sourceFile = new File("target/test-classes/hellocgi.jar");
+ File targetFile = tempFolder.newFile("cli-zip-memory.jar");
+
+ MigrationCLI.main(new String[] {
+ "-zipInMemory",
+ sourceFile.getAbsolutePath(),
+ targetFile.getAbsolutePath()
+ });
+
+ assertTrue("Target file should exist", targetFile.exists());
+ }
+
+ @Test
+ public void testMigrateCLIWithExclude() throws Exception {
+ File sourceFile = new File("target/test-classes/HelloServlet.java");
+ File targetFile = tempFolder.newFile("cli-exclude.java");
+
+ MigrationCLI.main(new String[] {
+ "-exclude=*.java",
+ sourceFile.getAbsolutePath(),
+ targetFile.getAbsolutePath()
+ });
+
+ assertTrue("Target file should exist even when excluded",
targetFile.exists());
+ String content = FileUtils.readFileToString(targetFile,
StandardCharsets.UTF_8);
+ assertTrue("Excluded file should not be converted",
content.contains("import javax.servlet"));
+ }
+
+ @Test
+ public void testMigrateCLIWithMatchExcludesAgainstPathName() throws
Exception {
+ File sourceFile = new File("target/test-classes/HelloServlet.java");
+ File targetFile = tempFolder.newFile("cli-match-path.java");
+
+ MigrationCLI.main(new String[] {
+ "-matchExcludesAgainstPathName",
+ sourceFile.getAbsolutePath(),
+ targetFile.getAbsolutePath()
+ });
+
+ assertTrue("Target file should exist", targetFile.exists());
+ }
+
+ @Test
+ public void testMigrateCLIWithCacheRetention() throws Exception {
+ File sourceFile = new File("target/test-classes/HelloServlet.java");
+ File targetFile = tempFolder.newFile("cli-cache-retention.java");
+ File cacheDir = tempFolder.newFolder("cache-retention-test");
+
+ try {
+ MigrationCLI.main(new String[] {
+ "-cache",
+ "-cacheLocation=" + cacheDir.getAbsolutePath(),
+ "-cacheRetention=7",
+ sourceFile.getAbsolutePath(),
+ targetFile.getAbsolutePath()
+ });
+
+ assertTrue("Target file should exist", targetFile.exists());
+ assertTrue("Cache directory should be created", cacheDir.exists());
+ } finally {
+ // Clean up
+ if (cacheDir.exists()) {
+ FileUtils.deleteDirectory(cacheDir);
+ }
+ }
+ }
+
+ @Test
+ public void testMigrateCLIWithLogLevelFine() throws Exception {
+ File sourceFile = new File("target/test-classes/HelloServlet.java");
+ File targetFile = tempFolder.newFile("cli-log-fine.java");
+
+ MigrationCLI.main(new String[] {
+ "-logLevel=FINE",
+ sourceFile.getAbsolutePath(),
+ targetFile.getAbsolutePath()
+ });
+
+ assertTrue("Target file should exist", targetFile.exists());
+ }
+
+ @Test
+ public void testMigrateCLIMissingArguments() throws Exception {
+ Assume.assumeTrue(securityManagerAvailable);
+
+ try {
+ MigrationCLI.main(new String[] {
+ "only-source.txt"
+ });
+ fail("No error code returned for missing arguments");
+ } catch (SecurityException e) {
+ assertEquals("error code", "1", e.getMessage());
+ }
+ }
+
+ @Test
+ public void testMigrateCLITooManyArguments() throws Exception {
+ Assume.assumeTrue(securityManagerAvailable);
+
+ try {
+ MigrationCLI.main(new String[] {
+ "source.txt", "dest.txt", "extra.txt"
+ });
+ fail("No error code returned for too many arguments");
+ } catch (SecurityException e) {
+ assertEquals("error code", "1", e.getMessage());
+ }
+ }
+
+ @Test
+ public void testMigrateCLIInvalidCacheRetention() throws Exception {
+ Assume.assumeTrue(securityManagerAvailable);
+
+ try {
+ MigrationCLI.main(new String[] {
+ "-cacheRetention=-1",
+ "source.txt", "dest.txt"
+ });
+ fail("No error code returned for invalid cache retention");
+ } catch (SecurityException e) {
+ assertEquals("error code", "1", e.getMessage());
+ }
+ }
+
+ @Test
+ public void testMigrateCLIInvalidLogLevel() throws Exception {
+ Assume.assumeTrue(securityManagerAvailable);
+
+ try {
+ MigrationCLI.main(new String[] {
+ "-logLevel=INVALID",
+ "source.txt", "dest.txt"
+ });
+ fail("No error code returned for invalid log level");
+ } catch (SecurityException e) {
+ assertEquals("error code", "1", e.getMessage());
+ }
+ }
+
+ @Test
+ public void testMigrateCLICacheRetentionNonNumeric() throws Exception {
+ Assume.assumeTrue(securityManagerAvailable);
+
+ try {
+ MigrationCLI.main(new String[] {
+ "-cacheRetention=abc",
+ "source.txt", "dest.txt"
+ });
+ fail("No error code returned for non-numeric cache retention");
+ } catch (SecurityException e) {
+ assertEquals("error code", "1", e.getMessage());
+ }
+ }
+
+ @Test
+ public void testMigrateCLICacheRetentionZero() throws Exception {
+ Assume.assumeTrue(securityManagerAvailable);
+
+ try {
+ MigrationCLI.main(new String[] {
+ "-cacheRetention=0",
+ "source.txt", "dest.txt"
+ });
+ fail("No error code returned for zero cache retention");
+ } catch (SecurityException e) {
+ assertEquals("error code", "1", e.getMessage());
+ }
+ }
+
+ @Test
+ public void testMigrateMultipleExcludes() throws Exception {
+ File sourceDirectory = new File("src/test/resources");
+ File destinationDirectory =
tempFolder.newFolder("multi-excludes-test");
+
+ Migration migration = new Migration();
+ migration.setSource(sourceDirectory);
+ migration.setDestination(destinationDirectory);
+ migration.addExclude("HelloServlet.java");
+ migration.addExclude("*.p12");
+ migration.execute();
+
+ // Excluded files are still copied but not converted
+ File excludedFile1 = new File(destinationDirectory,
"HelloServlet.java");
+ assertTrue("First excluded file should still be copied",
excludedFile1.exists());
+ String content1 = FileUtils.readFileToString(excludedFile1,
StandardCharsets.UTF_8);
+ assertTrue("First excluded file should not be converted",
+ content1.contains("import javax.servlet"));
+
+ File excludedFile2 = new File(destinationDirectory, "keystore.p12");
+ assertTrue("Second excluded file should still be copied",
excludedFile2.exists());
+ }
+
+ @Test
+ public void testMigrateWithDefaultExcludesDisabled() throws Exception {
+ File sourceFile = new File("target/test-classes/HelloServlet.java");
+ File destFile = tempFolder.newFile("no-default-excludes.java");
+
+ Migration migration = new Migration();
+ migration.setSource(sourceFile);
+ migration.setDestination(destFile);
+ migration.setEnableDefaultExcludes(false);
+ migration.setEESpecProfile(EESpecProfiles.EE);
+ migration.execute();
+
+ assertTrue("Migrated file should exist", destFile.exists());
+ String migratedSource = FileUtils.readFileToString(destFile,
StandardCharsets.UTF_8);
+ assertTrue("Imports should be migrated",
migratedSource.contains("import jakarta.servlet"));
+ }
+
+ @Test
+ public void testMigrateServletProfile() throws Exception {
+ File sourceFile = new File("target/test-classes/HelloServlet.java");
+ File destFile = tempFolder.newFile("servlet-profile.java");
+
+ Migration migration = new Migration();
+ migration.setSource(sourceFile);
+ migration.setDestination(destFile);
+ migration.setEESpecProfile(EESpecProfiles.SERVLET);
+ migration.execute();
+
+ assertTrue("Migrated file should exist", destFile.exists());
+ String migratedSource = FileUtils.readFileToString(destFile,
StandardCharsets.UTF_8);
+ assertTrue("Imports should be migrated with SERVLET profile",
+ migratedSource.contains("import jakarta.servlet"));
+ }
}
diff --git
a/src/test/java/org/apache/tomcat/jakartaee/PassThroughConverterTest.java
b/src/test/java/org/apache/tomcat/jakartaee/PassThroughConverterTest.java
index fb8fa91..58f474e 100644
--- a/src/test/java/org/apache/tomcat/jakartaee/PassThroughConverterTest.java
+++ b/src/test/java/org/apache/tomcat/jakartaee/PassThroughConverterTest.java
@@ -43,4 +43,85 @@ public class PassThroughConverterTest {
assertArrayEquals(content.getBytes(), out.toByteArray());
}
+
+ @Test
+ public void testAcceptsAlways() {
+ PassThroughConverter converter = new PassThroughConverter();
+ assertTrue(converter.accepts("file.txt"));
+ assertTrue(converter.accepts("file.class"));
+ assertTrue(converter.accepts("file.jar"));
+ assertTrue(converter.accepts("META-INF/MANIFEST.MF"));
+ assertTrue(converter.accepts("image.png"));
+ assertTrue(converter.accepts(""));
+ }
+
+ @Test
+ public void testConvertReturnsFalse() throws Exception {
+ PassThroughConverter converter = new PassThroughConverter();
+ String content = "test content";
+ ByteArrayInputStream in = new ByteArrayInputStream(content.getBytes());
+ ByteArrayOutputStream out = new ByteArrayOutputStream();
+
+ boolean converted = converter.convert(TEST_FILENAME, in, out,
EESpecProfiles.TOMCAT);
+
+ assertFalse("PassThroughConverter should always return false",
converted);
+ }
+
+ @Test
+ public void testConvertPreservesBinaryContent() throws Exception {
+ PassThroughConverter converter = new PassThroughConverter();
+ byte[] binaryContent = new byte[]{0, 1, 2, 127, -128, -1, 0, (byte)
255};
+ ByteArrayInputStream in = new ByteArrayInputStream(binaryContent);
+ ByteArrayOutputStream out = new ByteArrayOutputStream();
+
+ converter.convert("binary.dat", in, out, null);
+
+ assertArrayEquals("Binary content should be preserved exactly",
+ binaryContent, out.toByteArray());
+ }
+
+ @Test
+ public void testConvertEmptyContent() throws Exception {
+ PassThroughConverter converter = new PassThroughConverter();
+ ByteArrayInputStream in = new ByteArrayInputStream(new byte[0]);
+ ByteArrayOutputStream out = new ByteArrayOutputStream();
+
+ converter.convert("empty.txt", in, out, null);
+
+ assertEquals("Empty content should produce empty output", 0,
out.size());
+ }
+
+ @Test
+ public void testConvertWithDifferentProfiles() throws Exception {
+ PassThroughConverter converter = new PassThroughConverter();
+ String content = "javax.servlet";
+
+ for (EESpecProfile profile : EESpecProfiles.values()) {
+ ByteArrayInputStream in = new
ByteArrayInputStream(content.getBytes());
+ ByteArrayOutputStream out = new ByteArrayOutputStream();
+
+ boolean converted = converter.convert("test.txt", in, out,
profile);
+
+ assertFalse("Should return false for profile " + profile,
converted);
+ assertArrayEquals("Content should be unchanged for profile " +
profile,
+ content.getBytes(), out.toByteArray());
+ }
+ }
+
+ @Test
+ public void testConvertLargeContent() throws Exception {
+ PassThroughConverter converter = new PassThroughConverter();
+ byte[] largeContent = new byte[1024 * 1024]; // 1MB
+ for (int i = 0; i < largeContent.length; i++) {
+ largeContent[i] = (byte) (i % 256);
+ }
+
+ ByteArrayInputStream in = new ByteArrayInputStream(largeContent);
+ ByteArrayOutputStream out = new ByteArrayOutputStream();
+
+ converter.convert("large.bin", in, out, null);
+
+ assertArrayEquals("Large content should be preserved exactly",
+ largeContent, out.toByteArray());
+ }
}
diff --git a/src/test/java/org/apache/tomcat/jakartaee/StringManagerTest.java
b/src/test/java/org/apache/tomcat/jakartaee/StringManagerTest.java
new file mode 100644
index 0000000..095baa6
--- /dev/null
+++ b/src/test/java/org/apache/tomcat/jakartaee/StringManagerTest.java
@@ -0,0 +1,140 @@
+/*
+ * 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.jakartaee;
+
+import java.util.Locale;
+
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class StringManagerTest {
+
+ @Test
+ public void testGetStringWithNullKey() {
+ StringManager sm = StringManager.getManager(StringManagerTest.class);
+ try {
+ sm.getString(null);
+ fail("Should throw IllegalArgumentException for null key");
+ } catch (IllegalArgumentException e) {
+ assertEquals("key may not have a null value", e.getMessage());
+ }
+ }
+
+ @Test
+ public void testGetStringExistingKey() {
+ StringManager sm = StringManager.getManager(Migration.class);
+ String result = sm.getString("migration.notCompleted");
+ assertEquals("Migration has not completed", result);
+ }
+
+ @Test
+ public void testGetStringMissingKey() {
+ StringManager sm = StringManager.getManager(Migration.class);
+ String result = sm.getString("nonexistent.key.12345");
+ assertNull("Missing key should return null", result);
+ }
+
+ @Test
+ public void testGetStringWithArgsExistingKey() {
+ StringManager sm = StringManager.getManager(Migration.class);
+ String result = sm.getString("migration.execute",
+ "/source/path", "/dest/path", "TOMCAT");
+ assertNotNull("Result should not be null", result);
+ assertTrue("Result should contain source path",
result.contains("/source/path"));
+ assertTrue("Result should contain dest path",
result.contains("/dest/path"));
+ assertTrue("Result should contain profile", result.contains("TOMCAT"));
+ }
+
+ @Test
+ public void testGetStringWithArgsMissingKey() {
+ StringManager sm = StringManager.getManager(Migration.class);
+ String result = sm.getString("nonexistent.key.12345", "arg1", "arg2");
+ assertEquals("Missing key with args should return the key",
+ "nonexistent.key.12345", result);
+ }
+
+ @Test
+ public void testGetStringWithArgsNoArgs() {
+ StringManager sm = StringManager.getManager(Migration.class);
+ String result = sm.getString("migration.notCompleted");
+ assertEquals("Migration has not completed", result);
+ }
+
+ @Test
+ public void testGetManagerByClass() {
+ StringManager sm1 = StringManager.getManager(Migration.class);
+ StringManager sm2 = StringManager.getManager(Migration.class);
+ assertSame("Same package should return same manager", sm1, sm2);
+ }
+
+ @Test
+ public void testGetManagerByPackageName() {
+ StringManager sm1 =
StringManager.getManager("org.apache.tomcat.jakartaee");
+ StringManager sm2 =
StringManager.getManager("org.apache.tomcat.jakartaee");
+ assertSame("Same package should return same manager", sm1, sm2);
+ }
+
+ @Test
+ public void testGetManagerByPackageAndLocale() {
+ StringManager sm1 =
StringManager.getManager("org.apache.tomcat.jakartaee", Locale.ENGLISH);
+ StringManager sm2 =
StringManager.getManager("org.apache.tomcat.jakartaee", Locale.ENGLISH);
+ assertSame("Same package and locale should return same manager", sm1,
sm2);
+ }
+
+ @Test
+ public void testGetManagerDifferentLocale() {
+ StringManager sm1 =
StringManager.getManager("org.apache.tomcat.jakartaee", Locale.ENGLISH);
+ StringManager sm2 =
StringManager.getManager("org.apache.tomcat.jakartaee", Locale.FRANCE);
+ // May or may not be the same depending on available bundles
+ assertNotNull("Manager should not be null", sm1);
+ assertNotNull("Manager should not be null", sm2);
+ }
+
+ @Test
+ public void testGetManagerNonExistentPackage() {
+ StringManager sm =
StringManager.getManager("nonexistent.package.test");
+ assertNotNull("Manager should not be null for non-existent package",
sm);
+ assertNull("Missing key should return null for non-existent package",
+ sm.getString("any.key"));
+ }
+
+ @Test
+ public void testGetStringFormatWithMultipleArgs() {
+ StringManager sm = StringManager.getManager(Migration.class);
+ String result = sm.getString("migration.cannotReadSource",
"/path/to/file");
+ assertNotNull("Result should not be null", result);
+ assertTrue("Result should contain file path",
result.contains("/path/to/file"));
+ }
+
+ @Test
+ public void testGetStringWithEmptyArgs() {
+ StringManager sm = StringManager.getManager(Migration.class);
+ String result = sm.getString("migration.notCompleted", new Object[0]);
+ assertEquals("Migration has not completed", result);
+ }
+
+ @Test
+ public void testGetStringFormatWithNullArg() {
+ StringManager sm = StringManager.getManager(Migration.class);
+ String result = sm.getString("migration.cannotReadSource", (String)
null);
+ assertNotNull("Result should not be null", result);
+ assertTrue("Result should contain null representation",
+ result.contains("null") || result.contains("{0}"));
+ }
+}
diff --git a/src/test/java/org/apache/tomcat/jakartaee/TextConverterTest.java
b/src/test/java/org/apache/tomcat/jakartaee/TextConverterTest.java
index f136567..bde3479 100644
--- a/src/test/java/org/apache/tomcat/jakartaee/TextConverterTest.java
+++ b/src/test/java/org/apache/tomcat/jakartaee/TextConverterTest.java
@@ -1,6 +1,8 @@
package org.apache.tomcat.jakartaee;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
@@ -33,4 +35,192 @@ public class TextConverterTest {
}
+ @Test
+ public void testAcceptsJava() {
+ TextConverter converter = new TextConverter();
+ assertTrue(converter.accepts("HelloServlet.java"));
+ }
+
+ @Test
+ public void testAcceptsJsp() {
+ TextConverter converter = new TextConverter();
+ assertTrue(converter.accepts("index.jsp"));
+ }
+
+ @Test
+ public void testAcceptsJspf() {
+ TextConverter converter = new TextConverter();
+ assertTrue(converter.accepts("header.jspf"));
+ }
+
+ @Test
+ public void testAcceptsJspx() {
+ TextConverter converter = new TextConverter();
+ assertTrue(converter.accepts("page.jspx"));
+ }
+
+ @Test
+ public void testAcceptsTag() {
+ TextConverter converter = new TextConverter();
+ assertTrue(converter.accepts("mytag.tag"));
+ }
+
+ @Test
+ public void testAcceptsTagf() {
+ TextConverter converter = new TextConverter();
+ assertTrue(converter.accepts("mytag.tagf"));
+ }
+
+ @Test
+ public void testAcceptsTagx() {
+ TextConverter converter = new TextConverter();
+ assertTrue(converter.accepts("mytag.tagx"));
+ }
+
+ @Test
+ public void testAcceptsTld() {
+ TextConverter converter = new TextConverter();
+ assertTrue(converter.accepts("custom.tld"));
+ }
+
+ @Test
+ public void testAcceptsXml() {
+ TextConverter converter = new TextConverter();
+ assertTrue(converter.accepts("web.xml"));
+ }
+
+ @Test
+ public void testAcceptsJson() {
+ TextConverter converter = new TextConverter();
+ assertTrue(converter.accepts("config.json"));
+ }
+
+ @Test
+ public void testAcceptsProperties() {
+ TextConverter converter = new TextConverter();
+ assertTrue(converter.accepts("application.properties"));
+ }
+
+ @Test
+ public void testAcceptsGroovy() {
+ TextConverter converter = new TextConverter();
+ assertTrue(converter.accepts("script.groovy"));
+ }
+
+ @Test
+ public void testAcceptsClassFile() {
+ TextConverter converter = new TextConverter();
+ assertFalse(converter.accepts("HelloServlet.class"));
+ }
+
+ @Test
+ public void testAcceptsJarFile() {
+ TextConverter converter = new TextConverter();
+ assertFalse(converter.accepts("lib.jar"));
+ }
+
+ @Test
+ public void testAcceptsNoExtension() {
+ TextConverter converter = new TextConverter();
+ assertFalse(converter.accepts("README"));
+ }
+
+ @Test
+ public void testConvertNoConversionNeeded() throws IOException {
+ TextConverter converter = new TextConverter();
+ String content = "This file has no javax packages";
+ ByteArrayInputStream in = new
ByteArrayInputStream(content.getBytes(StandardCharsets.ISO_8859_1));
+ ByteArrayOutputStream out = new ByteArrayOutputStream();
+
+ boolean converted = converter.convert(TEST_FILENAME, in, out,
EESpecProfiles.TOMCAT);
+
+ assertFalse("Should not convert when no javax packages present",
converted);
+ String result = new String(out.toByteArray(),
StandardCharsets.ISO_8859_1);
+ assertEquals(content, result);
+ }
+
+ @Test
+ public void testConvertMultipleReplacements() throws IOException {
+ TextConverter converter = new TextConverter();
+ String content =
"javax.servlet.Servlet\njavax.servlet.http.HttpServlet";
+ ByteArrayInputStream in = new
ByteArrayInputStream(content.getBytes(StandardCharsets.ISO_8859_1));
+ ByteArrayOutputStream out = new ByteArrayOutputStream();
+
+ boolean converted = converter.convert(TEST_FILENAME, in, out,
EESpecProfiles.TOMCAT);
+
+ assertTrue("Should convert when javax packages present", converted);
+ String result = new String(out.toByteArray(),
StandardCharsets.ISO_8859_1);
+ assertTrue(result.contains("jakarta.servlet.Servlet"));
+ assertTrue(result.contains("jakarta.servlet.http.HttpServlet"));
+ }
+
+ @Test
+ public void testConvertWithJee8Profile() throws IOException {
+ TextConverter converter = new TextConverter();
+ String content = "javax.servlet.Servlet";
+ ByteArrayInputStream in = new
ByteArrayInputStream(content.getBytes(StandardCharsets.ISO_8859_1));
+ ByteArrayOutputStream out = new ByteArrayOutputStream();
+
+ boolean converted = converter.convert(TEST_FILENAME, in, out,
EESpecProfiles.JEE8);
+
+ assertFalse("JEE8 profile should not convert", converted);
+ String result = new String(out.toByteArray(),
StandardCharsets.ISO_8859_1);
+ assertEquals(content, result);
+ }
+
+ @Test
+ public void testConvertEmptyContent() throws IOException {
+ TextConverter converter = new TextConverter();
+ String content = "";
+ ByteArrayInputStream in = new
ByteArrayInputStream(content.getBytes(StandardCharsets.ISO_8859_1));
+ ByteArrayOutputStream out = new ByteArrayOutputStream();
+
+ boolean converted = converter.convert(TEST_FILENAME, in, out,
EESpecProfiles.TOMCAT);
+
+ assertFalse("Empty content should not be converted", converted);
+ String result = new String(out.toByteArray(),
StandardCharsets.ISO_8859_1);
+ assertEquals("", result);
+ }
+
+ @Test
+ public void testConvertXmlFile() throws IOException {
+ TextConverter converter = new TextConverter();
+ String content = "<filter-class>javax.servlet.Filter</filter-class>";
+ ByteArrayInputStream in = new
ByteArrayInputStream(content.getBytes(StandardCharsets.ISO_8859_1));
+ ByteArrayOutputStream out = new ByteArrayOutputStream();
+
+ boolean converted = converter.convert("web.xml", in, out,
EESpecProfiles.TOMCAT);
+
+ assertTrue("Should convert XML content", converted);
+ String result = new String(out.toByteArray(),
StandardCharsets.ISO_8859_1);
+ assertTrue(result.contains("jakarta.servlet.Filter"));
+ }
+
+ @Test
+ public void testConvertPropertiesFile() throws IOException {
+ TextConverter converter = new TextConverter();
+ String content = "servlet.class=javax.servlet.http.HttpServlet";
+ ByteArrayInputStream in = new
ByteArrayInputStream(content.getBytes(StandardCharsets.ISO_8859_1));
+ ByteArrayOutputStream out = new ByteArrayOutputStream();
+
+ boolean converted = converter.convert("config.properties", in, out,
EESpecProfiles.TOMCAT);
+
+ assertTrue("Should convert properties content", converted);
+ String result = new String(out.toByteArray(),
StandardCharsets.ISO_8859_1);
+ assertTrue(result.contains("jakarta.servlet.http.HttpServlet"));
+ }
+
+ @Test
+ public void testConvertJavaFile() throws IOException {
+ TextConverter converter = new TextConverter();
+ String content = "import
javax.servlet.http.HttpServletRequest;\npublic class Test {}";
+ ByteArrayInputStream in = new
ByteArrayInputStream(content.getBytes(StandardCharsets.ISO_8859_1));
+ ByteArrayOutputStream out = new ByteArrayOutputStream();
+
+ boolean converted = converter.convert("Test.java", in, out,
EESpecProfiles.TOMCAT);
+
+ assertTrue("Should convert Java content", converted);
+ String result = new String(out.toByteArray(),
StandardCharsets.ISO_8859_1);
+ assertTrue(result.contains("import
jakarta.servlet.http.HttpServletRequest"));
+ }
}
diff --git a/src/test/java/org/apache/tomcat/jakartaee/UtilTest.java
b/src/test/java/org/apache/tomcat/jakartaee/UtilTest.java
index ae0ef07..0e69cb3 100644
--- a/src/test/java/org/apache/tomcat/jakartaee/UtilTest.java
+++ b/src/test/java/org/apache/tomcat/jakartaee/UtilTest.java
@@ -17,6 +17,11 @@
package org.apache.tomcat.jakartaee;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+
import org.junit.Test;
import static org.junit.Assert.*;
@@ -28,4 +33,110 @@ public class UtilTest {
assertEquals("java", Util.getExtension("HelloServlet.java"));
assertEquals("", Util.getExtension("HelloServlet"));
}
+
+ @Test
+ public void testGetExtensionMultipleDots() {
+ assertEquals("gz", Util.getExtension("file.tar.gz"));
+ assertEquals("class", Util.getExtension("com.example.MyClass.class"));
+ }
+
+ @Test
+ public void testGetExtensionLeadingDot() {
+ assertEquals("gitignore", Util.getExtension(".gitignore"));
+ }
+
+ @Test
+ public void testGetExtensionEmptyString() {
+ assertEquals("", Util.getExtension(""));
+ }
+
+ @Test
+ public void testGetExtensionOnlyDot() {
+ assertEquals("", Util.getExtension("."));
+ }
+
+ @Test
+ public void testGetExtensionUpperCase() {
+ assertEquals("java", Util.getExtension("File.JAVA"));
+ }
+
+ @Test
+ public void testGetExtensionMixedCase() {
+ assertEquals("java", Util.getExtension("File.JaVa"));
+ }
+
+ @Test
+ public void testCopy() throws IOException {
+ byte[] source = "Hello, World!".getBytes(StandardCharsets.UTF_8);
+ ByteArrayInputStream in = new ByteArrayInputStream(source);
+ ByteArrayOutputStream out = new ByteArrayOutputStream();
+
+ Util.copy(in, out);
+
+ assertArrayEquals(source, out.toByteArray());
+ }
+
+ @Test
+ public void testCopyEmpty() throws IOException {
+ ByteArrayInputStream in = new ByteArrayInputStream(new byte[0]);
+ ByteArrayOutputStream out = new ByteArrayOutputStream();
+
+ Util.copy(in, out);
+
+ assertEquals(0, out.size());
+ }
+
+ @Test
+ public void testCopyLarge() throws IOException {
+ byte[] source = new byte[1024 * 1024]; // 1MB
+ for (int i = 0; i < source.length; i++) {
+ source[i] = (byte) (i % 256);
+ }
+ ByteArrayInputStream in = new ByteArrayInputStream(source);
+ ByteArrayOutputStream out = new ByteArrayOutputStream();
+
+ Util.copy(in, out);
+
+ assertArrayEquals(source, out.toByteArray());
+ }
+
+ @Test
+ public void testToString() throws IOException {
+ String original = "Hello, World!";
+ ByteArrayInputStream in = new
ByteArrayInputStream(original.getBytes(StandardCharsets.ISO_8859_1));
+
+ String result = Util.toString(in, StandardCharsets.ISO_8859_1);
+
+ assertEquals(original, result);
+ }
+
+ @Test
+ public void testToStringEmpty() throws IOException {
+ ByteArrayInputStream in = new ByteArrayInputStream(new byte[0]);
+
+ String result = Util.toString(in, StandardCharsets.ISO_8859_1);
+
+ assertEquals("", result);
+ }
+
+ @Test
+ public void testToStringUtf8() throws IOException {
+ String original = "Hello, 世界!";
+ ByteArrayInputStream in = new
ByteArrayInputStream(original.getBytes(StandardCharsets.UTF_8));
+
+ String result = Util.toString(in, StandardCharsets.UTF_8);
+
+ assertEquals(original, result);
+ }
+
+ @Test
+ public void testToStringBinary() throws IOException {
+ byte[] binary = new byte[]{0, 1, 2, 127, -128, -1};
+ ByteArrayInputStream in = new ByteArrayInputStream(binary);
+
+ String result = Util.toString(in, StandardCharsets.ISO_8859_1);
+
+ assertNotNull(result);
+ assertEquals(binary.length, result.length());
+ }
}
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
