refactor: memshell integration-test

integration-test/src/test/java/com/reajason/javaweb/integration/AbstractContainerTest.java

@@ -0,0 +1,258 @@
+package com.reajason.javaweb.integration;
+
+import com.reajason.javaweb.memshell.ShellTool;
+import com.reajason.javaweb.memshell.ShellType;
+import com.reajason.javaweb.packer.Packers;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.Assumptions;
+import org.junit.jupiter.api.TestInstance;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.EnumSource;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.Network;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.images.builder.ImageFromDockerfile;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Stream;
+
+import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+/**
+ * @author ReaJason
+ * @since 2025/9/19
+ */
+@Slf4j
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+public abstract class AbstractContainerTest {
+    private static final String NO_PROBE = "__NO_PROBE__";
+
+    protected static Network newNetwork() {
+        return Network.newNetwork();
+    }
+
+    protected static GenericContainer<?> buildPythonContainer(Network network) {
+        return new GenericContainer<>(new ImageFromDockerfile()
+                .withDockerfile(ContainerTool.neoGeorgDockerfile))
+                .withNetwork(network);
+    }
+
+    protected static GenericContainer<?> buildContainer(ContainerTestConfig config, Network network) {
+        GenericContainer<?> container = createContainer(config);
+        if (config.getWarFile() != null && StringUtils.isNotBlank(config.getWarDeployPath())) {
+            container.withCopyToContainer(config.getWarFile(), config.getWarDeployPath());
+        }
+        if(config.getJarFile() != null && StringUtils.isNotBlank(config.getJarDeployPath())){
+            container.withCopyToContainer(config.getJarFile(), config.getJarDeployPath());
+        }
+        if (config.getJattachFile() != null) {
+            container.withCopyToContainer(config.getJattachFile(), "/jattach");
+        }
+        if (config.getPidScript() != null) {
+            container.withCopyToContainer(config.getPidScript(), "/fetch_pid.sh");
+        }
+        Map<String, String> env = config.getEnv();
+        if (env != null) {
+            env.forEach(container::withEnv);
+        }
+        if (network != null) {
+            container.withNetwork(network);
+            if (StringUtils.isNotBlank(config.getNetworkAlias())) {
+                container.withNetworkAliases(config.getNetworkAlias());
+            }
+        }
+        if (config.getWaitStrategy() != null) {
+            container.waitingFor(config.getWaitStrategy());
+        } else if (StringUtils.isNotBlank(config.getHealthCheckPath())) {
+            container.waitingFor(Wait.forHttp(config.getHealthCheckPath()));
+        }
+        container.withExposedPorts(config.getExposedPort());
+        if (config.isPrivilegedMode()) {
+            container.withPrivilegedMode(true);
+        }
+        if(config.getCommand() != null){
+            container.withCommand(config.getCommand());
+        }
+        return container;
+    }
+
+    protected static GenericContainer<?> buildContainer(ContainerTestConfig config) {
+        return buildContainer(config, null);
+    }
+
+    protected abstract ContainerTestConfig getConfig();
+
+    @AfterAll
+    void tearDown() {
+        GenericContainer<?> container = getContainer();
+        if (container == null) {
+            return;
+        }
+        long logDelayMillis = getConfig().getLogDelayMillis();
+        if (logDelayMillis > 0) {
+            try {
+                Thread.sleep(logDelayMillis);
+            } catch (InterruptedException ex) {
+                Thread.currentThread().interrupt();
+            }
+        }
+        String logs = container.getLogs();
+        if (getConfig().isLogContainerOutput()) {
+            log.info(logs);
+        }
+        if (getConfig().isAssertLogs()) {
+            assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
+        }
+    }
+
+    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
+    @MethodSource("casesProvider")
+    void test(String imageName, String shellType, String shellTool, Packers packer) {
+        runShellInject(getConfig(), shellType, shellTool, packer);
+    }
+
+    @ParameterizedTest
+    @MethodSource("probeShellTypesProvider")
+    void testProbeInject(String shellType) {
+        if (NO_PROBE.equals(shellType)) {
+            Assumptions.assumeTrue(false, "No probe shell types configured.");
+        }
+        runProbeInject(getConfig(), shellType);
+    }
+
+    @ParameterizedTest
+    @EnumSource(names = {"ClassLoaderJSP", "ClassLoaderJSPUnicode", "DefineClassJSP", "DefineClassJSPUnicode", "JSPX", "JSPXUnicode"})
+    void testJspPackers(Packers packer) {
+        ContainerTestConfig config = getConfig();
+        if (config.isEnableJspPackerTest()) {
+            String shellType = config.isJakarta() ? ShellType.JAKARTA_FILTER : ShellType.FILTER;
+            String shellTool = ShellTool.Command;
+            runShellInject(config, shellType, shellTool, packer);
+        }
+    }
+
+    protected Stream<Arguments> casesProvider() {
+        return generateTestCases(getConfig());
+    }
+
+    protected Stream<String> probeShellTypesProvider() {
+        List<String> probeShellTypes = getConfig().getProbeShellTypes();
+        if (probeShellTypes == null || probeShellTypes.isEmpty()) {
+            return Stream.of(NO_PROBE);
+        }
+        return probeShellTypes.stream();
+    }
+
+    protected static Stream<Arguments> generateTestCases(ContainerTestConfig config) {
+        if (config.getUnSupportedCases() != null || config.getUnSupportedShellTools() != null) {
+            return TestCasesProvider.getTestCases(
+                    config.getImageName(),
+                    config.getServer(),
+                    config.getSupportedShellTypes(),
+                    config.getTestPackers(),
+                    config.getUnSupportedCases(),
+                    config.getUnSupportedShellTools());
+        }
+        return TestCasesProvider.getTestCases(
+                config.getImageName(),
+                config.getServer(),
+                config.getSupportedShellTypes(),
+                config.getTestPackers());
+    }
+
+    protected void runShellInject(ContainerTestConfig config, String shellType, String shellTool, Packers packer) {
+        String url = getUrl();
+        if (StringUtils.isNotBlank(config.getServerVersion())) {
+            ShellAssertion.shellInjectIsOk(url, config.getServer(), config.getServerVersion(), shellType, shellTool,
+                    config.getTargetJdkVersion(), packer, getContainer(), getPythonContainer());
+        } else {
+            ShellAssertion.shellInjectIsOk(url, config.getServer(), shellType, shellTool,
+                    config.getTargetJdkVersion(), packer, getContainer(), getPythonContainer());
+        }
+    }
+
+    protected void runProbeInject(ContainerTestConfig config, String shellType) {
+        String url = getUrl();
+        int probeTargetJdkVersion = config.getProbeTargetJdkVersion() == null
+                ? config.getTargetJdkVersion()
+                : config.getProbeTargetJdkVersion();
+        if (StringUtils.isNotBlank(config.getServerVersion())) {
+            ShellAssertion.testProbeInject(url, config.getServer(), config.getServerVersion(), shellType, probeTargetJdkVersion);
+        } else {
+            ShellAssertion.testProbeInject(url, config.getServer(), shellType, probeTargetJdkVersion);
+        }
+    }
+
+    protected String getUrl() {
+        GenericContainer<?> container = getContainer();
+        ContainerTestConfig config = getConfig();
+        String host = container.getHost();
+        int port = container.getMappedPort(config.getExposedPort());
+        String url = "http://" + host + ":" + port;
+        String contextPath = config.getContextPath();
+        if (StringUtils.isNotBlank(contextPath)) {
+            if (!contextPath.startsWith("/")) {
+                contextPath = "/" + contextPath;
+            }
+            url += contextPath;
+        }
+        log.info("container started, app url is : {}", url);
+        return url;
+    }
+
+    protected GenericContainer<?> getContainer() {
+        return getContainerField("container", true);
+    }
+
+    protected GenericContainer<?> getPythonContainer() {
+        return getContainerField("python", false);
+    }
+
+    private static GenericContainer<?> createContainer(ContainerTestConfig config) {
+        if (config.getDockerfilePath() != null) {
+            return new GenericContainer<>(new ImageFromDockerfile()
+                    .withDockerfile(config.getDockerfilePath()));
+        }
+        if (StringUtils.isBlank(config.getImageName())) {
+            throw new IllegalArgumentException("imageName is required when dockerfilePath is not set.");
+        }
+        return new GenericContainer<>(config.getImageName());
+    }
+
+    private GenericContainer<?> getContainerField(String fieldName, boolean required) {
+        Field field = findField(getClass(), fieldName);
+        if (field == null) {
+            if (required) {
+                throw new IllegalStateException("Missing @" + fieldName + " container on " + getClass().getName());
+            }
+            return null;
+        }
+        try {
+            field.setAccessible(true);
+            Object value = field.get(Modifier.isStatic(field.getModifiers()) ? null : this);
+            return (GenericContainer<?>) value;
+        } catch (IllegalAccessException ex) {
+            throw new IllegalStateException("Unable to access " + fieldName + " on " + getClass().getName(), ex);
+        }
+    }
+
+    private static Field findField(Class<?> type, String name) {
+        Class<?> current = type;
+        while (current != null) {
+            try {
+                return current.getDeclaredField(name);
+            } catch (NoSuchFieldException ex) {
+                current = current.getSuperclass();
+            }
+        }
+        return null;
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/ContainerTestConfig.java

@@ -0,0 +1,147 @@
+package com.reajason.javaweb.integration;
+
+import com.reajason.javaweb.Server;
+import com.reajason.javaweb.packer.Packers;
+import lombok.Builder;
+import lombok.Getter;
+import net.bytebuddy.jar.asm.Opcodes;
+import org.apache.commons.lang3.tuple.Triple;
+import org.testcontainers.containers.wait.strategy.WaitStrategy;
+import org.testcontainers.utility.MountableFile;
+
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author ReaJason
+ * @since 2025/9/19
+ */
+@Getter
+@Builder
+public class ContainerTestConfig {
+    private final String imageName;
+    private final Path dockerfilePath;
+    private final String command;
+
+    private final String server;
+    private final String serverVersion;
+    @Builder.Default
+    private final int targetJdkVersion = Opcodes.V1_8;
+    private final Integer probeTargetJdkVersion;
+
+    @Builder.Default
+    private final int exposedPort = 8080;
+    @Builder.Default
+    private final String contextPath = "/app";
+    @Builder.Default
+    private final String healthCheckPath = "/app";
+    private final WaitStrategy waitStrategy;
+
+    private final MountableFile warFile;
+    private final String warDeployPath;
+
+    private final MountableFile jarFile;
+    private final String jarDeployPath;
+
+    @Builder.Default
+    private final MountableFile jattachFile = ContainerTool.jattachFile;
+    private final MountableFile pidScript;
+
+    private final List<String> supportedShellTypes;
+    private final List<Packers> testPackers;
+    private final List<String> probeShellTypes;
+    private final List<Triple<String, String, Packers>> unSupportedCases;
+    private final List<String> unSupportedShellTools;
+
+    @Builder.Default
+    private final boolean assertLogs = true;
+    @Builder.Default
+    private final boolean logContainerOutput = true;
+    @Builder.Default
+    private final long logDelayMillis = 0L;
+    @Builder.Default
+    private final boolean privilegedMode = false;
+    @Builder.Default
+    private final String networkAlias = "app";
+    private final Map<String, String> env;
+    @Builder.Default
+    private final boolean jakarta = false;
+    @Builder.Default
+    private final boolean enableJspPackerTest = true;
+
+    public static ContainerTestConfigBuilder tomcat(String imageName) {
+        return builder()
+                .imageName(imageName)
+                .server(Server.Tomcat)
+                .warFile(ContainerTool.warFile)
+                .warDeployPath("/usr/local/tomcat/webapps/app.war")
+                .pidScript(ContainerTool.tomcatPid);
+    }
+
+    public static ContainerTestConfigBuilder jetty(String imageName) {
+        return builder()
+                .imageName(imageName)
+                .server(Server.Jetty)
+                .warFile(ContainerTool.warFile)
+                .warDeployPath("/var/lib/jetty/webapps/app.war")
+                .pidScript(ContainerTool.jettyPid);
+    }
+
+    public static ContainerTestConfigBuilder resin(String imageName, String warDeployPath) {
+        return builder()
+                .imageName(imageName)
+                .server(Server.Resin)
+                .warFile(ContainerTool.warFile)
+                .warDeployPath(warDeployPath)
+                .pidScript(ContainerTool.resinPid);
+    }
+
+    public static ContainerTestConfigBuilder jboss(String imageName, String warDeployPath) {
+        return builder()
+                .imageName(imageName)
+                .server(Server.JBoss)
+                .warFile(ContainerTool.warFile)
+                .warDeployPath(warDeployPath)
+                .pidScript(ContainerTool.jbossPid);
+    }
+
+    public static ContainerTestConfigBuilder undertow(String imageName, String warDeployPath) {
+        return builder()
+                .imageName(imageName)
+                .server(Server.Undertow)
+                .warFile(ContainerTool.warFile)
+                .warDeployPath(warDeployPath)
+                .pidScript(ContainerTool.jbossPid);
+    }
+
+    public static ContainerTestConfigBuilder glassFish(String imageName, String warDeployPath) {
+        return builder()
+                .imageName(imageName)
+                .server(Server.GlassFish)
+                .warFile(ContainerTool.warFile)
+                .warDeployPath(warDeployPath)
+                .pidScript(ContainerTool.glassfishPid);
+    }
+
+    public static ContainerTestConfigBuilder webLogic(String imageName, String warDeployPath) {
+        return builder()
+                .imageName(imageName)
+                .server(Server.WebLogic)
+                .warFile(ContainerTool.warFile)
+                .warDeployPath(warDeployPath)
+                .pidScript(ContainerTool.weblogicPid)
+                .exposedPort(7001);
+    }
+
+    public static ContainerTestConfigBuilder webSphere(String imageName, String warDeployPath) {
+        return builder()
+                .imageName(imageName)
+                .server(Server.WebSphere)
+                .warFile(ContainerTool.warFile)
+                .warDeployPath(warDeployPath)
+                .pidScript(ContainerTool.webspherePid)
+                .exposedPort(9080)
+                .privilegedMode(true);
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/ContainerTool.java

@@ -18,6 +18,15 @@ public class ContainerTool {
     public static final MountableFile warFile = MountableFile.forHostPath(Path.of("..", "vul", "vul-webapp", "build", "libs", "vul-webapp.war").toAbsolutePath(), 0666);
     public static final MountableFile struct2WarFile = MountableFile.forHostPath(Path.of("..", "vul", "vul-struct2", "build", "libs", "vul-struct2.war").toAbsolutePath());
     public static final MountableFile springBoot2WarFile = MountableFile.forHostPath(Path.of("..", "vul", "vul-springboot2", "build", "libs", "vul-springboot2.war").toAbsolutePath());
+
+    public static final MountableFile springBoot1JarFile = MountableFile.forHostPath(Path.of("..", "vul", "vul-springboot1", "build", "libs", "vul-springboot1.jar").toAbsolutePath());
+    public static final MountableFile springBoot2JarFile = MountableFile.forHostPath(Path.of("..", "vul", "vul-springboot2", "build", "libs", "vul-springboot2.jar").toAbsolutePath());
+    public static final MountableFile springBoot2JettyJarFile = MountableFile.forHostPath(Path.of("..", "vul", "vul-springboot2-jetty", "build", "libs", "vul-springboot2-jetty.jar").toAbsolutePath());
+    public static final MountableFile springBoot2UndertowJarFile = MountableFile.forHostPath(Path.of("..", "vul", "vul-springboot2-undertow", "build", "libs", "vul-springboot2-undertow.jar").toAbsolutePath());
+    public static final MountableFile springBoot2WebfluxJarFile = MountableFile.forHostPath(Path.of("..", "vul", "vul-springboot2-webflux", "build", "libs", "vul-springboot2-webflux.jar").toAbsolutePath());
+    public static final MountableFile springBoot3JarFile = MountableFile.forHostPath(Path.of("..", "vul", "vul-springboot3", "build", "libs", "vul-springboot3.jar").toAbsolutePath());
+    public static final MountableFile springBoot3WebfluxJarFile = MountableFile.forHostPath(Path.of("..", "vul", "vul-springboot3-webflux", "build", "libs", "vul-springboot3-webflux.jar").toAbsolutePath());
+
     public static final Path neoGeorgDockerfile = Path.of("..", "assets", "neoreg", "Dockerfile").toAbsolutePath();
     public static final Path springBoot1Dockerfile = Path.of("..", "vul", "vul-springboot1", "Dockerfile").toAbsolutePath();
     public static final Path springBoot2Dockerfile = Path.of("..", "vul", "vul-springboot2", "Dockerfile").toAbsolutePath();

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/glassfish/GlassFish3ContainerTest.java

@@ -1,99 +1,59 @@
 package com.reajason.javaweb.integration.memshell.glassfish;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellTool;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
 import org.apache.commons.lang3.tuple.Triple;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.api.BeforeAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
 import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
-
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
 
 /**
  * @author ReaJason
  * @since 2024/12/12
  */
-@Slf4j
 @Testcontainers
-public class GlassFish3ContainerTest {
-    public static final String imageName = "reajason/glassfish:3.1.2.2-jdk6";
-    static Network network = Network.newNetwork();
+public class GlassFish3ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig.glassFish(
+            "reajason/glassfish:3.1.2.2-jdk6",
+            "/usr/local/glassfish3/glassfish/domains/domain1/autodeploy/app.war")
+            .targetJdkVersion(Opcodes.V1_6)
+            .waitStrategy(Wait.forLogMessage(".*(deployed|done).*", 1))
+            .supportedShellTypes(List.of(
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.VALVE,
+                    ShellType.AGENT_FILTER_CHAIN,
+                    ShellType.CATALINA_AGENT_CONTEXT_VALVE
+            ))
+            .testPackers(List.of(Packers.JSP))
+            .unSupportedCases(List.of(
+                    Triple.of(ShellType.AGENT_FILTER_CHAIN, ShellTool.Suo5v2, Packers.AgentJar),
+                    Triple.of(ShellType.CATALINA_AGENT_CONTEXT_VALVE, ShellTool.Suo5v2, Packers.AgentJar)
+            ))
+            .probeShellTypes(List.of(
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.VALVE
+            ))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public static final GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warFile, "/usr/local/glassfish3/glassfish/domains/domain1/autodeploy/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(glassfishPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forLogMessage(".*(deployed|done).*", 1))
-            .withExposedPorts(8080);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    @BeforeAll
-    static void setup() {
-        container.waitingFor(Wait.forHttp("/app"));
-    }
-
-    static Stream<Arguments> casesProvider() {
-        String server = Server.GlassFish;
-        List<String> supportedShellTypes = List.of(
-                ShellType.FILTER,
-                ShellType.LISTENER,
-                ShellType.VALVE,
-                ShellType.AGENT_FILTER_CHAIN,
-                ShellType.CATALINA_AGENT_CONTEXT_VALVE
-        );
-        List<Packers> testPackers = List.of(Packers.JSP);
-        List<Triple<String, String, Packers>> unSupportedCases = List.of(
-                Triple.of(ShellType.AGENT_FILTER_CHAIN, ShellTool.Suo5v2, Packers.AgentJar),  // request.inputStream is empty
-                Triple.of(ShellType.CATALINA_AGENT_CONTEXT_VALVE, ShellTool.Suo5v2, Packers.AgentJar)  // request.inputStream is empty
-        );
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers, unSupportedCases);
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        log.info(logs);
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.GlassFish, shellType, shellTool, Opcodes.V1_6, packer, container, python);
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.FILTER,
-            ShellType.LISTENER,
-            ShellType.VALVE,})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.GlassFish, shellType, Opcodes.V1_6);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/glassfish/GlassFish4ContainerTest.java

@@ -1,93 +1,51 @@
 package com.reajason.javaweb.integration.memshell.glassfish;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.api.BeforeAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
-
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
 
 /**
  * @author ReaJason
  * @since 2024/12/12
  */
-@Slf4j
 @Testcontainers
-public class GlassFish4ContainerTest {
-    public static final String imageName = "reajason/glassfish:4.1.2-quick";
-    static Network network = Network.newNetwork();
+public class GlassFish4ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig.glassFish(
+            "reajason/glassfish:4.1.2-quick",
+            "/usr/local/glassfish4/glassfish/domains/domain1/autodeploy/app.war")
+            .targetJdkVersion(Opcodes.V1_6)
+            .supportedShellTypes(List.of(
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.VALVE,
+                    ShellType.AGENT_FILTER_CHAIN,
+                    ShellType.CATALINA_AGENT_CONTEXT_VALVE
+            ))
+            .testPackers(List.of(Packers.JSP))
+            .probeShellTypes(List.of(
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.VALVE
+            ))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public static final GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warFile, "/usr/local/glassfish4/glassfish/domains/domain1/autodeploy/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(glassfishPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/app"))
-            .withExposedPorts(8080);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    @BeforeAll
-    static void setup() {
-        container.waitingFor(Wait.forLogMessage(".*(deployed|done).*", 1));
-    }
-
-    static Stream<Arguments> casesProvider() {
-        String server = Server.GlassFish;
-        List<String> supportedShellTypes = List.of(
-                ShellType.FILTER,
-                ShellType.LISTENER,
-                ShellType.VALVE,
-                ShellType.AGENT_FILTER_CHAIN,
-                ShellType.CATALINA_AGENT_CONTEXT_VALVE
-        );
-        List<Packers> testPackers = List.of(Packers.JSP);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        log.info(logs);
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.GlassFish, shellType, shellTool, Opcodes.V1_6, packer, container, python);
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.FILTER,
-            ShellType.LISTENER,
-            ShellType.VALVE,})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.GlassFish, shellType, Opcodes.V1_6);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/glassfish/GlassFish501ContainerTest.java

@@ -1,93 +1,51 @@
 package com.reajason.javaweb.integration.memshell.glassfish;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.api.BeforeAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
-
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
 
 /**
  * @author ReaJason
  * @since 2024/12/12
  */
-@Slf4j
 @Testcontainers
-public class GlassFish501ContainerTest {
-    public static final String imageName = "reajason/glassfish:5.0.1";
-    static Network network = Network.newNetwork();
+public class GlassFish501ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig.glassFish(
+            "reajason/glassfish:5.0.1",
+            "/usr/local/glassfish5/glassfish/domains/domain1/autodeploy/app.war")
+            .targetJdkVersion(Opcodes.V1_6)
+            .supportedShellTypes(List.of(
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.VALVE,
+                    ShellType.AGENT_FILTER_CHAIN,
+                    ShellType.CATALINA_AGENT_CONTEXT_VALVE
+            ))
+            .testPackers(List.of(Packers.JSP))
+            .probeShellTypes(List.of(
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.VALVE
+            ))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public static final GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warFile, "/usr/local/glassfish5/glassfish/domains/domain1/autodeploy/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(glassfishPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/app"))
-            .withExposedPorts(8080);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.GlassFish;
-        List<String> supportedShellTypes = List.of(
-                ShellType.FILTER,
-                ShellType.LISTENER,
-                ShellType.VALVE,
-                ShellType.AGENT_FILTER_CHAIN,
-                ShellType.CATALINA_AGENT_CONTEXT_VALVE
-        );
-        List<Packers> testPackers = List.of(Packers.JSP);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
-    }
-
-    @BeforeAll
-    static void setup() {
-        container.waitingFor(Wait.forLogMessage(".*(deployed|done).*", 1));
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        log.info(logs);
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.GlassFish, shellType, shellTool, Opcodes.V1_6, packer, container, python);
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.FILTER,
-            ShellType.LISTENER,
-            ShellType.VALVE,})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.GlassFish, shellType, Opcodes.V1_6);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/glassfish/GlassFish510ContainerTest.java

@@ -1,93 +1,51 @@
 package com.reajason.javaweb.integration.memshell.glassfish;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.api.BeforeAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
-
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
 
 /**
  * @author ReaJason
  * @since 2024/12/12
  */
-@Slf4j
 @Testcontainers
-public class GlassFish510ContainerTest {
-    public static final String imageName = "reajason/glassfish:5.1.0";
-    static Network network = Network.newNetwork();
+public class GlassFish510ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig.glassFish(
+            "reajason/glassfish:5.1.0",
+            "/usr/local/glassfish5/glassfish/domains/domain1/autodeploy/app.war")
+            .targetJdkVersion(Opcodes.V1_6)
+            .supportedShellTypes(List.of(
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.VALVE,
+                    ShellType.AGENT_FILTER_CHAIN,
+                    ShellType.CATALINA_AGENT_CONTEXT_VALVE
+            ))
+            .testPackers(List.of(Packers.JSP))
+            .probeShellTypes(List.of(
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.VALVE
+            ))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public static final GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warFile, "/usr/local/glassfish5/glassfish/domains/domain1/autodeploy/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(glassfishPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/app"))
-            .withExposedPorts(8080);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.GlassFish;
-        List<String> supportedShellTypes = List.of(
-                ShellType.FILTER,
-                ShellType.LISTENER,
-                ShellType.VALVE,
-                ShellType.AGENT_FILTER_CHAIN,
-                ShellType.CATALINA_AGENT_CONTEXT_VALVE
-        );
-        List<Packers> testPackers = List.of(Packers.JSP);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
-    }
-
-    @BeforeAll
-    static void setup() {
-        container.waitingFor(Wait.forLogMessage(".*(deployed|done).*", 1));
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        log.info(logs);
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.GlassFish, shellType, shellTool, Opcodes.V1_6, packer, container, python);
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.FILTER,
-            ShellType.LISTENER,
-            ShellType.VALVE,})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.GlassFish, shellType, Opcodes.V1_6);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/glassfish/GlassFish6ContainerTest.java

@@ -1,92 +1,58 @@
 package com.reajason.javaweb.integration.memshell.glassfish;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellTool;
 import com.reajason.javaweb.memshell.ShellType;
+import com.reajason.javaweb.memshell.shelltool.antsword.AntSword;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.api.BeforeAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
 
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
+import static com.reajason.javaweb.integration.ContainerTool.warJakartaFile;
 
 /**
  * @author ReaJason
  * @since 2024/12/12
  */
-@Slf4j
 @Testcontainers
-public class GlassFish6ContainerTest {
-    public static final String imageName = "reajason/glassfish:6.2.6-jdk11";
-    static Network network = Network.newNetwork();
+public class GlassFish6ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig.glassFish(
+            "reajason/glassfish:6.2.6-jdk11",
+            "/usr/local/glassfish6/glassfish/domains/domain1/autodeploy/app.war")
+            .warFile(warJakartaFile)
+            .targetJdkVersion(Opcodes.V11)
+            .assertLogs(false)
+            .supportedShellTypes(List.of(
+                    ShellType.JAKARTA_FILTER,
+                    ShellType.JAKARTA_LISTENER,
+                    ShellType.JAKARTA_VALVE,
+                    ShellType.AGENT_FILTER_CHAIN,
+                    ShellType.CATALINA_AGENT_CONTEXT_VALVE
+            ))
+            .unSupportedShellTools(List.of(ShellTool.AntSword))
+            .testPackers(List.of(Packers.JSP))
+            .probeShellTypes(List.of(
+                    ShellType.JAKARTA_FILTER,
+                    ShellType.JAKARTA_LISTENER,
+                    ShellType.JAKARTA_VALVE
+            ))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public static final GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warJakartaFile, "/usr/local/glassfish6/glassfish/domains/domain1/autodeploy/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(glassfishPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/app"))
-            .withExposedPorts(8080);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.GlassFish;
-        List<String> supportedShellTypes = List.of(
-                ShellType.JAKARTA_FILTER,
-                ShellType.JAKARTA_LISTENER,
-                ShellType.JAKARTA_VALVE,
-                ShellType.AGENT_FILTER_CHAIN,
-                ShellType.CATALINA_AGENT_CONTEXT_VALVE
-        );
-        List<Packers> testPackers = List.of(Packers.JSP);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers, null, List.of(ShellTool.AntSword));
-    }
-
-    @BeforeAll
-    static void setup() {
-        container.waitingFor(Wait.forLogMessage(".*(deployed|done).*", 1));
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        log.info(logs);
-//        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.GlassFish, shellType, shellTool, Opcodes.V11, packer, container, python);
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.JAKARTA_FILTER,
-            ShellType.JAKARTA_LISTENER,
-            ShellType.JAKARTA_VALVE,})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.GlassFish, shellType, Opcodes.V11);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/glassfish/GlassFish7ContainerTest.java

@@ -1,94 +1,56 @@
 package com.reajason.javaweb.integration.memshell.glassfish;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellTool;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.api.BeforeAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
 
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
+import static com.reajason.javaweb.integration.ContainerTool.warJakartaFile;
 
 /**
  * @author ReaJason
  * @since 2024/12/12
  */
-@Slf4j
 @Testcontainers
-public class GlassFish7ContainerTest {
-    public static final String imageName = "reajason/glassfish:7.0.20-jdk17";
-    static Network network = Network.newNetwork();
+public class GlassFish7ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig.glassFish(
+                    "reajason/glassfish:7.0.20-jdk17",
+                    "/usr/local/glassfish7/glassfish/domains/domain1/autodeploy/app.war")
+            .warFile(warJakartaFile)
+            .targetJdkVersion(Opcodes.V17)
+            .supportedShellTypes(List.of(
+                    ShellType.JAKARTA_FILTER,
+                    ShellType.JAKARTA_LISTENER,
+                    ShellType.JAKARTA_VALVE,
+                    ShellType.AGENT_FILTER_CHAIN,
+                    ShellType.CATALINA_AGENT_CONTEXT_VALVE
+            ))
+            .unSupportedShellTools(List.of(ShellTool.AntSword))
+            .testPackers(List.of(Packers.JSP))
+            .probeShellTypes(List.of(
+                    ShellType.JAKARTA_FILTER,
+                    ShellType.JAKARTA_LISTENER,
+                    ShellType.JAKARTA_VALVE
+            ))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public static final GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warJakartaFile, "/usr/local/glassfish7/glassfish/domains/domain1/autodeploy/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(glassfishPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forLogMessage(".*JMXService.*", 1))
-            .withExposedPorts(8080);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.GlassFish;
-        List<String> supportedShellTypes = List.of(
-                ShellType.JAKARTA_FILTER,
-                ShellType.JAKARTA_LISTENER,
-                ShellType.JAKARTA_VALVE,
-                ShellType.AGENT_FILTER_CHAIN,
-                ShellType.CATALINA_AGENT_CONTEXT_VALVE
-        );
-        List<Packers> testPackers = List.of(Packers.JSP);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers, null, List.of(ShellTool.AntSword));
-    }
-
-    @BeforeAll
-    static void setup() {
-        container.waitingFor(Wait.forHttp("/app/test"));
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        log.info(logs);
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.GlassFish, shellType, shellTool, Opcodes.V17, packer, container, python);
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.JAKARTA_FILTER,
-            ShellType.JAKARTA_LISTENER,
-            ShellType.JAKARTA_VALVE,})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.GlassFish, shellType, Opcodes.V17);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/jbossas/Jboss423ContainerTest.java

@@ -1,89 +1,56 @@
 package com.reajason.javaweb.integration.memshell.jbossas;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
-
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
+import java.util.Map;
 
 /**
  * @author ReaJason
  * @since 2024/12/10
  */
-@Slf4j
 @Testcontainers
-public class Jboss423ContainerTest {
-    public static final String imageName = "reajason/jboss:4-jdk6";
-    static Network network = Network.newNetwork();
+public class Jboss423ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig.jboss(
+            "reajason/jboss:4-jdk6",
+            "/usr/local/jboss/server/default/deploy/app.war")
+            .targetJdkVersion(Opcodes.V1_6)
+            .env(Map.of("JAVA_OPTS",
+                    "-Xms128m -Xmx512m -XX:MaxPermSize=128M -Dsun.rmi.dgc.client.gcInterval=3600000 -Dsun.rmi.dgc.server.gcInterval=3600000"))
+            .supportedShellTypes(List.of(
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.VALVE,
+                    ShellType.PROXY_VALVE,
+                    ShellType.AGENT_FILTER_CHAIN,
+                    ShellType.CATALINA_AGENT_CONTEXT_VALVE
+            ))
+            .testPackers(List.of(Packers.JSP))
+            .probeShellTypes(List.of(
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.VALVE,
+                    ShellType.PROXY_VALVE
+            ))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public static final GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warFile, "/usr/local/jboss/server/default/deploy/app.war")
-            .withEnv("JAVA_OPTS", "-Xms128m -Xmx512m -XX:MaxPermSize=128M -Dsun.rmi.dgc.client.gcInterval=3600000 -Dsun.rmi.dgc.server.gcInterval=3600000")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(jbossPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/app"))
-            .withExposedPorts(8080);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.JBoss;
-        List<String> supportedShellTypes = List.of(
-                ShellType.FILTER,
-                ShellType.LISTENER,
-                ShellType.VALVE,
-                ShellType.PROXY_VALVE,
-                ShellType.AGENT_FILTER_CHAIN,
-                ShellType.CATALINA_AGENT_CONTEXT_VALVE
-        );
-        List<Packers> testPackers = List.of(Packers.JSP);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.JBoss, shellType, shellTool, Opcodes.V1_6, packer, container, python);
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.FILTER,
-            ShellType.LISTENER,
-            ShellType.VALVE,
-            ShellType.PROXY_VALVE,})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.JBoss, shellType, Opcodes.V1_6);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/jbossas/Jboss510ContainerTest.java

@@ -1,91 +1,55 @@
 package com.reajason.javaweb.integration.memshell.jbossas;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellTool;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
-
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
 
 /**
  * @author ReaJason
  * @since 2024/12/10
  */
-@Slf4j
 @Testcontainers
-public class Jboss510ContainerTest {
-    public static final String imageName = "reajason/jboss:5-jdk6";
-    static Network network = Network.newNetwork();
+public class Jboss510ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig.jboss(
+            "reajason/jboss:5-jdk6",
+            "/usr/local/jboss/server/web/deploy/app.war")
+            .targetJdkVersion(Opcodes.V1_6)
+            .supportedShellTypes(List.of(
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.VALVE,
+                    ShellType.PROXY_VALVE,
+                    ShellType.AGENT_FILTER_CHAIN,
+                    ShellType.CATALINA_AGENT_CONTEXT_VALVE
+            ))
+            .testPackers(List.of(Packers.JSP))
+            .unSupportedShellTools(List.of(ShellTool.Behinder))
+            .probeShellTypes(List.of(
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.VALVE,
+                    ShellType.PROXY_VALVE
+            ))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public static final GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warFile, "/usr/local/jboss/server/web/deploy/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(jbossPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/app"))
-            .withExposedPorts(8080);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.JBoss;
-        List<String> supportedShellTypes = List.of(
-                ShellType.FILTER, ShellType.LISTENER,
-                ShellType.VALVE,
-                ShellType.PROXY_VALVE,
-                ShellType.AGENT_FILTER_CHAIN,
-                ShellType.CATALINA_AGENT_CONTEXT_VALVE
-        );
-        List<Packers> testPackers = List.of(Packers.JSP);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers,
-                null, List.of(ShellTool.Behinder) // Behinder SocketTimeOuts
-        );
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        log.info(logs);
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.JBoss, shellType, shellTool, Opcodes.V1_6, packer, container, python);
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.FILTER,
-            ShellType.LISTENER,
-            ShellType.VALVE,
-            ShellType.PROXY_VALVE,})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.JBoss, shellType, Opcodes.V1_6);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/jbossas/Jboss610ContainerTest.java

@@ -1,87 +1,53 @@
 package com.reajason.javaweb.integration.memshell.jbossas;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
-
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
 
 /**
  * @author ReaJason
  * @since 2024/12/10
  */
-@Slf4j
 @Testcontainers
-public class Jboss610ContainerTest {
-    public static final String imageName = "reajason/jboss:6-jdk7";
-    static Network network = Network.newNetwork();
+public class Jboss610ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig.jboss(
+            "reajason/jboss:6-jdk7",
+            "/usr/local/jboss/server/jbossweb-standalone/deploy/app.war")
+            .targetJdkVersion(Opcodes.V1_6)
+            .supportedShellTypes(List.of(
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.VALVE,
+                    ShellType.PROXY_VALVE,
+                    ShellType.AGENT_FILTER_CHAIN,
+                    ShellType.CATALINA_AGENT_CONTEXT_VALVE
+            ))
+            .testPackers(List.of(Packers.JSP))
+            .probeShellTypes(List.of(
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.VALVE,
+                    ShellType.PROXY_VALVE
+            ))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public static final GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warFile, "/usr/local/jboss/server/jbossweb-standalone/deploy/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(jbossPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/app"))
-            .withExposedPorts(8080);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.JBoss;
-        List<String> supportedShellTypes = List.of(
-                ShellType.FILTER, ShellType.LISTENER,
-                ShellType.VALVE,
-                ShellType.PROXY_VALVE,
-                ShellType.AGENT_FILTER_CHAIN,
-                ShellType.CATALINA_AGENT_CONTEXT_VALVE
-        );
-        List<Packers> testPackers = List.of(Packers.JSP);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.JBoss, shellType, shellTool, Opcodes.V1_6, packer, container, python);
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.FILTER,
-            ShellType.LISTENER,
-            ShellType.VALVE,
-            ShellType.PROXY_VALVE,})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.JBoss, shellType, Opcodes.V1_6);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/jbossas/Jboss711ContainerTest.java

@@ -1,90 +1,53 @@
 package com.reajason.javaweb.integration.memshell.jbossas;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
-
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
 
 /**
  * @author ReaJason
  * @since 2024/12/10
  */
-@Slf4j
 @Testcontainers
-public class Jboss711ContainerTest {
-    public static final String imageName = "reajason/jboss:7-jdk7";
-    static Network network = Network.newNetwork();
+public class Jboss711ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig.jboss(
+            "reajason/jboss:7-jdk7",
+            "/usr/local/jboss/standalone/deployments/app.war")
+            .targetJdkVersion(Opcodes.V1_7)
+            .supportedShellTypes(List.of(
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.VALVE,
+                    ShellType.PROXY_VALVE,
+                    ShellType.AGENT_FILTER_CHAIN,
+                    ShellType.CATALINA_AGENT_CONTEXT_VALVE
+            ))
+            .testPackers(List.of(Packers.JSP))
+            .probeShellTypes(List.of(
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.VALVE,
+                    ShellType.PROXY_VALVE
+            ))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public static final GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warFile, "/usr/local/jboss/standalone/deployments/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(jbossPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/app"))
-            .withExposedPorts(8080);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    /**
-     * 找不到 Templates 类暂时先不测试反序列化
-     */
-    static Stream<Arguments> casesProvider() {
-        String server = Server.JBoss;
-        List<String> supportedShellTypes = List.of(
-                ShellType.FILTER, ShellType.LISTENER,
-                ShellType.VALVE,
-                ShellType.PROXY_VALVE,
-                ShellType.AGENT_FILTER_CHAIN,
-                ShellType.CATALINA_AGENT_CONTEXT_VALVE
-        );
-        List<Packers> testPackers = List.of(Packers.JSP);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.JBoss, shellType, shellTool, Opcodes.V1_7, packer, container, python);
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.FILTER,
-            ShellType.LISTENER,
-            ShellType.VALVE,
-            ShellType.PROXY_VALVE,})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.JBoss, shellType, Opcodes.V1_7);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/jbosseap/JbossEap6ContainerTest.java

@@ -1,89 +1,53 @@
 package com.reajason.javaweb.integration.memshell.jbosseap;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
-
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
 
 /**
  * @author ReaJason
  * @since 2024/12/10
  */
-@Slf4j
 @Testcontainers
-public class JbossEap6ContainerTest {
-    public static final String imageName = "reajason/jboss:eap-6-jdk8";
-    static Network network = Network.newNetwork();
+public class JbossEap6ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig.jboss(
+            "reajason/jboss:eap-6-jdk8",
+            "/usr/local/jboss/standalone/deployments/app.war")
+            .targetJdkVersion(Opcodes.V1_6)
+            .supportedShellTypes(List.of(
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.VALVE,
+                    ShellType.PROXY_VALVE,
+                    ShellType.AGENT_FILTER_CHAIN,
+                    ShellType.CATALINA_AGENT_CONTEXT_VALVE
+            ))
+            .testPackers(List.of(Packers.JSP))
+            .probeShellTypes(List.of(
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.VALVE,
+                    ShellType.PROXY_VALVE
+            ))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public static final GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warFile, "/usr/local/jboss/standalone/deployments/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(jbossPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/app"))
-            .withExposedPorts(8080);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.JBoss;
-        List<String> supportedShellTypes = List.of(
-                ShellType.FILTER,
-                ShellType.LISTENER,
-                ShellType.VALVE,
-                ShellType.PROXY_VALVE,
-                ShellType.AGENT_FILTER_CHAIN,
-                ShellType.CATALINA_AGENT_CONTEXT_VALVE
-        );
-        List<Packers> testPackers = List.of(Packers.JSP);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        log.info(logs);
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.JBoss, shellType, shellTool, Opcodes.V1_6, packer, container, python);
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.FILTER,
-            ShellType.LISTENER,
-            ShellType.VALVE,
-            ShellType.PROXY_VALVE,})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.JBoss, shellType, Opcodes.V1_6);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/jbosseap/JbossEap7ContainerTest.java

@@ -1,86 +1,50 @@
 package com.reajason.javaweb.integration.memshell.jbosseap;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
-
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
 
 /**
  * @author ReaJason
  * @since 2024/12/10
  */
-@Slf4j
 @Testcontainers
-public class JbossEap7ContainerTest {
-    public static final String imageName = "reajason/jboss:eap-7-jdk8";
-    static Network network = Network.newNetwork();
+public class JbossEap7ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig.undertow(
+            "reajason/jboss:eap-7-jdk8",
+            "/usr/local/jboss/standalone/deployments/app.war")
+            .targetJdkVersion(Opcodes.V1_6)
+            .supportedShellTypes(List.of(
+                    ShellType.SERVLET,
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.UNDERTOW_AGENT_SERVLET_HANDLER
+            ))
+            .testPackers(List.of(Packers.JSP))
+            .probeShellTypes(List.of(
+                    ShellType.SERVLET,
+                    ShellType.FILTER,
+                    ShellType.LISTENER
+            ))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public static final GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warFile, "/usr/local/jboss/standalone/deployments/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(jbossPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/app"))
-            .withExposedPorts(8080);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.Undertow;
-        List<String> supportedShellTypes = List.of(
-                ShellType.SERVLET,
-                ShellType.FILTER,
-                ShellType.LISTENER,
-                ShellType.UNDERTOW_AGENT_SERVLET_HANDLER
-        );
-        List<Packers> testPackers = List.of(Packers.JSP);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        log.info(logs);
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.Undertow, shellType, shellTool, Opcodes.V1_6, packer, container, python);
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.SERVLET,
-            ShellType.FILTER,
-            ShellType.LISTENER,})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.Undertow, shellType, Opcodes.V1_6);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/jbosseap/JbossEap81ContainerTest.java

@@ -1,89 +1,55 @@
 package com.reajason.javaweb.integration.memshell.jbosseap;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellTool;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
 
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
+import static com.reajason.javaweb.integration.ContainerTool.warJakartaFile;
 
 /**
  * @author ReaJason
  * @since 2024/12/10
  */
-@Slf4j
 @Testcontainers
-public class JbossEap81ContainerTest {
-    public static final String imageName = "reajason/jboss:eap-8.1-jdk17";
-    static Network network = Network.newNetwork();
+public class JbossEap81ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig.undertow(
+            "reajason/jboss:eap-8.1-jdk17",
+            "/usr/local/jboss/standalone/deployments/app.war")
+            .warFile(warJakartaFile)
+            .targetJdkVersion(Opcodes.V17)
+            .supportedShellTypes(List.of(
+                    ShellType.JAKARTA_SERVLET,
+                    ShellType.JAKARTA_FILTER,
+                    ShellType.JAKARTA_LISTENER,
+                    ShellType.UNDERTOW_AGENT_SERVLET_HANDLER
+            ))
+            .testPackers(List.of(Packers.JSP))
+            .unSupportedShellTools(List.of(ShellTool.AntSword))
+            .probeShellTypes(List.of(
+                    ShellType.JAKARTA_SERVLET,
+                    ShellType.JAKARTA_FILTER,
+                    ShellType.JAKARTA_LISTENER
+            ))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public static final GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warJakartaFile, "/usr/local/jboss/standalone/deployments/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(jbossPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/app"))
-            .withExposedPorts(8080);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.Undertow;
-        List<String> supportedShellTypes = List.of(
-                ShellType.JAKARTA_SERVLET,
-                ShellType.JAKARTA_FILTER,
-                ShellType.JAKARTA_LISTENER,
-                ShellType.UNDERTOW_AGENT_SERVLET_HANDLER
-        );
-        List<Packers> testPackers = List.of(Packers.JSP);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers,
-                null, List.of(ShellTool.AntSword) // AntSword not support jakarta
-        );
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        log.info(logs);
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.Undertow, shellType, shellTool, Opcodes.V17, packer, container, python);
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.JAKARTA_SERVLET,
-            ShellType.JAKARTA_FILTER,
-            ShellType.JAKARTA_LISTENER,})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.Undertow, shellType, Opcodes.V17);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/jetty/Jetty10ContainerTest.java

@@ -1,90 +1,55 @@
 package com.reajason.javaweb.integration.memshell.jetty;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
-
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
 
 /**
  * @author ReaJason
  * @since 2024/12/7
  */
-@Slf4j
 @Testcontainers
-public class Jetty10ContainerTest {
-    public static final String imageName = "jetty:10-jre11";
-    static Network network = Network.newNetwork();
+public class Jetty10ContainerTest extends AbstractContainerTest {
+
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig
+            .jetty("jetty:10-jre11")
+            .serverVersion("7+")
+            .targetJdkVersion(Opcodes.V11)
+            .supportedShellTypes(List.of(
+                    ShellType.SERVLET,
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.HANDLER,
+                    ShellType.CUSTOMIZER,
+                    ShellType.JETTY_AGENT_HANDLER
+            ))
+            .testPackers(List.of(Packers.JSP))
+            .probeShellTypes(List.of(
+                    ShellType.SERVLET,
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.HANDLER,
+                    ShellType.CUSTOMIZER
+            ))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warFile, "/var/lib/jetty/webapps/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(jettyPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/app"))
-            .withExposedPorts(8080);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.Jetty;
-        List<String> supportedShellTypes = List.of(
-                ShellType.SERVLET,
-                ShellType.FILTER,
-                ShellType.LISTENER,
-                ShellType.HANDLER,
-                ShellType.CUSTOMIZER,
-                ShellType.JETTY_AGENT_HANDLER
-        );
-        List<Packers> testPackers = List.of(Packers.JSP);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        log.info(logs);
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.Jetty, "7+", shellType, shellTool, Opcodes.V11, packer, container, python);
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.SERVLET,
-            ShellType.FILTER,
-            ShellType.LISTENER,
-            ShellType.HANDLER,
-            ShellType.CUSTOMIZER,})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.Jetty, "7+", shellType, Opcodes.V11);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/jetty/Jetty11ContainerTest.java

@@ -1,92 +1,60 @@
 package com.reajason.javaweb.integration.memshell.jetty;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellTool;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
 
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
+import static com.reajason.javaweb.integration.ContainerTool.warJakartaFile;
 
 /**
  * @author ReaJason
  * @since 2024/12/7
  */
-@Slf4j
 @Testcontainers
-public class Jetty11ContainerTest {
-    public static final String imageName = "jetty:11.0-jre17";
-    static Network network = Network.newNetwork();
+public class Jetty11ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig
+            .jetty("jetty:11.0-jre17")
+            .warFile(warJakartaFile)
+            .serverVersion("7+")
+            .jakarta(true)
+            .targetJdkVersion(Opcodes.V17)
+            .supportedShellTypes(List.of(
+                    ShellType.JAKARTA_SERVLET,
+                    ShellType.JAKARTA_FILTER,
+                    ShellType.JAKARTA_LISTENER,
+                    ShellType.JAKARTA_HANDLER,
+                    ShellType.CUSTOMIZER,
+                    ShellType.JETTY_AGENT_HANDLER
+            ))
+            .testPackers(List.of(Packers.JSP))
+            .unSupportedShellTools(List.of(ShellTool.AntSword))
+            .probeShellTypes(List.of(
+                    ShellType.JAKARTA_SERVLET,
+                    ShellType.JAKARTA_FILTER,
+                    ShellType.JAKARTA_LISTENER,
+                    ShellType.JAKARTA_HANDLER,
+                    ShellType.CUSTOMIZER
+            ))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warJakartaFile, "/var/lib/jetty/webapps/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(jettyPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/app"))
-            .withExposedPorts(8080);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.Jetty;
-        List<String> supportedShellTypes = List.of(
-                ShellType.JAKARTA_SERVLET,
-                ShellType.JAKARTA_FILTER,
-                ShellType.JAKARTA_LISTENER,
-                ShellType.JAKARTA_HANDLER,
-                ShellType.CUSTOMIZER,
-                ShellType.JETTY_AGENT_HANDLER
-        );
-        List<Packers> testPackers = List.of(Packers.JSP);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers,
-                null, List.of(ShellTool.AntSword)
-        );
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.Jetty, "7+", shellType, shellTool, Opcodes.V17, packer, container, python);
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.JAKARTA_SERVLET,
-            ShellType.JAKARTA_FILTER,
-            ShellType.JAKARTA_LISTENER,
-            ShellType.JAKARTA_HANDLER,
-            ShellType.CUSTOMIZER,})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.Jetty, "7+", shellType, Opcodes.V17);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/jetty/Jetty12ee10ContainerTest.java

@@ -1,90 +1,59 @@
 package com.reajason.javaweb.integration.memshell.jetty;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellTool;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
 
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
+import static com.reajason.javaweb.integration.ContainerTool.warJakartaFile;
 
 /**
  * @author ReaJason
  * @since 2024/12/7
  */
-@Slf4j
 @Testcontainers
-public class Jetty12ee10ContainerTest {
-    public static final String imageName = "reajason/jetty:12.0-jre21-ee10";
-    static Network network = Network.newNetwork();
+public class Jetty12ee10ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig
+            .jetty("reajason/jetty:12.0-jre21-ee10")
+            .warFile(warJakartaFile)
+            .jakarta(true)
+            .serverVersion("12")
+            .targetJdkVersion(Opcodes.V21)
+            .probeTargetJdkVersion(Opcodes.V17)
+            .supportedShellTypes(List.of(
+                    ShellType.JAKARTA_SERVLET,
+                    ShellType.JAKARTA_FILTER,
+                    ShellType.JAKARTA_LISTENER,
+                    ShellType.JAKARTA_HANDLER,
+                    ShellType.JETTY_AGENT_HANDLER
+            ))
+            .testPackers(List.of(Packers.Base64))
+            .unSupportedShellTools(List.of(ShellTool.AntSword))
+            .probeShellTypes(List.of(
+                    ShellType.JAKARTA_SERVLET,
+                    ShellType.JAKARTA_FILTER,
+                    ShellType.JAKARTA_LISTENER,
+                    ShellType.JAKARTA_HANDLER
+            ))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warJakartaFile, "/var/lib/jetty/webapps/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(jettyPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/app"))
-            .withExposedPorts(8080);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.Jetty;
-        List<String> supportedShellTypes = List.of(
-                ShellType.JAKARTA_SERVLET,
-                ShellType.JAKARTA_FILTER,
-                ShellType.JAKARTA_LISTENER,
-                ShellType.JAKARTA_HANDLER,
-                ShellType.JETTY_AGENT_HANDLER
-        );
-        List<Packers> testPackers = List.of(Packers.Base64);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers,
-                null, List.of(ShellTool.AntSword) // AntSword not supported Jakarta
-        );
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.Jetty, "12", shellType, shellTool, Opcodes.V21, packer, container, python);
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.JAKARTA_SERVLET,
-            ShellType.JAKARTA_FILTER,
-            ShellType.JAKARTA_LISTENER,
-            ShellType.JAKARTA_HANDLER})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.Jetty, "12", shellType, Opcodes.V17);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/jetty/Jetty12ee11ContainerTest.java

@@ -1,91 +1,59 @@
 package com.reajason.javaweb.integration.memshell.jetty;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellTool;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
 
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
+import static com.reajason.javaweb.integration.ContainerTool.warJakartaFile;
 
 /**
  * @author ReaJason
- * @since 2025/11/11
+ * @since 2024/12/7
  */
-@Slf4j
 @Testcontainers
-public class Jetty12ee11ContainerTest {
-    public static final String imageName = "reajason/jetty:12.1-jre21-ee11";
-    static Network network = Network.newNetwork();
+public class Jetty12ee11ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig
+            .jetty("reajason/jetty:12.1-jre21-ee11")
+            .warFile(warJakartaFile)
+            .jakarta(true)
+            .serverVersion("12")
+            .targetJdkVersion(Opcodes.V21)
+            .probeTargetJdkVersion(Opcodes.V17)
+            .supportedShellTypes(List.of(
+                    ShellType.JAKARTA_SERVLET,
+                    ShellType.JAKARTA_FILTER,
+                    ShellType.JAKARTA_LISTENER,
+                    ShellType.JAKARTA_HANDLER,
+                    ShellType.JETTY_AGENT_HANDLER
+            ))
+            .testPackers(List.of(Packers.Base64))
+            .unSupportedShellTools(List.of(ShellTool.AntSword))
+            .probeShellTypes(List.of(
+                    ShellType.JAKARTA_SERVLET,
+                    ShellType.JAKARTA_FILTER,
+                    ShellType.JAKARTA_LISTENER,
+                    ShellType.JAKARTA_HANDLER
+            ))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warJakartaFile, "/var/lib/jetty/webapps/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(jettyPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/app"))
-            .withExposedPorts(8080);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.Jetty;
-        List<String> supportedShellTypes = List.of(
-                ShellType.JAKARTA_SERVLET,
-                ShellType.JAKARTA_FILTER,
-                ShellType.JAKARTA_LISTENER,
-                ShellType.JAKARTA_HANDLER,
-                ShellType.JETTY_AGENT_HANDLER
-        );
-        List<Packers> testPackers = List.of(Packers.Base64);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers,
-                null, List.of(ShellTool.AntSword) // AntSword not supported Jakarta
-        );
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        log.info(logs);
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.Jetty, "12", shellType, shellTool, Opcodes.V21, packer, container, python);
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.JAKARTA_SERVLET,
-            ShellType.JAKARTA_FILTER,
-            ShellType.JAKARTA_LISTENER,
-            ShellType.JAKARTA_HANDLER})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.Jetty, "12", shellType, Opcodes.V17);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/jetty/Jetty12ee8ContainerTest.java

@@ -1,88 +1,53 @@
 package com.reajason.javaweb.integration.memshell.jetty;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
-
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
 
 /**
  * @author ReaJason
  * @since 2024/12/7
  */
-@Slf4j
 @Testcontainers
-public class Jetty12ee8ContainerTest {
-    public static final String imageName = "reajason/jetty:12.0-jre21-ee8";
-    static Network network = Network.newNetwork();
+public class Jetty12ee8ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig
+            .jetty("reajason/jetty:12.0-jre21-ee8")
+            .serverVersion("12")
+            .targetJdkVersion(Opcodes.V21)
+            .probeTargetJdkVersion(Opcodes.V17)
+            .supportedShellTypes(List.of(
+                    ShellType.SERVLET,
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.HANDLER,
+                    ShellType.JETTY_AGENT_HANDLER
+            ))
+            .testPackers(List.of(Packers.Base64))
+            .probeShellTypes(List.of(
+                    ShellType.SERVLET,
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.HANDLER
+            ))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warFile, "/var/lib/jetty/webapps/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(jettyPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/app"))
-            .withExposedPorts(8080);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.Jetty;
-        List<String> supportedShellTypes = List.of(
-                ShellType.SERVLET,
-                ShellType.FILTER,
-                ShellType.LISTENER,
-                ShellType.HANDLER,
-                ShellType.JETTY_AGENT_HANDLER
-        );
-        List<Packers> testPackers = List.of(Packers.Base64);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        log.info(logs);
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.Jetty, "12", shellType, shellTool, Opcodes.V21, packer, container, python);
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.SERVLET,
-            ShellType.FILTER,
-            ShellType.LISTENER,
-            ShellType.HANDLER,})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.Jetty, "12", shellType, Opcodes.V17);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/jetty/Jetty12ee9ContainerTest.java

@@ -1,90 +1,59 @@
 package com.reajason.javaweb.integration.memshell.jetty;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellTool;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
 
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
+import static com.reajason.javaweb.integration.ContainerTool.warJakartaFile;
 
 /**
  * @author ReaJason
  * @since 2024/12/7
  */
-@Slf4j
 @Testcontainers
-public class Jetty12ee9ContainerTest {
-    public static final String imageName = "reajason/jetty:12.0-jre21-ee9";
-    static Network network = Network.newNetwork();
+public class Jetty12ee9ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig
+            .jetty("reajason/jetty:12.0-jre21-ee9")
+            .warFile(warJakartaFile)
+            .jakarta(true)
+            .serverVersion("12")
+            .targetJdkVersion(Opcodes.V21)
+            .probeTargetJdkVersion(Opcodes.V17)
+            .supportedShellTypes(List.of(
+                    ShellType.JAKARTA_SERVLET,
+                    ShellType.JAKARTA_FILTER,
+                    ShellType.JAKARTA_LISTENER,
+                    ShellType.JAKARTA_HANDLER,
+                    ShellType.JETTY_AGENT_HANDLER
+            ))
+            .testPackers(List.of(Packers.Base64))
+            .unSupportedShellTools(List.of(ShellTool.AntSword))
+            .probeShellTypes(List.of(
+                    ShellType.JAKARTA_SERVLET,
+                    ShellType.JAKARTA_FILTER,
+                    ShellType.JAKARTA_LISTENER,
+                    ShellType.JAKARTA_HANDLER
+            ))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warJakartaFile, "/var/lib/jetty/webapps/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(jettyPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/app"))
-            .withExposedPorts(8080);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.Jetty;
-        List<String> supportedShellTypes = List.of(
-                ShellType.JAKARTA_SERVLET,
-                ShellType.JAKARTA_FILTER,
-                ShellType.JAKARTA_LISTENER,
-                ShellType.JAKARTA_HANDLER,
-                ShellType.JETTY_AGENT_HANDLER
-        );
-        List<Packers> testPackers = List.of(Packers.Base64);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers,
-                null, List.of(ShellTool.AntSword) // AntSword not supported Jakarta
-        );
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.Jetty, "12", shellType, shellTool, Opcodes.V21, packer, container, python);
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.JAKARTA_SERVLET,
-            ShellType.JAKARTA_FILTER,
-            ShellType.JAKARTA_LISTENER,
-            ShellType.JAKARTA_HANDLER})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.Jetty, "12", shellType, Opcodes.V17);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/jetty/Jetty61ContainerTest.java

@@ -1,88 +1,52 @@
 package com.reajason.javaweb.integration.memshell.jetty;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
-
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
 
 /**
  * @author ReaJason
  * @since 2024/12/7
  */
-@Slf4j
 @Testcontainers
-public class Jetty61ContainerTest {
-    public static final String imageName = "reajason/jetty:6.1-jdk6";
-    static Network network = Network.newNetwork();
+public class Jetty61ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig
+            .jetty("reajason/jetty:6.1-jdk6")
+            .serverVersion("6")
+            .targetJdkVersion(Opcodes.V1_6)
+            .supportedShellTypes(List.of(
+                    ShellType.SERVLET,
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.HANDLER,
+                    ShellType.JETTY_AGENT_HANDLER
+            ))
+            .testPackers(List.of(Packers.JSP))
+            .probeShellTypes(List.of(
+                    ShellType.SERVLET,
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.HANDLER
+            ))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warFile, "/usr/local/jetty/webapps/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(jettyPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/app"))
-            .withExposedPorts(8080);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.Jetty;
-        List<String> supportedShellTypes = List.of(
-                ShellType.SERVLET,
-                ShellType.FILTER,
-                ShellType.LISTENER,
-                ShellType.HANDLER,
-                ShellType.JETTY_AGENT_HANDLER
-        );
-        List<Packers> testPackers = List.of(Packers.JSP);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        log.info(logs);
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.Jetty, "6", shellType, shellTool, Opcodes.V1_6, packer, container, python);
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.SERVLET,
-            ShellType.FILTER,
-            ShellType.LISTENER,
-            ShellType.HANDLER,})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.Jetty, "6", shellType, Opcodes.V1_6);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/jetty/Jetty75ContainerTest.java

@@ -1,88 +1,53 @@
 package com.reajason.javaweb.integration.memshell.jetty;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
-
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
 
 /**
  * @author ReaJason
  * @since 2024/12/7
  */
-@Slf4j
 @Testcontainers
-public class Jetty75ContainerTest {
-    public static final String imageName = "reajason/jetty:7.5.4-jdk6";
-    static Network network = Network.newNetwork();
+public class Jetty75ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig
+            .jetty("reajason/jetty:7.5.4-jdk6")
+            .warDeployPath("/usr/local/jetty/webapps/app.war")
+            .serverVersion("7+")
+            .targetJdkVersion(Opcodes.V1_6)
+            .supportedShellTypes(List.of(
+                    ShellType.SERVLET,
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.HANDLER,
+                    ShellType.JETTY_AGENT_HANDLER
+            ))
+            .testPackers(List.of(Packers.JSP))
+            .probeShellTypes(List.of(
+                    ShellType.SERVLET,
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.HANDLER
+            ))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warFile, "/usr/local/jetty/webapps/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(jettyPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/app"))
-            .withExposedPorts(8080);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.Jetty;
-        List<String> supportedShellTypes = List.of(
-                ShellType.SERVLET,
-                ShellType.FILTER,
-                ShellType.LISTENER,
-                ShellType.HANDLER,
-                ShellType.JETTY_AGENT_HANDLER
-        );
-        List<Packers> testPackers = List.of(Packers.JSP);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        log.info("logs: {}", logs);
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.Jetty,"7+", shellType, shellTool, Opcodes.V1_6, packer, container, python);
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.SERVLET,
-            ShellType.FILTER,
-            ShellType.LISTENER,
-            ShellType.HANDLER,})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.Jetty, "7+", shellType, Opcodes.V1_6);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/jetty/Jetty76ContainerTest.java

@@ -1,87 +1,53 @@
 package com.reajason.javaweb.integration.memshell.jetty;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
-
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
 
 /**
  * @author ReaJason
  * @since 2024/12/7
  */
-@Slf4j
 @Testcontainers
-public class Jetty76ContainerTest {
-    public static final String imageName = "reajason/jetty:7.6-jdk6";
-    static Network network = Network.newNetwork();
+public class Jetty76ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig
+            .jetty("reajason/jetty:7.6-jdk6")
+            .warDeployPath("/usr/local/jetty/webapps/app.war")
+            .serverVersion("7+")
+            .targetJdkVersion(Opcodes.V1_6)
+            .supportedShellTypes(List.of(
+                    ShellType.SERVLET,
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.HANDLER,
+                    ShellType.JETTY_AGENT_HANDLER
+            ))
+            .testPackers(List.of(Packers.JSP))
+            .probeShellTypes(List.of(
+                    ShellType.SERVLET,
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.HANDLER
+            ))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warFile, "/usr/local/jetty/webapps/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(jettyPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/app"))
-            .withExposedPorts(8080);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.Jetty;
-        List<String> supportedShellTypes = List.of(
-                ShellType.SERVLET,
-                ShellType.FILTER,
-                ShellType.LISTENER,
-                ShellType.HANDLER,
-                ShellType.JETTY_AGENT_HANDLER
-        );
-        List<Packers> testPackers = List.of(Packers.JSP);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.Jetty, "7+", shellType, shellTool, Opcodes.V1_6, packer, container, python);
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.SERVLET,
-            ShellType.FILTER,
-            ShellType.LISTENER,
-            ShellType.HANDLER,})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.Jetty, "7+", shellType, Opcodes.V1_6);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/jetty/Jetty81ContainerTest.java

@@ -1,88 +1,53 @@
 package com.reajason.javaweb.integration.memshell.jetty;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
-
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
 
 /**
  * @author ReaJason
  * @since 2024/12/7
  */
-@Slf4j
 @Testcontainers
-public class Jetty81ContainerTest {
-    public static final String imageName = "reajason/jetty:8.1-jdk7";
-    static Network network = Network.newNetwork();
+public class Jetty81ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig
+            .jetty("reajason/jetty:8.1-jdk7")
+            .warDeployPath("/usr/local/jetty/webapps/app.war")
+            .serverVersion("7+")
+            .targetJdkVersion(Opcodes.V1_6)
+            .supportedShellTypes(List.of(
+                    ShellType.SERVLET,
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.HANDLER,
+                    ShellType.JETTY_AGENT_HANDLER
+            ))
+            .testPackers(List.of(Packers.JSP))
+            .probeShellTypes(List.of(
+                    ShellType.SERVLET,
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.HANDLER
+            ))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warFile, "/usr/local/jetty/webapps/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(jettyPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/app"))
-            .withExposedPorts(8080);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.Jetty;
-        List<String> supportedShellTypes = List.of(
-                ShellType.SERVLET,
-                ShellType.FILTER,
-                ShellType.LISTENER,
-                ShellType.HANDLER,
-                ShellType.JETTY_AGENT_HANDLER
-        );
-        List<Packers> testPackers = List.of(Packers.JSP);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        log.info("logs: {}", logs);
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.Jetty, "7+", shellType, shellTool, Opcodes.V1_6, packer, container, python);
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.SERVLET,
-            ShellType.FILTER,
-            ShellType.LISTENER,
-            ShellType.HANDLER,})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.Jetty, "7+", shellType, Opcodes.V1_6);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/jetty/Jetty92ContainerTest.java

@@ -1,91 +1,54 @@
 package com.reajason.javaweb.integration.memshell.jetty;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
-
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
 
 /**
  * @author ReaJason
  * @since 2024/12/7
  */
-@Slf4j
 @Testcontainers
-public class Jetty92ContainerTest {
+public class Jetty92ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig
+            .jetty("jetty:9.2-jre7")
+            .serverVersion("7+")
+            .targetJdkVersion(Opcodes.V1_6)
+            .supportedShellTypes(List.of(
+                    ShellType.SERVLET,
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.HANDLER,
+                    ShellType.CUSTOMIZER,
+                    ShellType.JETTY_AGENT_HANDLER
+            ))
+            .testPackers(List.of(Packers.JSP))
+            .probeShellTypes(List.of(
+                    ShellType.SERVLET,
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.HANDLER,
+                    ShellType.CUSTOMIZER
+            ))
+            .build();
 
-    public static final String imageName = "jetty:9.2-jre7";
-    static Network network = Network.newNetwork();
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warFile, "/var/lib/jetty/webapps/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(jettyPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/app"))
-            .withExposedPorts(8080);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.Jetty;
-        List<String> supportedShellTypes = List.of(
-                ShellType.SERVLET,
-                ShellType.FILTER,
-                ShellType.LISTENER,
-                ShellType.HANDLER,
-                ShellType.CUSTOMIZER,
-                ShellType.JETTY_AGENT_HANDLER
-        );
-        List<Packers> testPackers = List.of(Packers.JSP);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        log.info(logs);
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.Jetty, "7+", shellType, shellTool, Opcodes.V1_6, packer, container, python);
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.SERVLET,
-            ShellType.FILTER,
-            ShellType.LISTENER,
-            ShellType.HANDLER,
-            ShellType.CUSTOMIZER,})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.Jetty, "7+", shellType, Opcodes.V1_6);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/jetty/Jetty93ContainerTest.java

@@ -1,90 +1,54 @@
 package com.reajason.javaweb.integration.memshell.jetty;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
-
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
 
 /**
  * @author ReaJason
  * @since 2024/12/7
  */
-@Slf4j
 @Testcontainers
-public class Jetty93ContainerTest {
-    public static final String imageName = "reajason/jetty:9.3";
-    static Network network = Network.newNetwork();
+public class Jetty93ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig
+            .jetty("reajason/jetty:9.3")
+            .serverVersion("7+")
+            .targetJdkVersion(Opcodes.V1_6)
+            .supportedShellTypes(List.of(
+                    ShellType.SERVLET,
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.HANDLER,
+                    ShellType.CUSTOMIZER,
+                    ShellType.JETTY_AGENT_HANDLER
+            ))
+            .testPackers(List.of(Packers.JSP))
+            .probeShellTypes(List.of(
+                    ShellType.SERVLET,
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.HANDLER,
+                    ShellType.CUSTOMIZER
+            ))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warFile, "/var/lib/jetty/webapps/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(jettyPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/app"))
-            .withExposedPorts(8080);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.Jetty;
-        List<String> supportedShellTypes = List.of(
-                ShellType.SERVLET,
-                ShellType.FILTER,
-                ShellType.LISTENER,
-                ShellType.HANDLER,
-                ShellType.CUSTOMIZER,
-                ShellType.JETTY_AGENT_HANDLER
-        );
-        List<Packers> testPackers = List.of(Packers.JSP);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        log.info(logs);
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.Jetty, "7+", shellType, shellTool, Opcodes.V1_6, packer, container, python);
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.SERVLET,
-            ShellType.FILTER,
-            ShellType.LISTENER,
-            ShellType.HANDLER,
-            ShellType.CUSTOMIZER,})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.Jetty, "7+", shellType, Opcodes.V1_6);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/jetty/Jetty94ContainerTest.java

@@ -1,90 +1,54 @@
 package com.reajason.javaweb.integration.memshell.jetty;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
-
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
 
 /**
  * @author ReaJason
  * @since 2024/12/7
  */
-@Slf4j
 @Testcontainers
-public class Jetty94ContainerTest {
-    public static final String imageName = "jetty:9.4-jre8";
-    static Network network = Network.newNetwork();
+public class Jetty94ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig
+            .jetty("jetty:9.4-jre8")
+            .serverVersion("7+")
+            .targetJdkVersion(Opcodes.V1_6)
+            .supportedShellTypes(List.of(
+                    ShellType.SERVLET,
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.HANDLER,
+                    ShellType.CUSTOMIZER,
+                    ShellType.JETTY_AGENT_HANDLER
+            ))
+            .testPackers(List.of(Packers.JSP))
+            .probeShellTypes(List.of(
+                    ShellType.SERVLET,
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.HANDLER,
+                    ShellType.CUSTOMIZER
+            ))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warFile, "/var/lib/jetty/webapps/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(jettyPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/app"))
-            .withExposedPorts(8080);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.Jetty;
-        List<String> supportedShellTypes = List.of(
-                ShellType.SERVLET,
-                ShellType.FILTER,
-                ShellType.LISTENER,
-                ShellType.HANDLER,
-                ShellType.CUSTOMIZER,
-                ShellType.JETTY_AGENT_HANDLER
-        );
-        List<Packers> testPackers = List.of(Packers.JSP);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        log.info(logs);
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.Jetty, "7+", shellType, shellTool, Opcodes.V1_6, packer, container, python);
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.SERVLET,
-            ShellType.FILTER,
-            ShellType.LISTENER,
-            ShellType.HANDLER,
-            ShellType.CUSTOMIZER,})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.Jetty, "7+", shellType, Opcodes.V1_6);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/payara/Payara5201ContainerTest.java

@@ -1,93 +1,53 @@
 package com.reajason.javaweb.integration.memshell.payara;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.api.BeforeAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
 import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
-
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
 
 /**
  * @author ReaJason
  * @since 2024/12/12
  */
-@Slf4j
 @Testcontainers
-public class Payara5201ContainerTest {
-    public static final String imageName = "reajason/payara:5.201";
-    static Network network = Network.newNetwork();
+public class Payara5201ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig.glassFish(
+            "reajason/payara:5.201",
+            "/usr/local/payara5/glassfish/domains/domain1/autodeploy/app.war")
+            .targetJdkVersion(Opcodes.V1_6)
+            .waitStrategy(Wait.forLogMessage(".*JMXService.*", 1))
+            .supportedShellTypes(List.of(
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.VALVE,
+                    ShellType.AGENT_FILTER_CHAIN,
+                    ShellType.CATALINA_AGENT_CONTEXT_VALVE
+            ))
+            .testPackers(List.of(Packers.JSP))
+            .probeShellTypes(List.of(
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.VALVE
+            ))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public static final GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warFile, "/usr/local/payara5/glassfish/domains/domain1/autodeploy/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(glassfishPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forLogMessage(".*JMXService.*", 1))
-            .withExposedPorts(8080);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.GlassFish;
-        List<String> supportedShellTypes = List.of(
-                ShellType.FILTER,
-                ShellType.LISTENER,
-                ShellType.VALVE,
-                ShellType.AGENT_FILTER_CHAIN,
-                ShellType.CATALINA_AGENT_CONTEXT_VALVE
-        );
-        List<Packers> testPackers = List.of(Packers.JSP);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
-    }
-
-    @BeforeAll
-    static void setup() {
-        container.waitingFor(Wait.forHttp("/app"));
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        log.info(logs);
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.GlassFish, shellType, shellTool, Opcodes.V1_6, packer, container, python);
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.FILTER,
-            ShellType.LISTENER,
-            ShellType.VALVE,})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.GlassFish, shellType, Opcodes.V1_6);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/payara/Payara520225ContainerTest.java

@@ -1,93 +1,53 @@
 package com.reajason.javaweb.integration.memshell.payara;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.api.BeforeAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
 import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
-
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
 
 /**
  * @author ReaJason
  * @since 2024/12/12
  */
-@Slf4j
 @Testcontainers
-public class Payara520225ContainerTest {
-    public static final String imageName = "reajason/payara:5.2022.5";
-    static Network network = Network.newNetwork();
+public class Payara520225ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig.glassFish(
+            "reajason/payara:5.2022.5",
+            "/usr/local/payara5/glassfish/domains/domain1/autodeploy/app.war")
+            .targetJdkVersion(Opcodes.V1_6)
+            .waitStrategy(Wait.forLogMessage(".*JMXService.*", 1))
+            .supportedShellTypes(List.of(
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.VALVE,
+                    ShellType.AGENT_FILTER_CHAIN,
+                    ShellType.CATALINA_AGENT_CONTEXT_VALVE
+            ))
+            .testPackers(List.of(Packers.JSP))
+            .probeShellTypes(List.of(
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.VALVE
+            ))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public static final GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warFile, "/usr/local/payara5/glassfish/domains/domain1/autodeploy/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(glassfishPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forLogMessage(".*JMXService.*", 1))
-            .withExposedPorts(8080);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.GlassFish;
-        List<String> supportedShellTypes = List.of(
-                ShellType.FILTER,
-                ShellType.LISTENER,
-                ShellType.VALVE,
-                ShellType.AGENT_FILTER_CHAIN,
-                ShellType.CATALINA_AGENT_CONTEXT_VALVE
-        );
-        List<Packers> testPackers = List.of(Packers.JSP);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
-    }
-
-    @BeforeAll
-    static void setup() {
-        container.waitingFor(Wait.forHttp("/app"));
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        log.info(logs);
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.GlassFish, shellType, shellTool, Opcodes.V1_6, packer, container, python);
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.FILTER,
-            ShellType.LISTENER,
-            ShellType.VALVE,})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.GlassFish, shellType, Opcodes.V1_6);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/payara/Payara620222ContainerTest.java

@@ -1,92 +1,60 @@
 package com.reajason.javaweb.integration.memshell.payara;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellTool;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.api.BeforeAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
 import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
 
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
+import static com.reajason.javaweb.integration.ContainerTool.warJakartaFile;
 
 /**
  * @author ReaJason
  * @since 2024/12/12
  */
-@Slf4j
 @Testcontainers
-public class Payara620222ContainerTest {
-    public static final String imageName = "reajason/payara:6.2022.2-jdk11";
-    static Network network = Network.newNetwork();
+public class Payara620222ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig.glassFish(
+            "reajason/payara:6.2022.2-jdk11",
+            "/usr/local/payara6/glassfish/domains/domain1/autodeploy/app.war")
+            .warFile(warJakartaFile)
+            .jakarta(true)
+            .targetJdkVersion(Opcodes.V11)
+            .waitStrategy(Wait.forLogMessage(".*JMXService.*", 1))
+            .assertLogs(false)
+            .supportedShellTypes(List.of(
+                    ShellType.JAKARTA_FILTER,
+                    ShellType.JAKARTA_LISTENER,
+                    ShellType.JAKARTA_VALVE,
+                    ShellType.AGENT_FILTER_CHAIN,
+                    ShellType.CATALINA_AGENT_CONTEXT_VALVE
+            ))
+            .testPackers(List.of(Packers.JSP))
+            .unSupportedShellTools(List.of(ShellTool.AntSword))
+            .probeShellTypes(List.of(
+                    ShellType.JAKARTA_FILTER,
+                    ShellType.JAKARTA_LISTENER,
+                    ShellType.JAKARTA_VALVE
+            ))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public static final GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warJakartaFile, "/usr/local/payara6/glassfish/domains/domain1/autodeploy/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(glassfishPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forLogMessage(".*JMXService.*", 1))
-            .withExposedPorts(8080);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.GlassFish;
-        List<String> supportedShellTypes = List.of(
-                ShellType.JAKARTA_FILTER,
-                ShellType.JAKARTA_LISTENER,
-                ShellType.JAKARTA_VALVE,
-                ShellType.AGENT_FILTER_CHAIN,
-                ShellType.CATALINA_AGENT_CONTEXT_VALVE
-        );
-        List<Packers> testPackers = List.of(Packers.JSP);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers, null, List.of(ShellTool.AntSword));
-    }
-
-    @BeforeAll
-    static void setup() {
-        container.waitingFor(Wait.forHttp("/app/test"));
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        log.info(logs);
-//        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.GlassFish, shellType, shellTool, Opcodes.V11, packer, container, python);
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.JAKARTA_FILTER,
-            ShellType.JAKARTA_LISTENER,
-            ShellType.JAKARTA_VALVE,})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.GlassFish, shellType, Opcodes.V11);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/resin/Resin3116ContainerTest.java

@@ -1,87 +1,49 @@
 package com.reajason.javaweb.integration.memshell.resin;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.SneakyThrows;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
-
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
 
 /**
  * @author ReaJason
  * @since 2024/12/4
  */
-@Slf4j
 @Testcontainers
-public class Resin3116ContainerTest {
-    public static final String imageName = "reajason/resin:3.1.16";
-    static Network network = Network.newNetwork();
+public class Resin3116ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig.resin(
+            "reajason/resin:3.1.16",
+            "/usr/local/resin3/webapps/app.war")
+            .targetJdkVersion(Opcodes.V1_6)
+            .logDelayMillis(1000L)
+            .supportedShellTypes(List.of(
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.AGENT_FILTER_CHAIN
+            ))
+            .testPackers(List.of(Packers.JSP))
+            .probeShellTypes(List.of(
+                    ShellType.FILTER,
+                    ShellType.LISTENER
+            ))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warFile, "/usr/local/resin3/webapps/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(resinPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/app"))
-            .withExposedPorts(8080);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.Resin;
-        List<String> supportedShellTypes = List.of(
-                ShellType.FILTER,
-                ShellType.LISTENER,
-                ShellType.AGENT_FILTER_CHAIN
-        );
-        List<Packers> testPackers = List.of(Packers.JSP);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
-
-    @AfterAll
-    @SneakyThrows
-    static void tearDown() {
-        Thread.sleep(1000);
-        String logs = container.getLogs();
-        log.info(logs);
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.Resin, shellType, shellTool, Opcodes.V1_6, packer, container, python);
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.FILTER,
-            ShellType.LISTENER,})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.Resin, shellType, Opcodes.V1_6);
-    }
-}
+}

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/resin/Resin318ContainerTest.java

@@ -1,84 +1,48 @@
 package com.reajason.javaweb.integration.memshell.resin;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
-
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
 
 /**
  * @author ReaJason
  * @since 2024/12/4
  */
-@Slf4j
 @Testcontainers
-public class Resin318ContainerTest {
-    public static final String imageName = "reajason/resin:3.1.8-jdk7";
-    static Network network = Network.newNetwork();
+public class Resin318ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig.resin(
+            "reajason/resin:3.1.8-jdk7",
+            "/usr/local/resin3/webapps/app.war")
+            .targetJdkVersion(Opcodes.V1_6)
+            .supportedShellTypes(List.of(
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.AGENT_FILTER_CHAIN
+            ))
+            .testPackers(List.of(Packers.JSP))
+            .probeShellTypes(List.of(
+                    ShellType.FILTER,
+                    ShellType.LISTENER
+            ))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warFile, "/usr/local/resin3/webapps/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(resinPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/app"))
-            .withExposedPorts(8080);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.Resin;
-        List<String> supportedShellTypes = List.of(
-                ShellType.FILTER,
-                ShellType.LISTENER,
-                ShellType.AGENT_FILTER_CHAIN
-        );
-        List<Packers> testPackers = List.of(Packers.JSP);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        log.info(logs);
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.Resin, shellType, shellTool, Opcodes.V1_6, packer, container, python);
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.FILTER,
-            ShellType.LISTENER,})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.Resin, shellType, Opcodes.V1_6);
-    }
-}
+}

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/resin/Resin4058ContainerTest.java

@@ -1,84 +1,48 @@
 package com.reajason.javaweb.integration.memshell.resin;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
-
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
 
 /**
  * @author ReaJason
  * @since 2024/12/4
  */
-@Slf4j
 @Testcontainers
-public class Resin4058ContainerTest {
-    public static final String imageName = "reajason/resin:4.0.58";
-    static Network network = Network.newNetwork();
+public class Resin4058ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig.resin(
+            "reajason/resin:4.0.58",
+            "/usr/local/resin4/webapps/app.war")
+            .targetJdkVersion(Opcodes.V1_6)
+            .supportedShellTypes(List.of(
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.AGENT_FILTER_CHAIN
+            ))
+            .testPackers(List.of(Packers.JSP))
+            .probeShellTypes(List.of(
+                    ShellType.FILTER,
+                    ShellType.LISTENER
+            ))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warFile, "/usr/local/resin4/webapps/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(resinPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/app"))
-            .withExposedPorts(8080);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.Resin;
-        List<String> supportedShellTypes = List.of(
-                ShellType.FILTER,
-                ShellType.LISTENER,
-                ShellType.AGENT_FILTER_CHAIN
-        );
-        List<Packers> testPackers = List.of(Packers.JSP);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        log.info(logs);
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.Resin, shellType, shellTool, Opcodes.V1_6, packer, container, python);
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.FILTER,
-            ShellType.LISTENER,})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.Resin, shellType, Opcodes.V1_6);
-    }
-}
+}

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/resin/Resin4067ContainerTest.java

@@ -1,84 +1,49 @@
 package com.reajason.javaweb.integration.memshell.resin;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
-
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
 
 /**
  * @author ReaJason
  * @since 2024/12/4
  */
-@Slf4j
 @Testcontainers
-public class Resin4067ContainerTest {
-    public static final String imageName = "reajason/resin:4.0.67-jdk11";
-    static Network network = Network.newNetwork();
+public class Resin4067ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig.resin(
+            "reajason/resin:4.0.67-jdk11",
+            "/usr/local/resin4/webapps/app.war")
+            .targetJdkVersion(Opcodes.V11)
+            .probeTargetJdkVersion(Opcodes.V1_6)
+            .supportedShellTypes(List.of(
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.AGENT_FILTER_CHAIN
+            ))
+            .testPackers(List.of(Packers.JSP))
+            .probeShellTypes(List.of(
+                    ShellType.FILTER,
+                    ShellType.LISTENER
+            ))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warFile, "/usr/local/resin4/webapps/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(resinPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/app"))
-            .withExposedPorts(8080);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.Resin;
-        List<String> supportedShellTypes = List.of(
-                ShellType.FILTER,
-                ShellType.LISTENER,
-                ShellType.AGENT_FILTER_CHAIN
-        );
-        List<Packers> testPackers = List.of(Packers.JSP);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        log.info(logs);
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.Resin, shellType, shellTool, Opcodes.V11, packer, container, python);
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.FILTER,
-            ShellType.LISTENER,})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.Resin, shellType, Opcodes.V1_6);
-    }
-}
+}

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/springwebflux/SpringBoot2WebFluxContainerTest.java

@@ -1,78 +1,54 @@
 package com.reajason.javaweb.integration.memshell.springwebflux;
 
 import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
+import com.reajason.javaweb.integration.ContainerTool;
+import com.reajason.javaweb.integration.VulTool;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
-
-import static com.reajason.javaweb.integration.ContainerTool.neoGeorgDockerfile;
-import static com.reajason.javaweb.integration.ContainerTool.springBoot2WebfluxDockerfile;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
 
 /**
  * @author ReaJason
  * @since 2024/12/22
  */
 @Testcontainers
-@Slf4j
-public class SpringBoot2WebFluxContainerTest {
-    public static final String imageName = "springboot2-webflux";
+public class SpringBoot2WebFluxContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig.builder()
+            .imageName("eclipse-temurin:8u472-b08-jdk")
+            .jarFile(ContainerTool.springBoot2WebfluxJarFile)
+            .jarDeployPath("/app/app.jar")
+            .command("java -jar /app/app.jar")
+            .server(Server.SpringWebFlux)
+            .targetJdkVersion(Opcodes.V1_8)
+            .enableJspPackerTest(false)
+            .contextPath("")
+            .healthCheckPath("/test")
+            .jattachFile(null)
+            .supportedShellTypes(List.of(
+                    ShellType.SPRING_WEBFLUX_WEB_FILTER,
+                    ShellType.SPRING_WEBFLUX_HANDLER_METHOD,
+                    ShellType.NETTY_HANDLER
+            ))
+            .testPackers(List.of(Packers.Base64))
+            .build();
 
-    static Network network = Network.newNetwork();
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public final static GenericContainer<?> container = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(springBoot2WebfluxDockerfile))
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/test"))
-            .withExposedPorts(8080);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.SpringWebFlux;
-        List<String> supportedShellTypes = List.of(ShellType.SPRING_WEBFLUX_WEB_FILTER, ShellType.SPRING_WEBFLUX_HANDLER_METHOD, ShellType.NETTY_HANDLER);
-        List<Packers> testPackers = List.of(Packers.Base64);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        log.info("container stopped, logs is : {}", logs);
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.SpringWebFlux, shellType, shellTool, Opcodes.V1_8, packer, container, python);
-    }
-
-    public static String getUrl(GenericContainer<?> container) {
-        String host = container.getHost();
-        int port = container.getMappedPort(8080);
-        String url = "http://" + host + ":" + port;
-        log.info("container started, app url is : {}", url);
-        return url;
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/springwebflux/SpringBoot3WebFluxContainerTest.java

@@ -1,76 +1,53 @@
 package com.reajason.javaweb.integration.memshell.springwebflux;
 
 import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
+import com.reajason.javaweb.integration.ContainerTool;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
-
-import static com.reajason.javaweb.integration.ContainerTool.neoGeorgDockerfile;
-import static com.reajason.javaweb.integration.ContainerTool.springBoot3WebfluxDockerfile;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
 
 /**
  * @author ReaJason
  * @since 2024/12/22
  */
 @Testcontainers
-@Slf4j
-public class SpringBoot3WebFluxContainerTest {
-    public static final String imageName = "springboot3-webflux";
-    static Network network = Network.newNetwork();
+public class SpringBoot3WebFluxContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig.builder()
+            .imageName("eclipse-temurin:17.0.17_10-jdk")
+            .jarFile(ContainerTool.springBoot3WebfluxJarFile)
+            .jarDeployPath("/app/app.jar")
+            .command("java -jar /app/app.jar")
+            .server(Server.SpringWebFlux)
+            .targetJdkVersion(Opcodes.V17)
+            .enableJspPackerTest(false)
+            .contextPath("")
+            .healthCheckPath("/test")
+            .jattachFile(null)
+            .supportedShellTypes(List.of(
+                    ShellType.SPRING_WEBFLUX_WEB_FILTER,
+                    ShellType.SPRING_WEBFLUX_HANDLER_METHOD,
+                    ShellType.NETTY_HANDLER
+            ))
+            .testPackers(List.of(Packers.Base64))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public final static GenericContainer<?> container = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(springBoot3WebfluxDockerfile))
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/test"))
-            .withExposedPorts(8080);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.SpringWebFlux;
-        List<String> supportedShellTypes = List.of(ShellType.SPRING_WEBFLUX_WEB_FILTER, ShellType.SPRING_WEBFLUX_HANDLER_METHOD, ShellType.NETTY_HANDLER);
-        List<Packers> testPackers = List.of(Packers.Base64);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.SpringWebFlux, shellType, shellTool, Opcodes.V17, packer, container, python);
-    }
-
-    public static String getUrl(GenericContainer<?> container) {
-        String host = container.getHost();
-        int port = container.getMappedPort(8080);
-        String url = "http://" + host + ":" + port;
-        log.info("container started, app url is : {}", url);
-        return url;
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/springwebmvc/SpringBoot1ContainerTest.java

@@ -1,92 +1,58 @@
 package com.reajason.javaweb.integration.memshell.springwebmvc;
 
 import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
+import com.reajason.javaweb.integration.ContainerTool;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
-
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
 
 /**
  * @author ReaJason
  * @since 2024/12/22
  */
 @Testcontainers
-@Slf4j
-public class SpringBoot1ContainerTest {
-    public static final String imageName = "springboot1";
-    static Network network = Network.newNetwork();
+public class SpringBoot1ContainerTest extends AbstractContainerTest {
+
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig.builder()
+            .imageName("eclipse-temurin:8u472-b08-jdk")
+            .jarFile(ContainerTool.springBoot1JarFile)
+            .jarDeployPath("/app/app.jar")
+            .command("java -jar /app/app.jar")
+            .server(Server.SpringWebMvc)
+            .pidScript(ContainerTool.springbootPid)
+            .targetJdkVersion(Opcodes.V1_8)
+            .enableJspPackerTest(false)
+            .contextPath("")
+            .healthCheckPath("/test")
+            .supportedShellTypes(List.of(
+                    ShellType.SPRING_WEBMVC_INTERCEPTOR,
+                    ShellType.SPRING_WEBMVC_CONTROLLER_HANDLER,
+                    ShellType.SPRING_WEBMVC_AGENT_FRAMEWORK_SERVLET
+            ))
+            .testPackers(List.of(Packers.SpEL))
+            .probeShellTypes(List.of(
+                    ShellType.SPRING_WEBMVC_INTERCEPTOR,
+                    ShellType.SPRING_WEBMVC_CONTROLLER_HANDLER
+            ))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public final static GenericContainer<?> container = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(springBoot1Dockerfile))
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(springbootPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/test"))
-            .withExposedPorts(8080);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.SpringWebMvc;
-        List<String> supportedShellTypes = List.of(
-                ShellType.SPRING_WEBMVC_INTERCEPTOR,
-                ShellType.SPRING_WEBMVC_CONTROLLER_HANDLER,
-                ShellType.SPRING_WEBMVC_AGENT_FRAMEWORK_SERVLET
-        );
-        List<Packers> testPackers = List.of(Packers.SpEL);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        log.info(logs);
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.SpringWebMvc, shellType, shellTool, Opcodes.V1_8, packer, container, python);
-    }
-
-    public static String getUrl(GenericContainer<?> container) {
-        String host = container.getHost();
-        int port = container.getMappedPort(8080);
-        String url = "http://" + host + ":" + port;
-        log.info("container started, app url is : {}", url);
-        return url;
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.SPRING_WEBMVC_INTERCEPTOR,
-            ShellType.SPRING_WEBMVC_CONTROLLER_HANDLER,})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.SpringWebMvc, shellType, Opcodes.V1_8);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/springwebmvc/SpringBoot2ContainerTest.java

@@ -1,114 +1,85 @@
 package com.reajason.javaweb.integration.memshell.springwebmvc;
 
 import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
+import com.reajason.javaweb.integration.ContainerTool;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
 import java.util.stream.Stream;
 
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
-
 /**
  * @author ReaJason
  * @since 2024/12/22
  */
 @Testcontainers
-@Slf4j
-public class SpringBoot2ContainerTest {
-    public static final String imageName = "springboot2";
+public class SpringBoot2ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig.builder()
+            .imageName("eclipse-temurin:8u472-b08-jdk")
+            .jarFile(ContainerTool.springBoot2JarFile)
+            .jarDeployPath("/app/app.jar")
+            .command("java -jar /app/app.jar")
+            .server(Server.SpringWebMvc)
+            .pidScript(ContainerTool.javaPid)
+            .enableJspPackerTest(false)
+            .targetJdkVersion(Opcodes.V1_8)
+            .contextPath("")
+            .healthCheckPath("/test")
+            .supportedShellTypes(List.of(
+                    ShellType.SPRING_WEBMVC_INTERCEPTOR,
+                    ShellType.SPRING_WEBMVC_CONTROLLER_HANDLER,
+                    ShellType.SPRING_WEBMVC_AGENT_FRAMEWORK_SERVLET
+            ))
+            .testPackers(List.of(Packers.H2JS))
+            .probeShellTypes(List.of(
+                    ShellType.SPRING_WEBMVC_INTERCEPTOR,
+                    ShellType.SPRING_WEBMVC_CONTROLLER_HANDLER
+            ))
+            .build();
 
-    static Network network = Network.newNetwork();
+    private static final ContainerTestConfig TOMCAT_CONFIG = ContainerTestConfig.builder()
+            .imageName("springboot-2")
+            .server(Server.Tomcat)
+            .targetJdkVersion(Opcodes.V1_8)
+            .supportedShellTypes(List.of(
+                    ShellType.FILTER,
+                    ShellType.VALVE,
+                    ShellType.WEBSOCKET,
+                    ShellType.AGENT_FILTER_CHAIN,
+                    ShellType.CATALINA_AGENT_CONTEXT_VALVE
+            ))
+            .testPackers(List.of(Packers.H2JS))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
 
     @Container
-    public final static GenericContainer<?> container = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(springBoot2Dockerfile))
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(javaPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/test"))
-            .withExposedPorts(8080);
-
-    static Stream<Arguments> casesProvider() {
-        String server = Server.SpringWebMvc;
-        List<String> supportedShellTypes = List.of(
-                ShellType.SPRING_WEBMVC_INTERCEPTOR,
-                ShellType.SPRING_WEBMVC_CONTROLLER_HANDLER,
-                ShellType.SPRING_WEBMVC_AGENT_FRAMEWORK_SERVLET
-        );
-        List<Packers> testPackers = List.of(Packers.H2JS);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        log.info(logs);
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.SpringWebMvc, shellType, shellTool, Opcodes.V1_8, packer, container, python);
-    }
-
-    public static String getUrl(GenericContainer<?> container) {
-        String host = container.getHost();
-        int port = container.getMappedPort(8080);
-        String url = "http://" + host + ":" + port;
-        log.info("container started, app url is : {}", url);
-        return url;
-    }
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
     static Stream<Arguments> tomcatCasesProvider() {
-        String server = Server.Tomcat;
-        List<String> supportedShellTypes = List.of(
-                ShellType.FILTER,
-//                ShellType.LISTENER,
-                ShellType.VALVE,
-                ShellType.WEBSOCKET,
-                ShellType.AGENT_FILTER_CHAIN,
-                ShellType.CATALINA_AGENT_CONTEXT_VALVE
-        );
-        List<Packers> testPackers = List.of(Packers.H2JS);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
+        return generateTestCases(TOMCAT_CONFIG);
     }
 
     @ParameterizedTest(name = "{0}|{1}{2}|{3}")
     @MethodSource("tomcatCasesProvider")
     void testTomcat(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.Tomcat, shellType, shellTool, Opcodes.V1_8, packer, container, python);
+        runShellInject(TOMCAT_CONFIG, shellType, shellTool, packer);
     }
 
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.SPRING_WEBMVC_INTERCEPTOR,
-            ShellType.SPRING_WEBMVC_CONTROLLER_HANDLER,})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.SpringWebMvc, shellType, Opcodes.V1_8);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/springwebmvc/SpringBoot2JettyContainerTest.java

@@ -1,104 +1,82 @@
 package com.reajason.javaweb.integration.memshell.springwebmvc;
 
 import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
+import com.reajason.javaweb.integration.ContainerTool;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
 import java.util.stream.Stream;
 
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
-
 /**
  * @author ReaJason
  * @since 2024/12/22
  */
 @Testcontainers
-@Slf4j
-public class SpringBoot2JettyContainerTest {
-    public static final String imageName = "springboot2-jetty";
+public class SpringBoot2JettyContainerTest extends AbstractContainerTest {
 
-    static Network network = Network.newNetwork();
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig.builder()
+            .imageName("eclipse-temurin:8u472-b08-jdk")
+            .jarFile(ContainerTool.springBoot2JettyJarFile)
+            .jarDeployPath("/app/app.jar")
+            .command("java -jar /app/app.jar")
+            .server(Server.SpringWebMvc)
+            .pidScript(ContainerTool.springbootPid)
+            .enableJspPackerTest(false)
+            .targetJdkVersion(Opcodes.V1_8)
+            .contextPath("")
+            .healthCheckPath("/test")
+            .supportedShellTypes(List.of(
+                    ShellType.SPRING_WEBMVC_INTERCEPTOR,
+                    ShellType.SPRING_WEBMVC_CONTROLLER_HANDLER,
+                    ShellType.SPRING_WEBMVC_AGENT_FRAMEWORK_SERVLET
+            ))
+            .testPackers(List.of(Packers.SpEL))
+            .build();
+
+    private static final ContainerTestConfig JETTY_CONFIG = ContainerTestConfig.builder()
+            .imageName("springboot2-jetty")
+            .server(Server.Jetty)
+            .serverVersion("7+")
+            .targetJdkVersion(Opcodes.V1_8)
+            .supportedShellTypes(List.of(
+                    ShellType.SERVLET,
+                    ShellType.FILTER,
+                    ShellType.HANDLER,
+                    ShellType.CUSTOMIZER,
+                    ShellType.JETTY_AGENT_HANDLER
+            ))
+            .testPackers(List.of(Packers.SpEL))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
 
     @Container
-    public final static GenericContainer<?> container = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(springBoot2JettyDockerfile))
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(springbootPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/test"))
-            .withExposedPorts(8080);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.SpringWebMvc;
-        List<String> supportedShellTypes = List.of(
-                ShellType.SPRING_WEBMVC_INTERCEPTOR,
-                ShellType.SPRING_WEBMVC_CONTROLLER_HANDLER,
-                ShellType.SPRING_WEBMVC_AGENT_FRAMEWORK_SERVLET
-        );
-        List<Packers> testPackers = List.of(Packers.ScriptEngine, Packers.SpEL, Packers.Base64);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        log.info(logs);
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.SpringWebMvc, shellType, shellTool, Opcodes.V1_8, packer, container, python);
-    }
-
-    public static String getUrl(GenericContainer<?> container) {
-        String host = container.getHost();
-        int port = container.getMappedPort(8080);
-        String url = "http://" + host + ":" + port;
-        log.info("container started, app url is : {}", url);
-        return url;
-    }
-
-    static Stream<Arguments> jettyCasesProvider() {
-        String server = Server.Jetty;
-        List<String> supportedShellTypes = List.of(
-                ShellType.SERVLET,
-                ShellType.FILTER,
-                ShellType.HANDLER,
-                ShellType.CUSTOMIZER,
-//                ShellType.LISTENER,
-                ShellType.JETTY_AGENT_HANDLER
-        );
-        List<Packers> testPackers = List.of(Packers.SpEL);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
+    static Stream<org.junit.jupiter.params.provider.Arguments> jettyCasesProvider() {
+        return generateTestCases(JETTY_CONFIG);
     }
 
     @ParameterizedTest(name = "{0}|{1}{2}|{3}")
     @MethodSource("jettyCasesProvider")
     void testJetty(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.Jetty, "7+", shellType, shellTool, Opcodes.V1_8, packer, container, python);
+        runShellInject(JETTY_CONFIG, shellType, shellTool, packer);
+    }
+
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/springwebmvc/SpringBoot2UndertowContainerTest.java

@@ -1,102 +1,78 @@
 package com.reajason.javaweb.integration.memshell.springwebmvc;
 
 import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
+import com.reajason.javaweb.integration.ContainerTool;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
 import java.util.stream.Stream;
 
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
-
 /**
  * @author ReaJason
  * @since 2024/12/22
  */
 @Testcontainers
-@Slf4j
-public class SpringBoot2UndertowContainerTest {
-    public static final String imageName = "springboot2-undertow";
+public class SpringBoot2UndertowContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig.builder()
+            .imageName("eclipse-temurin:8u472-b08-jdk")
+            .jarFile(ContainerTool.springBoot2UndertowJarFile)
+            .jarDeployPath("/app/app.jar")
+            .command("java -jar /app/app.jar")
+            .server(Server.SpringWebMvc)
+            .pidScript(ContainerTool.springbootPid)
+            .enableJspPackerTest(false)
+            .targetJdkVersion(Opcodes.V1_8)
+            .contextPath("")
+            .healthCheckPath("/test")
+            .supportedShellTypes(List.of(
+                    ShellType.SPRING_WEBMVC_INTERCEPTOR,
+                    ShellType.SPRING_WEBMVC_CONTROLLER_HANDLER,
+                    ShellType.SPRING_WEBMVC_AGENT_FRAMEWORK_SERVLET
+            ))
+            .testPackers(List.of(Packers.ScriptEngine, Packers.SpEL, Packers.Base64))
+            .build();
 
-    static Network network = Network.newNetwork();
+    private static final ContainerTestConfig UNDERTOW_CONFIG = ContainerTestConfig.builder()
+            .imageName("springboot2-undertow")
+            .server(Server.Undertow)
+            .targetJdkVersion(Opcodes.V1_8)
+            .supportedShellTypes(List.of(
+                    ShellType.SERVLET,
+                    ShellType.FILTER,
+                    ShellType.UNDERTOW_AGENT_SERVLET_HANDLER
+            ))
+            .testPackers(List.of(Packers.SpEL))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
 
     @Container
-    public final static GenericContainer<?> container = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(springBoot2UndertowDockerfile))
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(springbootPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/test"))
-            .withExposedPorts(8080);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.SpringWebMvc;
-        List<String> supportedShellTypes = List.of(
-                ShellType.SPRING_WEBMVC_INTERCEPTOR,
-                ShellType.SPRING_WEBMVC_CONTROLLER_HANDLER,
-                ShellType.SPRING_WEBMVC_AGENT_FRAMEWORK_SERVLET
-        );
-        List<Packers> testPackers = List.of(Packers.ScriptEngine, Packers.SpEL, Packers.Base64);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        log.info(logs);
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.SpringWebMvc, shellType, shellTool, Opcodes.V1_8, packer, container, python);
-    }
-
-    public static String getUrl(GenericContainer<?> container) {
-        String host = container.getHost();
-        int port = container.getMappedPort(8080);
-        String url = "http://" + host + ":" + port;
-        log.info("container started, app url is : {}", url);
-        return url;
-    }
-
-    static Stream<Arguments> undertowCasesProvider() {
-        String server = Server.Undertow;
-        List<String> supportedShellTypes = List.of(
-                ShellType.SERVLET,
-                ShellType.FILTER,
-//                ShellType.LISTENER,
-                ShellType.UNDERTOW_AGENT_SERVLET_HANDLER
-        );
-        List<Packers> testPackers = List.of(Packers.SpEL);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
+    static Stream<org.junit.jupiter.params.provider.Arguments> undertowCasesProvider() {
+        return generateTestCases(UNDERTOW_CONFIG);
     }
 
     @ParameterizedTest(name = "{0}|{1}{2}|{3}")
     @MethodSource("undertowCasesProvider")
-    void testJetty(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.Undertow, shellType, shellTool, Opcodes.V1_8, packer, container, python);
+    void testUndertow(String imageName, String shellType, String shellTool, Packers packer) {
+        runShellInject(UNDERTOW_CONFIG, shellType, shellTool, packer);
+    }
+
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/springwebmvc/SpringBoot2WarContainerTest.java

@@ -1,93 +1,79 @@
 package com.reajason.javaweb.integration.memshell.springwebmvc;
 
 import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
+import com.reajason.javaweb.integration.ContainerTool;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
 import java.util.stream.Stream;
 
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
-
 /**
  * @author ReaJason
  * @since 2024/12/22
  */
 @Testcontainers
-@Slf4j
-public class SpringBoot2WarContainerTest {
+public class SpringBoot2WarContainerTest extends AbstractContainerTest {
     public static final String imageName = "tomcat:8-jre8";
-    static Network network = Network.newNetwork();
+
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig.builder()
+            .imageName(imageName)
+            .server(Server.SpringWebMvc)
+            .warFile(ContainerTool.springBoot2WarFile)
+            .warDeployPath("/usr/local/tomcat/webapps/app.war")
+            .pidScript(ContainerTool.tomcatPid)
+            .enableJspPackerTest(false)
+            .targetJdkVersion(Opcodes.V1_8)
+            .supportedShellTypes(List.of(
+                    ShellType.SPRING_WEBMVC_INTERCEPTOR,
+                    ShellType.SPRING_WEBMVC_CONTROLLER_HANDLER
+            ))
+            .testPackers(List.of(Packers.SpEL))
+            .build();
+
+    private static final ContainerTestConfig TOMCAT_CONFIG = ContainerTestConfig.builder()
+            .imageName(imageName)
+            .server(Server.Tomcat)
+            .targetJdkVersion(Opcodes.V1_8)
+            .supportedShellTypes(List.of(
+                    ShellType.FILTER,
+                    ShellType.VALVE,
+                    ShellType.WEBSOCKET,
+                    ShellType.AGENT_FILTER_CHAIN,
+                    ShellType.CATALINA_AGENT_CONTEXT_VALVE
+            ))
+            .testPackers(List.of(Packers.SpEL))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(springBoot2WarFile, "/usr/local/tomcat/webapps/app.war")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(tomcatPid, "/fetch_pid.sh")
-            .waitingFor(Wait.forHttp("/app"))
-            .withExposedPorts(8080);
-
-    static Stream<Arguments> casesProvider() {
-        String server = Server.SpringWebMvc;
-        List<String> supportedShellTypes = List.of(
-                ShellType.SPRING_WEBMVC_INTERCEPTOR,
-                ShellType.SPRING_WEBMVC_CONTROLLER_HANDLER
-//                ShellType.SPRING_WEBMVC_AGENT_FRAMEWORK_SERVLET // TODO: 这个地方会报奇怪的错误，需要排查
-        );
-        List<Packers> testPackers = List.of(Packers.ScriptEngine, Packers.SpEL, Packers.Base64);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.SpringWebMvc, shellType, shellTool, Opcodes.V1_8, packer, container, python);
-    }
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
     static Stream<Arguments> tomcatCasesProvider() {
-        String server = Server.Tomcat;
-        List<String> supportedShellTypes = List.of(
-                ShellType.FILTER,
-//                ShellType.LISTENER,
-                ShellType.VALVE,
-                ShellType.WEBSOCKET,
-                ShellType.AGENT_FILTER_CHAIN,
-                ShellType.CATALINA_AGENT_CONTEXT_VALVE
-        );
-        List<Packers> testPackers = List.of(Packers.SpEL);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
+        return generateTestCases(TOMCAT_CONFIG);
     }
 
     @ParameterizedTest(name = "{0}|{1}{2}|{3}")
     @MethodSource("tomcatCasesProvider")
     void testTomcat(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.Tomcat, shellType, shellTool, Opcodes.V1_8, packer, container, python);
+        runShellInject(TOMCAT_CONFIG, shellType, shellTool, packer);
+    }
+
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/springwebmvc/SpringBoot3ContainerTest.java

@@ -1,114 +1,90 @@
 package com.reajason.javaweb.integration.memshell.springwebmvc;
 
 import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
+import com.reajason.javaweb.integration.ContainerTool;
 import com.reajason.javaweb.memshell.ShellTool;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
 import java.util.stream.Stream;
 
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
-
 /**
  * @author ReaJason
  * @since 2024/12/22
  */
 @Testcontainers
-@Slf4j
-public class SpringBoot3ContainerTest {
-    public static final String imageName = "springboot3";
-    static Network network = Network.newNetwork();
+public class SpringBoot3ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig.builder()
+            .imageName("eclipse-temurin:17.0.17_10-jdk")
+            .jarFile(ContainerTool.springBoot3JarFile)
+            .jakarta(true)
+            .jarDeployPath("/app/app.jar")
+            .command("java -jar /app/app.jar")
+            .server(Server.SpringWebMvc)
+            .pidScript(ContainerTool.springbootPid)
+            .targetJdkVersion(Opcodes.V17)
+            .enableJspPackerTest(false)
+            .contextPath("")
+            .healthCheckPath("/test")
+            .supportedShellTypes(List.of(
+                    ShellType.SPRING_WEBMVC_JAKARTA_INTERCEPTOR,
+                    ShellType.SPRING_WEBMVC_JAKARTA_CONTROLLER_HANDLER,
+                    ShellType.SPRING_WEBMVC_AGENT_FRAMEWORK_SERVLET
+            ))
+            .testPackers(List.of(Packers.H2))
+            .unSupportedShellTools(List.of(ShellTool.AntSword))
+            .probeShellTypes(List.of(
+                    ShellType.SPRING_WEBMVC_JAKARTA_INTERCEPTOR,
+                    ShellType.SPRING_WEBMVC_JAKARTA_CONTROLLER_HANDLER
+            ))
+            .build();
+
+    private static final ContainerTestConfig TOMCAT_CONFIG = ContainerTestConfig.builder()
+            .imageName("springboot3")
+            .server(Server.Tomcat)
+            .targetJdkVersion(Opcodes.V17)
+            .supportedShellTypes(List.of(
+                    ShellType.JAKARTA_FILTER,
+//                ShellType.LISTENER,
+                    ShellType.JAKARTA_VALVE,
+                    ShellType.JAKARTA_WEBSOCKET,
+                    ShellType.AGENT_FILTER_CHAIN,
+                    ShellType.CATALINA_AGENT_CONTEXT_VALVE
+            ))
+            .testPackers(List.of(Packers.H2))
+            .unSupportedShellTools(List.of(ShellTool.AntSword))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public final static GenericContainer<?> container = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(springBoot3Dockerfile))
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(springbootPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/test"))
-            .withExposedPorts(8080);
-
-    static Stream<Arguments> casesProvider() {
-        String server = Server.SpringWebMvc;
-        List<String> supportedShellTypes = List.of(
-                ShellType.SPRING_WEBMVC_JAKARTA_INTERCEPTOR,
-                ShellType.SPRING_WEBMVC_JAKARTA_CONTROLLER_HANDLER,
-                ShellType.SPRING_WEBMVC_AGENT_FRAMEWORK_SERVLET
-        );
-        List<Packers> testPackers = List.of(Packers.H2);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers, null, List.of(ShellTool.AntSword));
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        log.info(logs);
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.SpringWebMvc, shellType, shellTool, Opcodes.V17, packer, container, python);
-    }
-
-    public static String getUrl(GenericContainer<?> container) {
-        String host = container.getHost();
-        int port = container.getMappedPort(8080);
-        String url = "http://" + host + ":" + port;
-        log.info("container started, app url is : {}", url);
-        return url;
-    }
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
     static Stream<Arguments> tomcatCasesProvider() {
-        String server = Server.Tomcat;
-        List<String> supportedShellTypes = List.of(
-                ShellType.JAKARTA_FILTER,
-//                ShellType.LISTENER,
-                ShellType.JAKARTA_VALVE,
-                ShellType.JAKARTA_WEBSOCKET,
-                ShellType.AGENT_FILTER_CHAIN,
-                ShellType.CATALINA_AGENT_CONTEXT_VALVE
-        );
-        List<Packers> testPackers = List.of(Packers.H2);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers, null, List.of(ShellTool.AntSword));
+        return generateTestCases(TOMCAT_CONFIG);
     }
 
     @ParameterizedTest(name = "{0}|{1}{2}|{3}")
     @MethodSource("tomcatCasesProvider")
     void testTomcat(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.Tomcat, shellType, shellTool, Opcodes.V17, packer, container, python);
+        runShellInject(TOMCAT_CONFIG, shellType, shellTool, packer);
     }
 
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.SPRING_WEBMVC_JAKARTA_INTERCEPTOR,
-            ShellType.SPRING_WEBMVC_JAKARTA_CONTROLLER_HANDLER,})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.SpringWebMvc, shellType, Opcodes.V17);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/springwebmvc/SpringBoot3ExpressionContainerTest.java

@@ -1,6 +1,7 @@
 package com.reajason.javaweb.integration.memshell.springwebmvc;
 
 import com.reajason.javaweb.Server;
+import com.reajason.javaweb.integration.ContainerTool;
 import com.reajason.javaweb.integration.ShellAssertion;
 import com.reajason.javaweb.memshell.ShellTool;
 import com.reajason.javaweb.memshell.ShellType;
@@ -32,8 +33,9 @@ public class SpringBoot3ExpressionContainerTest {
     public static final String imageName = "springboot3";
 
     @Container
-    public final static GenericContainer<?> container = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(springBoot3Dockerfile))
+    public final static GenericContainer<?> container = new GenericContainer<>("eclipse-temurin:17.0.17_10-jdk")
+            .withCopyFileToContainer(springBoot3JarFile, "/app/app.jar")
+            .withCommand("java -jar /app/app.jar")
             .withCopyToContainer(jattachFile, "/jattach")
             .withCopyToContainer(springbootPid, "/fetch_pid.sh")
             .waitingFor(Wait.forHttp("/test"))

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/struct2/Struct2ContainerTest.java

@@ -1,81 +1,47 @@
 package com.reajason.javaweb.integration.memshell.struct2;
 
 import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
+import com.reajason.javaweb.integration.ContainerTool;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
-
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
 
 /**
  * @author ReaJason
  * @since 2024/12/4
  */
-@Slf4j
 @Testcontainers
-public class Struct2ContainerTest {
-    public static final String imageName = "tomcat:8-jre8";
+public class Struct2ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig.builder()
+            .imageName("tomcat:8-jre8")
+            .server(Server.Struct2)
+            .warFile(ContainerTool.struct2WarFile)
+            .warDeployPath("/usr/local/tomcat/webapps/app.war")
+            .pidScript(ContainerTool.tomcatPid)
+            .enableJspPackerTest(false)
+            .targetJdkVersion(Opcodes.V1_8)
+            .supportedShellTypes(List.of(ShellType.ACTION))
+            .testPackers(List.of(Packers.ScriptEngine))
+            .probeShellTypes(List.of(ShellType.ACTION))
+            .build();
 
-    static Network network = Network.newNetwork();
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
 
     @Container
-    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(struct2WarFile, "/usr/local/tomcat/webapps/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(tomcatPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/app"))
-            .withExposedPorts(8080);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.Struct2;
-        List<String> supportedShellTypes = List.of(ShellType.ACTION);
-        List<Packers> testPackers = List.of(Packers.ScriptEngine);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        log.info(logs);
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.Struct2, shellType, shellTool, Opcodes.V1_8, packer, container, python);
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.ACTION})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.Struct2, shellType, Opcodes.V1_8);
-    }
-}
+}

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/tomcat/Tomcat10ContainerTest.java

@@ -1,95 +1,61 @@
 package com.reajason.javaweb.integration.memshell.tomcat;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellTool;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
 
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
+import static com.reajason.javaweb.integration.ContainerTool.warJakartaFile;
 
 /**
  * @author ReaJason
  * @since 2024/12/4
  */
-@Slf4j
 @Testcontainers
-public class Tomcat10ContainerTest {
-    public static final String imageName = "tomcat:10.1-jre11";
-    static Network network = Network.newNetwork();
+public class Tomcat10ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig.tomcat("tomcat:10.1-jre11")
+            .warFile(warJakartaFile)
+            .targetJdkVersion(Opcodes.V11)
+            .supportedShellTypes(List.of(
+                    ShellType.JAKARTA_FILTER,
+                    ShellType.JAKARTA_SERVLET,
+                    ShellType.JAKARTA_LISTENER,
+                    ShellType.JAKARTA_VALVE,
+                    ShellType.JAKARTA_PROXY_VALVE,
+                    ShellType.JAKARTA_WEBSOCKET,
+                    ShellType.UPGRADE,
+                    ShellType.AGENT_FILTER_CHAIN,
+                    ShellType.CATALINA_AGENT_CONTEXT_VALVE
+            ))
+            .testPackers(List.of(Packers.JSP, Packers.AgentJarWithJREAttacher))
+            .unSupportedShellTools(List.of(ShellTool.AntSword))
+            .probeShellTypes(List.of(
+                    ShellType.JAKARTA_FILTER,
+                    ShellType.JAKARTA_SERVLET,
+                    ShellType.JAKARTA_LISTENER,
+                    ShellType.JAKARTA_VALVE,
+                    ShellType.JAKARTA_PROXY_VALVE,
+                    ShellType.JAKARTA_WEBSOCKET
+            ))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warJakartaFile, "/usr/local/tomcat/webapps/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(tomcatPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/app"))
-            .withExposedPorts(8080);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.Tomcat;
-        List<String> supportedShellTypes = List.of(
-                ShellType.JAKARTA_FILTER,
-                ShellType.JAKARTA_SERVLET,
-                ShellType.JAKARTA_LISTENER,
-                ShellType.JAKARTA_VALVE,
-                ShellType.JAKARTA_PROXY_VALVE,
-                ShellType.JAKARTA_WEBSOCKET,
-                ShellType.UPGRADE,
-                ShellType.AGENT_FILTER_CHAIN,
-                ShellType.CATALINA_AGENT_CONTEXT_VALVE
-        );
-        List<Packers> testPackers = List.of(Packers.JSP, Packers.AgentJarWithJREAttacher);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers, null, List.of(ShellTool.AntSword));
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        log.info(logs);
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.Tomcat, shellType, shellTool, Opcodes.V11, packer, container, python);
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.JAKARTA_FILTER,
-            ShellType.JAKARTA_SERVLET,
-            ShellType.JAKARTA_LISTENER,
-            ShellType.JAKARTA_VALVE,
-            ShellType.JAKARTA_PROXY_VALVE,
-            ShellType.JAKARTA_WEBSOCKET})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.Tomcat, shellType, Opcodes.V11);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/tomcat/Tomcat11ContainerTest.java

@@ -1,96 +1,61 @@
 package com.reajason.javaweb.integration.memshell.tomcat;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellTool;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
 
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
+import static com.reajason.javaweb.integration.ContainerTool.warJakartaFile;
 
 /**
  * @author ReaJason
  * @since 2024/12/4
  */
-@Slf4j
 @Testcontainers
-public class Tomcat11ContainerTest {
+public class Tomcat11ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig.tomcat("tomcat:11.0-jre17")
+            .warFile(warJakartaFile)
+            .targetJdkVersion(Opcodes.V17)
+            .supportedShellTypes(List.of(
+                    ShellType.JAKARTA_FILTER,
+                    ShellType.JAKARTA_SERVLET,
+                    ShellType.JAKARTA_LISTENER,
+                    ShellType.JAKARTA_VALVE,
+                    ShellType.JAKARTA_PROXY_VALVE,
+                    ShellType.JAKARTA_WEBSOCKET,
+                    ShellType.UPGRADE,
+                    ShellType.AGENT_FILTER_CHAIN,
+                    ShellType.CATALINA_AGENT_CONTEXT_VALVE
+            ))
+            .testPackers(List.of(Packers.JSP, Packers.AgentJarWithJREAttacher))
+            .unSupportedShellTools(List.of(ShellTool.AntSword))
+            .probeShellTypes(List.of(
+                    ShellType.JAKARTA_FILTER,
+                    ShellType.JAKARTA_SERVLET,
+                    ShellType.JAKARTA_LISTENER,
+                    ShellType.JAKARTA_VALVE,
+                    ShellType.JAKARTA_PROXY_VALVE,
+                    ShellType.JAKARTA_WEBSOCKET
+            ))
+            .build();
 
-    public static final String imageName = "tomcat:11.0-jre17";
-    static Network network = Network.newNetwork();
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warJakartaFile, "/usr/local/tomcat/webapps/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(tomcatPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/app"))
-            .withExposedPorts(8080);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.Tomcat;
-        List<String> supportedShellTypes = List.of(
-                ShellType.JAKARTA_FILTER,
-                ShellType.JAKARTA_SERVLET,
-                ShellType.JAKARTA_LISTENER,
-                ShellType.JAKARTA_VALVE,
-                ShellType.JAKARTA_PROXY_VALVE,
-                ShellType.JAKARTA_WEBSOCKET,
-                ShellType.UPGRADE,
-                ShellType.AGENT_FILTER_CHAIN,
-                ShellType.CATALINA_AGENT_CONTEXT_VALVE
-        );
-        List<Packers> testPackers = List.of(Packers.JSP, Packers.AgentJarWithJREAttacher);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers, null, List.of(ShellTool.AntSword));
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        log.info(logs);
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.Tomcat, shellType, shellTool, Opcodes.V17, packer, container, python);
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.JAKARTA_FILTER,
-            ShellType.JAKARTA_SERVLET,
-            ShellType.JAKARTA_LISTENER,
-            ShellType.JAKARTA_VALVE,
-            ShellType.JAKARTA_PROXY_VALVE,
-            ShellType.JAKARTA_WEBSOCKET})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.Tomcat, shellType, Opcodes.V17);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/tomcat/Tomcat11JRE21ContainerTest.java

@@ -1,96 +1,60 @@
 package com.reajason.javaweb.integration.memshell.tomcat;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellTool;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
 
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
+import static com.reajason.javaweb.integration.ContainerTool.warJakartaFile;
 
 /**
  * @author ReaJason
  * @since 2024/12/4
  */
-@Slf4j
 @Testcontainers
-public class Tomcat11JRE21ContainerTest {
+public class Tomcat11JRE21ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig.tomcat("tomcat:11.0-jre21")
+            .warFile(warJakartaFile)
+            .targetJdkVersion(Opcodes.V21)
+            .supportedShellTypes(List.of(
+                    ShellType.JAKARTA_FILTER,
+                    ShellType.JAKARTA_SERVLET,
+                    ShellType.JAKARTA_LISTENER,
+                    ShellType.JAKARTA_VALVE,
+                    ShellType.JAKARTA_PROXY_VALVE,
+                    ShellType.JAKARTA_WEBSOCKET,
+                    ShellType.AGENT_FILTER_CHAIN,
+                    ShellType.CATALINA_AGENT_CONTEXT_VALVE
+            ))
+            .testPackers(List.of(Packers.JSP, Packers.AgentJarWithJREAttacher))
+            .unSupportedShellTools(List.of(ShellTool.AntSword))
+            .probeShellTypes(List.of(
+                    ShellType.JAKARTA_FILTER,
+                    ShellType.JAKARTA_SERVLET,
+                    ShellType.JAKARTA_LISTENER,
+                    ShellType.JAKARTA_VALVE,
+                    ShellType.JAKARTA_PROXY_VALVE,
+                    ShellType.JAKARTA_WEBSOCKET
+            ))
+            .build();
 
-    public static final String imageName = "tomcat:11.0-jre21";
-    static Network network = Network.newNetwork();
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
 
     @Container
-    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warJakartaFile, "/usr/local/tomcat/webapps/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(tomcatPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/app"))
-            .withExposedPorts(8080);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.Tomcat;
-        List<String> supportedShellTypes = List.of(
-                ShellType.JAKARTA_FILTER,
-                ShellType.JAKARTA_SERVLET,
-                ShellType.JAKARTA_LISTENER,
-                ShellType.JAKARTA_VALVE,
-                ShellType.JAKARTA_PROXY_VALVE,
-                ShellType.JAKARTA_WEBSOCKET,
-                ShellType.AGENT_FILTER_CHAIN,
-                ShellType.CATALINA_AGENT_CONTEXT_VALVE
-        );
-        List<Packers> testPackers = List.of(Packers.JSP, Packers.AgentJarWithJREAttacher);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers, null, List.of(ShellTool.AntSword));
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        log.info(logs);
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.Tomcat, shellType, shellTool, Opcodes.V21, packer, container, python);
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.JAKARTA_FILTER,
-            ShellType.JAKARTA_SERVLET,
-            ShellType.JAKARTA_LISTENER,
-            ShellType.JAKARTA_VALVE,
-            ShellType.JAKARTA_PROXY_VALVE,
-            ShellType.JAKARTA_WEBSOCKET})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.Tomcat, shellType, Opcodes.V21);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/tomcat/Tomcat5ContainerTest.java

@@ -1,90 +1,54 @@
 package com.reajason.javaweb.integration.memshell.tomcat;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
-
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
 
 /**
  * @author ReaJason
  * @since 2024/12/4
  */
-@Slf4j
 @Testcontainers
-public class Tomcat5ContainerTest {
-    public static final String imageName = "reajason/tomcat:5-jdk6";
+public class Tomcat5ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig
+            .tomcat("reajason/tomcat:5-jdk6")
+            .targetJdkVersion(Opcodes.V1_6)
+            .supportedShellTypes(List.of(
+                    ShellType.SERVLET,
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.VALVE,
+                    ShellType.PROXY_VALVE,
+                    ShellType.AGENT_FILTER_CHAIN,
+                    ShellType.CATALINA_AGENT_CONTEXT_VALVE
+            ))
+            .testPackers(List.of(Packers.JSP, Packers.AgentJarWithJDKAttacher))
+            .probeShellTypes(List.of(
+                    ShellType.FILTER,
+                    ShellType.SERVLET,
+                    ShellType.LISTENER,
+                    ShellType.VALVE,
+                    ShellType.PROXY_VALVE
+            ))
+            .build();
 
-    static Network network = Network.newNetwork();
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
 
     @Container
-    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warFile, "/usr/local/tomcat/webapps/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(tomcatPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/app"))
-            .withExposedPorts(8080);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.Tomcat;
-        List<String> supportedShellTypes = List.of(
-                ShellType.SERVLET,
-                ShellType.FILTER,
-                ShellType.LISTENER,
-                ShellType.VALVE,
-                ShellType.PROXY_VALVE,
-                ShellType.AGENT_FILTER_CHAIN,
-                ShellType.CATALINA_AGENT_CONTEXT_VALVE
-        );
-        List<Packers> testPackers = List.of(Packers.JSP, Packers.AgentJarWithJDKAttacher);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        log.info(logs);
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.Tomcat, shellType, shellTool, Opcodes.V1_6, packer, container, python);
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.FILTER, ShellType.SERVLET, ShellType.LISTENER,
-            ShellType.VALVE, ShellType.PROXY_VALVE})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.Tomcat, shellType, Opcodes.V1_6);
-    }
-}
+}

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/tomcat/Tomcat6ContainerTest.java

@@ -1,88 +1,53 @@
 package com.reajason.javaweb.integration.memshell.tomcat;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
-
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
 
 /**
  * @author ReaJason
  * @since 2024/12/4
  */
-@Slf4j
 @Testcontainers
-public class Tomcat6ContainerTest {
-    public static final String imageName = "reajason/tomcat:6-jdk6";
-    static Network network = Network.newNetwork();
+public class Tomcat6ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig.tomcat("reajason/tomcat:6-jdk6")
+            .targetJdkVersion(Opcodes.V1_6)
+            .supportedShellTypes(List.of(
+                    ShellType.FILTER,
+                    ShellType.SERVLET,
+                    ShellType.LISTENER,
+                    ShellType.VALVE,
+                    ShellType.PROXY_VALVE,
+                    ShellType.AGENT_FILTER_CHAIN,
+                    ShellType.CATALINA_AGENT_CONTEXT_VALVE
+            ))
+            .testPackers(List.of(Packers.JSP, Packers.AgentJarWithJDKAttacher))
+            .probeShellTypes(List.of(
+                    ShellType.FILTER,
+                    ShellType.SERVLET,
+                    ShellType.LISTENER,
+                    ShellType.VALVE,
+                    ShellType.PROXY_VALVE
+            ))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warFile, "/usr/local/tomcat/webapps/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(tomcatPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/app"))
-            .withExposedPorts(8080);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.Tomcat;
-        List<String> supportedShellTypes = List.of(
-                ShellType.FILTER,
-                ShellType.SERVLET,
-                ShellType.LISTENER,
-                ShellType.VALVE,
-                ShellType.PROXY_VALVE,
-                ShellType.AGENT_FILTER_CHAIN,
-                ShellType.CATALINA_AGENT_CONTEXT_VALVE
-        );
-        List<Packers> testPackers = List.of(Packers.JSP, Packers.AgentJarWithJDKAttacher);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        log.info(logs);
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.Tomcat, shellType, shellTool, Opcodes.V1_6, packer, container, python);
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.FILTER, ShellType.SERVLET, ShellType.LISTENER,
-            ShellType.VALVE, ShellType.PROXY_VALVE})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.Tomcat, shellType, Opcodes.V1_6);
-    }
-}
+}

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/tomcat/Tomcat7ContainerTest.java

@@ -1,89 +1,56 @@
 package com.reajason.javaweb.integration.memshell.tomcat;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
-
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
 
 /**
  * @author ReaJason
  * @since 2024/12/4
  */
-@Slf4j
 @Testcontainers
-public class Tomcat7ContainerTest {
-    public static final String imageName = "tomcat:7.0.85-jre7";
-    static Network network = Network.newNetwork();
+public class Tomcat7ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig.tomcat("tomcat:7.0.85-jre7")
+            .targetJdkVersion(Opcodes.V1_7)
+            .probeTargetJdkVersion(Opcodes.V1_6)
+            .supportedShellTypes(List.of(
+                    ShellType.FILTER,
+                    ShellType.SERVLET,
+                    ShellType.LISTENER,
+                    ShellType.VALVE,
+                    ShellType.PROXY_VALVE,
+                    ShellType.WEBSOCKET,
+                    ShellType.AGENT_FILTER_CHAIN,
+                    ShellType.CATALINA_AGENT_CONTEXT_VALVE
+            ))
+            .testPackers(List.of(Packers.JSP, Packers.AgentJarWithJREAttacher))
+            .probeShellTypes(List.of(
+                    ShellType.FILTER,
+                    ShellType.SERVLET,
+                    ShellType.LISTENER,
+                    ShellType.VALVE,
+                    ShellType.PROXY_VALVE,
+                    ShellType.WEBSOCKET
+            ))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warFile, "/usr/local/tomcat/webapps/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(tomcatPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/app"))
-            .withExposedPorts(8080);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.Tomcat;
-        List<String> supportedShellTypes = List.of(
-                ShellType.FILTER,
-                ShellType.SERVLET,
-                ShellType.LISTENER,
-                ShellType.VALVE,
-                ShellType.PROXY_VALVE,
-                ShellType.WEBSOCKET,
-                ShellType.AGENT_FILTER_CHAIN,
-                ShellType.CATALINA_AGENT_CONTEXT_VALVE
-        );
-        List<Packers> testPackers = List.of(Packers.JSP, Packers.AgentJarWithJREAttacher);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        log.info(logs);
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.Tomcat, shellType, shellTool, Opcodes.V1_7, packer, container, python);
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.FILTER, ShellType.SERVLET, ShellType.LISTENER,
-            ShellType.VALVE, ShellType.PROXY_VALVE, ShellType.WEBSOCKET})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.Tomcat, shellType, Opcodes.V1_6);
-    }
-}
+}

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/tomcat/Tomcat8ContainerTest.java

@@ -1,91 +1,56 @@
 package com.reajason.javaweb.integration.memshell.tomcat;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
-
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
 
 /**
  * @author ReaJason
  * @since 2024/12/4
  */
-@Slf4j
 @Testcontainers
-public class Tomcat8ContainerTest {
-    public static final String imageName = "tomcat:8-jre8";
+public class Tomcat8ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig.tomcat("tomcat:8-jre8")
+            .targetJdkVersion(Opcodes.V1_8)
+            .supportedShellTypes(List.of(
+                    ShellType.FILTER,
+                    ShellType.SERVLET,
+                    ShellType.LISTENER,
+                    ShellType.VALVE,
+                    ShellType.PROXY_VALVE,
+                    ShellType.WEBSOCKET,
+                    ShellType.UPGRADE,
+                    ShellType.AGENT_FILTER_CHAIN,
+                    ShellType.CATALINA_AGENT_CONTEXT_VALVE
+            ))
+            .testPackers(List.of(Packers.BigInteger, Packers.AgentJarWithJREAttacher))
+            .probeShellTypes(List.of(
+                    ShellType.FILTER,
+                    ShellType.SERVLET,
+                    ShellType.LISTENER,
+                    ShellType.VALVE,
+                    ShellType.PROXY_VALVE,
+                    ShellType.WEBSOCKET
+            ))
+            .build();
 
-    static Network network = Network.newNetwork();
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
 
     @Container
-    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warFile, "/usr/local/tomcat/webapps/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(tomcatPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/app"))
-            .withExposedPorts(8080);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.Tomcat;
-        List<String> supportedShellTypes = List.of(
-                ShellType.FILTER,
-                ShellType.SERVLET,
-                ShellType.LISTENER,
-                ShellType.VALVE,
-                ShellType.PROXY_VALVE,
-                ShellType.WEBSOCKET,
-                ShellType.UPGRADE,
-                ShellType.AGENT_FILTER_CHAIN,
-                ShellType.CATALINA_AGENT_CONTEXT_VALVE);
-        List<Packers> testPackers = List.of(Packers.BigInteger, Packers.AgentJarWithJREAttacher);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        log.info(logs);
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.Tomcat, shellType, shellTool, Opcodes.V1_8, packer, container, python);
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.FILTER, ShellType.SERVLET, ShellType.LISTENER,
-            ShellType.VALVE, ShellType.PROXY_VALVE, ShellType.WEBSOCKET})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.Tomcat, shellType, Opcodes.V1_8);
-    }
-}
+}

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/tomcat/Tomcat9ContainerTest.java

@@ -1,90 +1,56 @@
 package com.reajason.javaweb.integration.memshell.tomcat;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
-
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
 
 /**
  * @author ReaJason
  * @since 2024/12/4
  */
-@Slf4j
 @Testcontainers
-public class Tomcat9ContainerTest {
-    public static final String imageName = "tomcat:9-jre9";
-    static Network network = Network.newNetwork();
+public class Tomcat9ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig.tomcat("tomcat:9-jre9")
+            .targetJdkVersion(Opcodes.V9)
+            .supportedShellTypes(List.of(
+                    ShellType.FILTER,
+                    ShellType.SERVLET,
+                    ShellType.LISTENER,
+                    ShellType.VALVE,
+                    ShellType.PROXY_VALVE,
+                    ShellType.WEBSOCKET,
+                    ShellType.UPGRADE,
+                    ShellType.AGENT_FILTER_CHAIN,
+                    ShellType.CATALINA_AGENT_CONTEXT_VALVE
+            ))
+            .testPackers(List.of(Packers.JSP, Packers.ScriptEngine, Packers.AgentJarWithJREAttacher))
+            .probeShellTypes(List.of(
+                    ShellType.FILTER,
+                    ShellType.SERVLET,
+                    ShellType.LISTENER,
+                    ShellType.VALVE,
+                    ShellType.PROXY_VALVE,
+                    ShellType.WEBSOCKET
+            ))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warFile, "/usr/local/tomcat/webapps/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(tomcatPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/app"))
-            .withExposedPorts(8080);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.Tomcat;
-        List<String> supportedShellTypes = List.of(
-                ShellType.FILTER,
-                ShellType.SERVLET,
-                ShellType.LISTENER,
-                ShellType.VALVE,
-                ShellType.PROXY_VALVE,
-                ShellType.WEBSOCKET,
-                ShellType.UPGRADE,
-                ShellType.AGENT_FILTER_CHAIN,
-                ShellType.CATALINA_AGENT_CONTEXT_VALVE
-        );
-        List<Packers> testPackers = List.of(Packers.JSP, Packers.ScriptEngine, Packers.AgentJarWithJREAttacher);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        log.info(logs);
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.Tomcat, shellType, shellTool, Opcodes.V9, packer, container, python);
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.FILTER, ShellType.SERVLET, ShellType.LISTENER,
-            ShellType.VALVE, ShellType.PROXY_VALVE, ShellType.WEBSOCKET})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.Tomcat, shellType, Opcodes.V9);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/weblogic/WebLogic1036ContainerTest.java

@@ -1,91 +1,51 @@
 package com.reajason.javaweb.integration.memshell.weblogic;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
-
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
 
 /**
  * @author ReaJason
  * @since 2024/12/24
  */
 @Testcontainers
-@Slf4j
-public class WebLogic1036ContainerTest {
-    public static final String imageName = "reajason/weblogic:10.3.6";
-    static Network network = Network.newNetwork();
+public class WebLogic1036ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig.webLogic(
+            "reajason/weblogic:10.3.6",
+            "/opt/oracle/wls1036/user_projects/domains/base_domain/autodeploy/app.war")
+            .targetJdkVersion(Opcodes.V1_6)
+            .assertLogs(false)
+            .supportedShellTypes(List.of(
+                    ShellType.SERVLET,
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.WEBLOGIC_AGENT_SERVLET_CONTEXT
+            ))
+            .testPackers(List.of(Packers.Base64))
+            .probeShellTypes(List.of(
+                    ShellType.SERVLET,
+                    ShellType.FILTER,
+                    ShellType.LISTENER
+            ))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warFile, "/opt/oracle/wls1036/user_projects/domains/base_domain/autodeploy/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(weblogicPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/app"))
-            .withExposedPorts(7001);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.WebLogic;
-        List<String> supportedShellTypes = List.of(
-                ShellType.SERVLET,
-                ShellType.FILTER,
-                ShellType.LISTENER,
-                ShellType.WEBLOGIC_AGENT_SERVLET_CONTEXT
-        );
-        List<Packers> testPackers = List.of(Packers.Base64);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        log.info(logs);
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.WebLogic, shellType, shellTool, Opcodes.V1_6, packer, container, python);
-    }
-
-    public static String getUrl(GenericContainer<?> container) {
-        String host = container.getHost();
-        int port = container.getMappedPort(7001);
-        String url = "http://" + host + ":" + port + "/app";
-        log.info("container started, app url is : {}", url);
-        return url;
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.SERVLET,
-            ShellType.FILTER,
-            ShellType.LISTENER,})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.WebLogic, shellType, Opcodes.V1_6);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/weblogic/WebLogic12214ContainerTest.java

@@ -1,94 +1,50 @@
 package com.reajason.javaweb.integration.memshell.weblogic;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
-
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
 
 /**
  * @author ReaJason
  * @since 2024/12/24
  */
 @Testcontainers
-@Slf4j
-public class WebLogic12214ContainerTest {
-    public static final String imageName = "reajason/weblogic:12.2.1.4";
-    static Network network = Network.newNetwork();
+public class WebLogic12214ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig.webLogic(
+            "reajason/weblogic:12.2.1.4",
+            "/u01/oracle/user_projects/domains/domain1/autodeploy/app.war")
+            .targetJdkVersion(Opcodes.V1_6)
+            .supportedShellTypes(List.of(
+                    ShellType.SERVLET,
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.WEBLOGIC_AGENT_SERVLET_CONTEXT
+            ))
+            .testPackers(List.of(Packers.Base64))
+            .probeShellTypes(List.of(
+                    ShellType.SERVLET,
+                    ShellType.FILTER,
+                    ShellType.LISTENER
+            ))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warFile, "/u01/oracle/user_projects/domains/domain1/autodeploy/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(weblogicPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/app"))
-            .withExposedPorts(7001);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.WebLogic;
-        List<String> supportedShellTypes = List.of(
-                ShellType.SERVLET,
-                ShellType.FILTER,
-                ShellType.LISTENER,
-                ShellType.WEBLOGIC_AGENT_SERVLET_CONTEXT
-        );
-        List<Packers> testPackers = List.of(Packers.Base64);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        log.info(logs);
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.WebLogic, shellType, shellTool, Opcodes.V1_6, packer, container, python);
-    }
-
-    public static String getUrl(GenericContainer<?> container) {
-        String host = container.getHost();
-        int port = container.getMappedPort(7001);
-        String url = "http://" + host + ":" + port + "/app";
-        log.info("container started, app url is : {}", url);
-        return url;
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.SERVLET,
-            ShellType.FILTER,
-            ShellType.LISTENER,})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.WebLogic, shellType, Opcodes.V1_6);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/weblogic/WebLogic14110ContainerTest.java

@@ -1,94 +1,50 @@
 package com.reajason.javaweb.integration.memshell.weblogic;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
-
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
 
 /**
  * @author ReaJason
  * @since 2024/12/24
  */
 @Testcontainers
-@Slf4j
-public class WebLogic14110ContainerTest {
-    public static final String imageName = "reajason/weblogic:14.1.1.0";
-    static Network network = Network.newNetwork();
+public class WebLogic14110ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig.webLogic(
+            "reajason/weblogic:14.1.1.0",
+            "/u01/oracle/user_projects/domains/domain1/autodeploy/app.war")
+            .targetJdkVersion(Opcodes.V1_6)
+            .supportedShellTypes(List.of(
+                    ShellType.SERVLET,
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.WEBLOGIC_AGENT_SERVLET_CONTEXT
+            ))
+            .testPackers(List.of(Packers.Base64))
+            .probeShellTypes(List.of(
+                    ShellType.SERVLET,
+                    ShellType.FILTER,
+                    ShellType.LISTENER
+            ))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warFile, "/u01/oracle/user_projects/domains/domain1/autodeploy/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(weblogicPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/app"))
-            .withExposedPorts(7001);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.WebLogic;
-        List<String> supportedShellTypes = List.of(
-                ShellType.SERVLET,
-                ShellType.FILTER,
-                ShellType.LISTENER,
-                ShellType.WEBLOGIC_AGENT_SERVLET_CONTEXT
-        );
-        List<Packers> testPackers = List.of(Packers.Base64);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        log.info(logs);
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.WebLogic, shellType, shellTool, Opcodes.V1_6, packer, container, python);
-    }
-
-    public static String getUrl(GenericContainer<?> container) {
-        String host = container.getHost();
-        int port = container.getMappedPort(7001);
-        String url = "http://" + host + ":" + port + "/app";
-        log.info("container started, app url is : {}", url);
-        return url;
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.SERVLET,
-            ShellType.FILTER,
-            ShellType.LISTENER,})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.WebLogic, shellType, Opcodes.V1_6);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/weblogic/WebLogic14120ContainerTest.java

@@ -0,0 +1,50 @@
+package com.reajason.javaweb.integration.memshell.weblogic;
+
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
+import com.reajason.javaweb.memshell.ShellType;
+import com.reajason.javaweb.packer.Packers;
+import net.bytebuddy.jar.asm.Opcodes;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.Network;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.util.List;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/24
+ */
+@Testcontainers
+public class WebLogic14120ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig.webLogic(
+            "reajason/weblogic:14.1.2.0-jdk17",
+            "/u01/oracle/user_projects/domains/domain1/autodeploy/app.war")
+            .targetJdkVersion(Opcodes.V17)
+            .supportedShellTypes(List.of(
+                    ShellType.SERVLET,
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.WEBLOGIC_AGENT_SERVLET_CONTEXT
+            ))
+            .testPackers(List.of(Packers.Base64))
+            .probeShellTypes(List.of(
+                    ShellType.SERVLET,
+                    ShellType.FILTER,
+                    ShellType.LISTENER
+            ))
+            .build();
+
+    static Network network = newNetwork();
+    @Container
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
+    @Container
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
+
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
+    }
+}

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/websphere/OpenLiberty18ContainerTest.java

@@ -1,96 +1,53 @@
 package com.reajason.javaweb.integration.memshell.websphere;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
 import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.time.Duration;
 import java.util.List;
-import java.util.stream.Stream;
-
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
 
 /**
  * @author ReaJason
  * @since 2024/12/21
  */
 @Testcontainers
-@Slf4j
-public class OpenLiberty18ContainerTest {
-    public static final String imageName = "open-liberty:18.0.0.4-webProfile8";
-    static Network network = Network.newNetwork();
+public class OpenLiberty18ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig.webSphere(
+            "open-liberty:18.0.0.4-webProfile8",
+            "/config/dropins/app.war")
+            .targetJdkVersion(Opcodes.V1_6)
+            .waitStrategy(Wait.forHttp("/app/").forPort(9080).withStartupTimeout(Duration.ofMinutes(5)))
+            .supportedShellTypes(List.of(
+                    ShellType.SERVLET,
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.WAS_AGENT_FILTER_MANAGER
+            ))
+            .testPackers(List.of(Packers.JSP))
+            .probeShellTypes(List.of(
+                    ShellType.SERVLET,
+                    ShellType.FILTER,
+                    ShellType.LISTENER
+            ))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warFile, "/config/dropins/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(webspherePid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/app/").forPort(9080).withStartupTimeout(Duration.ofMinutes(5)))
-            .withExposedPorts(9080)
-            .withPrivilegedMode(true);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.WebSphere;
-        List<String> supportedShellTypes = List.of(
-                ShellType.SERVLET,
-                ShellType.FILTER,
-                ShellType.LISTENER,
-                ShellType.WAS_AGENT_FILTER_MANAGER
-        );
-        List<Packers> testPackers = List.of(Packers.JSP);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        log.info(logs);
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.WebSphere, shellType, shellTool, Opcodes.V1_6, packer, container, python);
-    }
-
-    public static String getUrl(GenericContainer<?> container) {
-        String host = container.getHost();
-        int port = container.getMappedPort(9080);
-        String url = "http://" + host + ":" + port + "/app";
-        log.info("container started, app url is : {}", url);
-        return url;
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.SERVLET,
-            ShellType.FILTER,
-            ShellType.LISTENER,})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.WebSphere, shellType, Opcodes.V1_6);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/websphere/OpenLiberty20ContainerTest.java

@@ -1,96 +1,53 @@
 package com.reajason.javaweb.integration.memshell.websphere;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
 import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.time.Duration;
 import java.util.List;
-import java.util.stream.Stream;
-
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
 
 /**
  * @author ReaJason
  * @since 2024/12/21
  */
 @Testcontainers
-@Slf4j
-public class OpenLiberty20ContainerTest {
-    public static final String imageName = "open-liberty:20.0.0.12-full-java8-openj9";
-    static Network network = Network.newNetwork();
+public class OpenLiberty20ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig.webSphere(
+            "open-liberty:20.0.0.12-full-java8-openj9",
+            "/config/dropins/app.war")
+            .targetJdkVersion(Opcodes.V1_6)
+            .waitStrategy(Wait.forHttp("/app/").forPort(9080).withStartupTimeout(Duration.ofMinutes(5)))
+            .supportedShellTypes(List.of(
+                    ShellType.SERVLET,
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.WAS_AGENT_FILTER_MANAGER
+            ))
+            .testPackers(List.of(Packers.JSP))
+            .probeShellTypes(List.of(
+                    ShellType.SERVLET,
+                    ShellType.FILTER,
+                    ShellType.LISTENER
+            ))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warFile, "/config/dropins/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(webspherePid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/app/").forPort(9080).withStartupTimeout(Duration.ofMinutes(5)))
-            .withExposedPorts(9080)
-            .withPrivilegedMode(true);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.WebSphere;
-        List<String> supportedShellTypes = List.of(
-                ShellType.SERVLET,
-                ShellType.FILTER,
-                ShellType.LISTENER,
-                ShellType.WAS_AGENT_FILTER_MANAGER
-        );
-        List<Packers> testPackers = List.of(Packers.JSP);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        log.info(logs);
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.WebSphere, shellType, shellTool, Opcodes.V1_6, packer, container, python);
-    }
-
-    public static String getUrl(GenericContainer<?> container) {
-        String host = container.getHost();
-        int port = container.getMappedPort(9080);
-        String url = "http://" + host + ":" + port + "/app";
-        log.info("container started, app url is : {}", url);
-        return url;
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.SERVLET,
-            ShellType.FILTER,
-            ShellType.LISTENER,})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.WebSphere, shellType, Opcodes.V1_6);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/websphere/OpenLiberty22ContainerTest.java

@@ -1,96 +1,53 @@
 package com.reajason.javaweb.integration.memshell.websphere;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
 import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.time.Duration;
 import java.util.List;
-import java.util.stream.Stream;
-
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
 
 /**
  * @author ReaJason
  * @since 2024/12/21
  */
 @Testcontainers
-@Slf4j
-public class OpenLiberty22ContainerTest {
-    public static final String imageName = "open-liberty:22.0.0.12-full-java11-openj9";
-    static Network network = Network.newNetwork();
+public class OpenLiberty22ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig.webSphere(
+            "open-liberty:22.0.0.12-full-java11-openj9",
+            "/config/dropins/app.war")
+            .targetJdkVersion(Opcodes.V11)
+            .waitStrategy(Wait.forHttp("/app/").forPort(9080).withStartupTimeout(Duration.ofMinutes(5)))
+            .supportedShellTypes(List.of(
+                    ShellType.SERVLET,
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.WAS_AGENT_FILTER_MANAGER
+            ))
+            .testPackers(List.of(Packers.JSP))
+            .probeShellTypes(List.of(
+                    ShellType.SERVLET,
+                    ShellType.FILTER,
+                    ShellType.LISTENER
+            ))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warFile, "/config/dropins/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(webspherePid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/app/").forPort(9080).withStartupTimeout(Duration.ofMinutes(5)))
-            .withExposedPorts(9080)
-            .withPrivilegedMode(true);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.WebSphere;
-        List<String> supportedShellTypes = List.of(
-                ShellType.SERVLET,
-                ShellType.FILTER,
-                ShellType.LISTENER,
-                ShellType.WAS_AGENT_FILTER_MANAGER
-        );
-        List<Packers> testPackers = List.of(Packers.JSP);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        log.info(logs);
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.WebSphere, shellType, shellTool, Opcodes.V11, packer, container, python);
-    }
-
-    public static String getUrl(GenericContainer<?> container) {
-        String host = container.getHost();
-        int port = container.getMappedPort(9080);
-        String url = "http://" + host + ":" + port + "/app";
-        log.info("container started, app url is : {}", url);
-        return url;
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.SERVLET,
-            ShellType.FILTER,
-            ShellType.LISTENER,})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.WebSphere, shellType, Opcodes.V11);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/websphere/OpenLiberty25ContainerTest.java

@@ -1,96 +1,53 @@
 package com.reajason.javaweb.integration.memshell.websphere;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
 import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.time.Duration;
 import java.util.List;
-import java.util.stream.Stream;
-
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
 
 /**
  * @author ReaJason
  * @since 2024/12/21
  */
 @Testcontainers
-@Slf4j
-public class OpenLiberty25ContainerTest {
-    public static final String imageName = "open-liberty:25.0.0.12-full-java17-openj9";
-    static Network network = Network.newNetwork();
+public class OpenLiberty25ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig.webSphere(
+            "open-liberty:25.0.0.12-full-java17-openj9",
+            "/config/dropins/app.war")
+            .targetJdkVersion(Opcodes.V17)
+            .waitStrategy(Wait.forHttp("/app/").forPort(9080).withStartupTimeout(Duration.ofMinutes(5)))
+            .supportedShellTypes(List.of(
+                    ShellType.SERVLET,
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.WAS_AGENT_FILTER_MANAGER
+            ))
+            .testPackers(List.of(Packers.JSP))
+            .probeShellTypes(List.of(
+                    ShellType.SERVLET,
+                    ShellType.FILTER,
+                    ShellType.LISTENER
+            ))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warFile, "/config/dropins/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(webspherePid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/app/").forPort(9080).withStartupTimeout(Duration.ofMinutes(5)))
-            .withExposedPorts(9080)
-            .withPrivilegedMode(true);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.WebSphere;
-        List<String> supportedShellTypes = List.of(
-                ShellType.SERVLET,
-                ShellType.FILTER,
-                ShellType.LISTENER,
-                ShellType.WAS_AGENT_FILTER_MANAGER
-        );
-        List<Packers> testPackers = List.of(Packers.JSP);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        log.info(logs);
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.WebSphere, shellType, shellTool, Opcodes.V17, packer, container, python);
-    }
-
-    public static String getUrl(GenericContainer<?> container) {
-        String host = container.getHost();
-        int port = container.getMappedPort(9080);
-        String url = "http://" + host + ":" + port + "/app";
-        log.info("container started, app url is : {}", url);
-        return url;
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.SERVLET,
-            ShellType.FILTER,
-            ShellType.LISTENER,})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.WebSphere, shellType, Opcodes.V17);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/websphere/WebSphere855ContainerTest.java

@@ -1,96 +1,53 @@
 package com.reajason.javaweb.integration.memshell.websphere;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
 import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.time.Duration;
 import java.util.List;
-import java.util.stream.Stream;
-
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
 
 /**
  * @author ReaJason
  * @since 2024/12/21
  */
 @Testcontainers
-@Slf4j
-public class WebSphere855ContainerTest {
-    public static final String imageName = "reajason/websphere:8.5.5.24";
-    static Network network = Network.newNetwork();
+public class WebSphere855ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig.webSphere(
+            "reajason/websphere:8.5.5.24",
+            "/opt/IBM/WebSphere/AppServer/profiles/AppSrv01/monitoredDeployableApps/servers/server1/app.war")
+            .targetJdkVersion(Opcodes.V1_6)
+            .waitStrategy(Wait.forHttp("/app/").forPort(9080).withStartupTimeout(Duration.ofMinutes(5)))
+            .supportedShellTypes(List.of(
+                    ShellType.SERVLET,
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.WAS_AGENT_FILTER_MANAGER
+            ))
+            .testPackers(List.of(Packers.JSP))
+            .probeShellTypes(List.of(
+                    ShellType.SERVLET,
+                    ShellType.FILTER,
+                    ShellType.LISTENER
+            ))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warFile, "/opt/IBM/WebSphere/AppServer/profiles/AppSrv01/monitoredDeployableApps/servers/server1/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(webspherePid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/app/").forPort(9080).withStartupTimeout(Duration.ofMinutes(5)))
-            .withExposedPorts(9080)
-            .withPrivilegedMode(true);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.WebSphere;
-        List<String> supportedShellTypes = List.of(
-                ShellType.SERVLET,
-                ShellType.FILTER,
-                ShellType.LISTENER,
-                ShellType.WAS_AGENT_FILTER_MANAGER
-        );
-        List<Packers> testPackers = List.of(Packers.JSP);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        log.info(logs);
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.WebSphere, shellType, shellTool, Opcodes.V1_6, packer, container, python);
-    }
-
-    public static String getUrl(GenericContainer<?> container) {
-        String host = container.getHost();
-        int port = container.getMappedPort(9080);
-        String url = "http://" + host + ":" + port + "/app";
-        log.info("container started, app url is : {}", url);
-        return url;
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.SERVLET,
-            ShellType.FILTER,
-            ShellType.LISTENER,})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.WebSphere, shellType, Opcodes.V1_6);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/websphere/WebSphere905ContainerTest.java

@@ -1,95 +1,53 @@
 package com.reajason.javaweb.integration.memshell.websphere;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
 import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.time.Duration;
 import java.util.List;
-import java.util.stream.Stream;
-
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
 
 /**
  * @author ReaJason
  * @since 2024/12/21
  */
 @Testcontainers
-@Slf4j
-public class WebSphere905ContainerTest {
-    public static final String imageName = "reajason/websphere:9.0.5.17";
-    static Network network = Network.newNetwork();
+public class WebSphere905ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig.webSphere(
+            "reajason/websphere:9.0.5.17",
+            "/opt/IBM/WebSphere/AppServer/profiles/AppSrv01/monitoredDeployableApps/servers/server1/app.war")
+            .targetJdkVersion(Opcodes.V1_6)
+            .waitStrategy(Wait.forHttp("/app/").forPort(9080).withStartupTimeout(Duration.ofMinutes(5)))
+            .supportedShellTypes(List.of(
+                    ShellType.SERVLET,
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.WAS_AGENT_FILTER_MANAGER
+            ))
+            .testPackers(List.of(Packers.JSP))
+            .probeShellTypes(List.of(
+                    ShellType.SERVLET,
+                    ShellType.FILTER,
+                    ShellType.LISTENER
+            ))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warFile, "/opt/IBM/WebSphere/AppServer/profiles/AppSrv01/monitoredDeployableApps/servers/server1/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(webspherePid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/app/").forPort(9080).withStartupTimeout(Duration.ofMinutes(5)))
-            .withExposedPorts(9080)
-            .withPrivilegedMode(true);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.WebSphere;
-        List<String> supportedShellTypes = List.of(
-                ShellType.SERVLET,
-                ShellType.FILTER,
-                ShellType.LISTENER,
-                ShellType.WAS_AGENT_FILTER_MANAGER
-        );
-        List<Packers> testPackers = List.of(Packers.JSP);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        log.info(logs);
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.WebSphere, shellType, shellTool, Opcodes.V1_6, packer, container, python);
-    }
-
-    public static String getUrl(GenericContainer<?> container) {
-        String host = container.getHost();
-        int port = container.getMappedPort(9080);
-        String url = "http://" + host + ":" + port + "/app";
-        log.info("container started, app url is : {}", url);
-        return url;
-    }
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.SERVLET,
-            ShellType.FILTER,
-            ShellType.LISTENER,})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.WebSphere, shellType, Opcodes.V1_6);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/websphere7/WebSphere700ContainerTest.java

@@ -1,85 +1,49 @@
 package com.reajason.javaweb.integration.memshell.websphere7;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
 import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.time.Duration;
 import java.util.List;
-import java.util.stream.Stream;
-
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
 
 /**
  * @author ReaJason
  * @since 2024/12/21
  */
 @Testcontainers
-@Slf4j
-public class WebSphere700ContainerTest {
-    public static final String imageName = "reajason/websphere:7.0.0.21";
-    static Network network = Network.newNetwork();
+public class WebSphere700ContainerTest extends AbstractContainerTest {
+
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig
+            .webSphere(
+                    "reajason/websphere:7.0.0.21",
+                    "/opt/IBM/WebSphere/AppServer/profiles/AppSrv01/monitoredDeployableApps/servers/server1/app.war")
+            .targetJdkVersion(Opcodes.V1_6)
+            .waitStrategy(Wait.forHttp("/app/").forPort(9080).withStartupTimeout(Duration.ofMinutes(5)))
+            .supportedShellTypes(List.of(
+                    ShellType.SERVLET,
+                    ShellType.FILTER,
+                    ShellType.LISTENER
+            ))
+            .testPackers(List.of(Packers.JSP))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public final static GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warFile, "/opt/IBM/WebSphere/AppServer/profiles/AppSrv01/monitoredDeployableApps/servers/server1/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(webspherePid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/app/").forPort(9080).withStartupTimeout(Duration.ofMinutes(5)))
-            .withExposedPorts(9080)
-            .withPrivilegedMode(true);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.WebSphere;
-        List<String> supportedShellTypes = List.of(
-                ShellType.SERVLET,
-                ShellType.FILTER,
-                ShellType.LISTENER
-//                ShellType.WAS_AGENT_FILTER_MANAGER // fuck the env, java.lang.instrument.UnmodifiableClassException
-        );
-        List<Packers> testPackers = List.of(Packers.JSP);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        log.info(logs);
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.WebSphere, shellType, shellTool, Opcodes.V1_6, packer, container, python);
-    }
-
-    public static String getUrl(GenericContainer<?> container) {
-        String host = container.getHost();
-        int port = container.getMappedPort(9080);
-        String url = "http://" + host + ":" + port + "/app";
-        log.info("container started, app url is : {}", url);
-        return url;
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/wildfly/Wildfly18ContainerTest.java

@@ -1,85 +1,50 @@
 package com.reajason.javaweb.integration.memshell.wildfly;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
-
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
 
 /**
  * @author ReaJason
  * @since 2024/12/10
  */
-@Slf4j
 @Testcontainers
-public class Wildfly18ContainerTest {
-    public static final String imageName = "jboss/wildfly:18.0.1.Final";
-    static Network network = Network.newNetwork();
+public class Wildfly18ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig.undertow(
+            "jboss/wildfly:18.0.1.Final",
+            "/opt/jboss/wildfly/standalone/deployments/app.war")
+            .targetJdkVersion(Opcodes.V1_6)
+            .supportedShellTypes(List.of(
+                    ShellType.SERVLET,
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.UNDERTOW_AGENT_SERVLET_HANDLER
+            ))
+            .testPackers(List.of(Packers.JSP))
+            .probeShellTypes(List.of(
+                    ShellType.SERVLET,
+                    ShellType.FILTER,
+                    ShellType.LISTENER
+            ))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public static final GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warFile, "/opt/jboss/wildfly/standalone/deployments/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(jbossPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/app"))
-            .withExposedPorts(8080);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.Undertow;
-        List<String> supportedShellTypes = List.of(
-                ShellType.SERVLET,
-                ShellType.FILTER,
-                ShellType.LISTENER,
-                ShellType.UNDERTOW_AGENT_SERVLET_HANDLER
-        );
-        List<Packers> testPackers = List.of(Packers.JSP);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.Undertow, shellType, shellTool, Opcodes.V1_6, packer, container, python);
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = { ShellType.SERVLET,
-            ShellType.FILTER,
-            ShellType.LISTENER,})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.Undertow, shellType, Opcodes.V1_6);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/wildfly/Wildfly23ContainerTest.java

@@ -1,85 +1,50 @@
 package com.reajason.javaweb.integration.memshell.wildfly;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
-
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
 
 /**
  * @author ReaJason
  * @since 2024/12/10
  */
-@Slf4j
 @Testcontainers
-public class Wildfly23ContainerTest {
-    public static final String imageName = "jboss/wildfly:23.0.2.Final";
-    static Network network = Network.newNetwork();
+public class Wildfly23ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig.undertow(
+            "jboss/wildfly:23.0.2.Final",
+            "/opt/jboss/wildfly/standalone/deployments/app.war")
+            .targetJdkVersion(Opcodes.V1_6)
+            .supportedShellTypes(List.of(
+                    ShellType.SERVLET,
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.UNDERTOW_AGENT_SERVLET_HANDLER
+            ))
+            .testPackers(List.of(Packers.JSP))
+            .probeShellTypes(List.of(
+                    ShellType.SERVLET,
+                    ShellType.FILTER,
+                    ShellType.LISTENER
+            ))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public static final GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warFile, "/opt/jboss/wildfly/standalone/deployments/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(jbossPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/app"))
-            .withExposedPorts(8080);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.Undertow;
-        List<String> supportedShellTypes = List.of(
-                ShellType.SERVLET,
-                ShellType.FILTER,
-                ShellType.LISTENER,
-                ShellType.UNDERTOW_AGENT_SERVLET_HANDLER
-        );
-        List<Packers> testPackers = List.of(Packers.JSP);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.Undertow, shellType, shellTool, Opcodes.V1_6, packer, container, python);
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = { ShellType.SERVLET,
-            ShellType.FILTER,
-            ShellType.LISTENER,})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.Undertow, shellType, Opcodes.V1_6);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/wildfly/Wildfly26ContainerTest.java

@@ -1,85 +1,50 @@
 package com.reajason.javaweb.integration.memshell.wildfly;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
-
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
 
 /**
  * @author ReaJason
  * @since 2024/12/10
  */
-@Slf4j
 @Testcontainers
-public class Wildfly26ContainerTest {
-    public static final String imageName = "quay.io/wildfly/wildfly:26.1.3.Final-jdk11";
-    static Network network = Network.newNetwork();
+public class Wildfly26ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig.undertow(
+            "quay.io/wildfly/wildfly:26.1.3.Final-jdk11",
+            "/opt/jboss/wildfly/standalone/deployments/app.war")
+            .targetJdkVersion(Opcodes.V11)
+            .supportedShellTypes(List.of(
+                    ShellType.SERVLET,
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.UNDERTOW_AGENT_SERVLET_HANDLER
+            ))
+            .testPackers(List.of(Packers.JSP))
+            .probeShellTypes(List.of(
+                    ShellType.SERVLET,
+                    ShellType.FILTER,
+                    ShellType.LISTENER
+            ))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public static final GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warFile, "/opt/jboss/wildfly/standalone/deployments/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(jbossPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/app"))
-            .withExposedPorts(8080);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.Undertow;
-        List<String> supportedShellTypes = List.of(
-                ShellType.SERVLET,
-                ShellType.FILTER,
-                ShellType.LISTENER,
-                ShellType.UNDERTOW_AGENT_SERVLET_HANDLER
-        );
-        List<Packers> testPackers = List.of(Packers.JSP);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers);
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.Undertow, shellType, shellTool, Opcodes.V11, packer, container, python);
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = { ShellType.SERVLET,
-            ShellType.FILTER,
-            ShellType.LISTENER,})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.Undertow, shellType, Opcodes.V11);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/wildfly/Wildfly27ContainerTest.java

@@ -1,88 +1,55 @@
 package com.reajason.javaweb.integration.memshell.wildfly;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellTool;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
 
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
+import static com.reajason.javaweb.integration.ContainerTool.warJakartaFile;
 
 /**
  * @author ReaJason
  * @since 2024/12/10
  */
-@Slf4j
 @Testcontainers
-public class Wildfly27ContainerTest {
-    public static final String imageName = "quay.io/wildfly/wildfly:27.0.1.Final-jdk11";
-    static Network network = Network.newNetwork();
+public class Wildfly27ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig.undertow(
+            "quay.io/wildfly/wildfly:27.0.1.Final-jdk11",
+            "/opt/jboss/wildfly/standalone/deployments/app.war")
+            .warFile(warJakartaFile)
+            .targetJdkVersion(Opcodes.V11)
+            .supportedShellTypes(List.of(
+                    ShellType.JAKARTA_SERVLET,
+                    ShellType.JAKARTA_FILTER,
+                    ShellType.JAKARTA_LISTENER,
+                    ShellType.UNDERTOW_AGENT_SERVLET_HANDLER
+            ))
+            .testPackers(List.of(Packers.JSP))
+            .unSupportedShellTools(List.of(ShellTool.AntSword))
+            .probeShellTypes(List.of(
+                    ShellType.JAKARTA_SERVLET,
+                    ShellType.JAKARTA_FILTER,
+                    ShellType.JAKARTA_LISTENER
+            ))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public static final GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warJakartaFile, "/opt/jboss/wildfly/standalone/deployments/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(jbossPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/app"))
-            .withExposedPorts(8080);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.Undertow;
-        List<String> supportedShellTypes = List.of(
-                ShellType.JAKARTA_SERVLET,
-                ShellType.JAKARTA_FILTER,
-                ShellType.JAKARTA_LISTENER,
-                ShellType.UNDERTOW_AGENT_SERVLET_HANDLER
-        );
-        List<Packers> testPackers = List.of(Packers.JSP);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers,
-                null, List.of(ShellTool.AntSword) // AntSword not support jakarta
-        );
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.Undertow, shellType, shellTool, Opcodes.V11, packer, container, python);
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.JAKARTA_SERVLET,
-            ShellType.JAKARTA_FILTER,
-            ShellType.JAKARTA_LISTENER,})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.Undertow, shellType, Opcodes.V11);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/wildfly/Wildfly30ContainerTest.java

@@ -1,89 +1,55 @@
 package com.reajason.javaweb.integration.memshell.wildfly;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellTool;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
 
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
+import static com.reajason.javaweb.integration.ContainerTool.warJakartaFile;
 
 /**
  * @author ReaJason
  * @since 2024/12/10
  */
-@Slf4j
 @Testcontainers
-public class Wildfly30ContainerTest {
-    public static final String imageName = "quay.io/wildfly/wildfly:30.0.1.Final-jdk17";
-    static Network network = Network.newNetwork();
+public class Wildfly30ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig.undertow(
+            "quay.io/wildfly/wildfly:30.0.1.Final-jdk17",
+            "/opt/jboss/wildfly/standalone/deployments/app.war")
+            .warFile(warJakartaFile)
+            .targetJdkVersion(Opcodes.V17)
+            .supportedShellTypes(List.of(
+                    ShellType.JAKARTA_SERVLET,
+                    ShellType.JAKARTA_FILTER,
+                    ShellType.JAKARTA_LISTENER,
+                    ShellType.UNDERTOW_AGENT_SERVLET_HANDLER
+            ))
+            .testPackers(List.of(Packers.JSP))
+            .unSupportedShellTools(List.of(ShellTool.AntSword))
+            .probeShellTypes(List.of(
+                    ShellType.JAKARTA_SERVLET,
+                    ShellType.JAKARTA_FILTER,
+                    ShellType.JAKARTA_LISTENER
+            ))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public static final GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warJakartaFile, "/opt/jboss/wildfly/standalone/deployments/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(jbossPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/app"))
-            .withExposedPorts(8080);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.Undertow;
-        List<String> supportedShellTypes = List.of(
-                ShellType.JAKARTA_SERVLET,
-                ShellType.JAKARTA_FILTER,
-                ShellType.JAKARTA_LISTENER,
-                ShellType.UNDERTOW_AGENT_SERVLET_HANDLER
-        );
-        List<Packers> testPackers = List.of(Packers.JSP);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers,
-                null, List.of(ShellTool.AntSword) // AntSword not support jakarta
-        );
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        log.info(logs);
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.Undertow, shellType, shellTool, Opcodes.V17, packer, container, python);
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.JAKARTA_SERVLET,
-            ShellType.JAKARTA_FILTER,
-            ShellType.JAKARTA_LISTENER,})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.Undertow, shellType, Opcodes.V17);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/wildfly/Wildfly36ContainerTest.java

@@ -1,89 +1,55 @@
 package com.reajason.javaweb.integration.memshell.wildfly;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellTool;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
 
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
+import static com.reajason.javaweb.integration.ContainerTool.warJakartaFile;
 
 /**
  * @author ReaJason
  * @since 2024/12/10
  */
-@Slf4j
 @Testcontainers
-public class Wildfly36ContainerTest {
-    public static final String imageName = "quay.io/wildfly/wildfly:36.0.0.Final-jdk21";
-    static Network network = Network.newNetwork();
+public class Wildfly36ContainerTest extends AbstractContainerTest {
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig.undertow(
+            "quay.io/wildfly/wildfly:36.0.0.Final-jdk21",
+            "/opt/jboss/wildfly/standalone/deployments/app.war")
+            .warFile(warJakartaFile)
+            .targetJdkVersion(Opcodes.V21)
+            .supportedShellTypes(List.of(
+                    ShellType.JAKARTA_SERVLET,
+                    ShellType.JAKARTA_FILTER,
+                    ShellType.JAKARTA_LISTENER,
+                    ShellType.UNDERTOW_AGENT_SERVLET_HANDLER
+            ))
+            .testPackers(List.of(Packers.JSP))
+            .unSupportedShellTools(List.of(ShellTool.AntSword))
+            .probeShellTypes(List.of(
+                    ShellType.JAKARTA_SERVLET,
+                    ShellType.JAKARTA_FILTER,
+                    ShellType.JAKARTA_LISTENER
+            ))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public static final GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warJakartaFile, "/opt/jboss/wildfly/standalone/deployments/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(jbossPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/app"))
-            .withExposedPorts(8080);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.Undertow;
-        List<String> supportedShellTypes = List.of(
-                ShellType.JAKARTA_SERVLET,
-                ShellType.JAKARTA_FILTER,
-                ShellType.JAKARTA_LISTENER,
-                ShellType.UNDERTOW_AGENT_SERVLET_HANDLER
-        );
-        List<Packers> testPackers = List.of(Packers.JSP);
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers,
-                null, List.of(ShellTool.AntSword) // AntSword not support jakarta
-        );
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        log.info(logs);
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.Undertow, shellType, shellTool, Opcodes.V21, packer, container, python);
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {ShellType.JAKARTA_SERVLET,
-            ShellType.JAKARTA_FILTER,
-            ShellType.JAKARTA_LISTENER,})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.Undertow, shellType, Opcodes.V21);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }

integration-test/src/test/java/com/reajason/javaweb/integration/memshell/wildfly/Wildfly9ContainerTest.java

@@ -1,33 +1,18 @@
 package com.reajason.javaweb.integration.memshell.wildfly;
 
-import com.reajason.javaweb.Server;
-import com.reajason.javaweb.integration.ShellAssertion;
-import com.reajason.javaweb.integration.TestCasesProvider;
+import com.reajason.javaweb.integration.AbstractContainerTest;
+import com.reajason.javaweb.integration.ContainerTestConfig;
 import com.reajason.javaweb.memshell.ShellTool;
 import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.packer.Packers;
-import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
 import org.apache.commons.lang3.tuple.Triple;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 import java.util.List;
-import java.util.stream.Stream;
-
-import static com.reajason.javaweb.integration.ContainerTool.*;
-import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException;
-import static com.reajason.javaweb.integration.ShellAssertion.shellInjectIsOk;
-import static org.hamcrest.MatcherAssert.assertThat;
 
 /**
  * <a href="https://hub.docker.com/r/jboss/wildfly/tags">Wildfly - DockerHub</a>
@@ -36,59 +21,40 @@ import static org.hamcrest.MatcherAssert.assertThat;
  * @author ReaJason
  * @since 2024/12/10
  */
-@Slf4j
 @Testcontainers
-public class Wildfly9ContainerTest {
-    public static final String imageName = "jboss/wildfly:9.0.1.Final";
-    static Network network = Network.newNetwork();
+public class Wildfly9ContainerTest extends AbstractContainerTest {
+
+    private static final ContainerTestConfig CONFIG = ContainerTestConfig
+            .undertow(
+                    "jboss/wildfly:9.0.1.Final",
+                    "/opt/jboss/wildfly/standalone/deployments/app.war")
+            .targetJdkVersion(Opcodes.V1_6)
+            .supportedShellTypes(List.of(
+                    ShellType.SERVLET,
+                    ShellType.FILTER,
+                    ShellType.LISTENER,
+                    ShellType.UNDERTOW_AGENT_SERVLET_HANDLER
+            ))
+            .testPackers(List.of(Packers.JSP))
+            .unSupportedCases(List.of(
+                    Triple.of(ShellType.UNDERTOW_AGENT_SERVLET_HANDLER, ShellTool.AntSword, Packers.AgentJar)
+            ))
+            .probeShellTypes(List.of(
+                    ShellType.SERVLET,
+                    ShellType.FILTER,
+                    ShellType.LISTENER
+            ))
+            .build();
+
+    static Network network = newNetwork();
     @Container
-    public final static GenericContainer<?> python = new GenericContainer<>(new ImageFromDockerfile()
-            .withDockerfile(neoGeorgDockerfile))
-            .withNetwork(network);
+    public static final GenericContainer<?> python = buildPythonContainer(network);
+
     @Container
-    public static final GenericContainer<?> container = new GenericContainer<>(imageName)
-            .withCopyToContainer(warFile, "/opt/jboss/wildfly/standalone/deployments/app.war")
-            .withCopyToContainer(jattachFile, "/jattach")
-            .withCopyToContainer(jbossPid, "/fetch_pid.sh")
-            .withNetwork(network)
-            .withNetworkAliases("app")
-            .waitingFor(Wait.forHttp("/app"))
-            .withExposedPorts(8080);
+    public static final GenericContainer<?> container = buildContainer(CONFIG, network);
 
-    static Stream<Arguments> casesProvider() {
-        String server = Server.Undertow;
-        List<String> supportedShellTypes = List.of(
-                ShellType.SERVLET,
-                ShellType.FILTER,
-                ShellType.LISTENER,
-                ShellType.UNDERTOW_AGENT_SERVLET_HANDLER
-        );
-        List<Packers> testPackers = List.of(Packers.JSP);
-        List<Triple<String, String, Packers>> unSupportedCases = List.of(
-                Triple.of(ShellType.UNDERTOW_AGENT_SERVLET_HANDLER, ShellTool.AntSword, Packers.AgentJar)  // Request ClassNotFound in module
-        );
-        return TestCasesProvider.getTestCases(imageName, server, supportedShellTypes, testPackers, unSupportedCases);
-    }
-
-    @AfterAll
-    static void tearDown() {
-        String logs = container.getLogs();
-        log.info(logs);
-        assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
-    }
-
-    @ParameterizedTest(name = "{0}|{1}{2}|{3}")
-    @MethodSource("casesProvider")
-    void test(String imageName, String shellType, String shellTool, Packers packer) {
-        shellInjectIsOk(getUrl(container), Server.Undertow, shellType, shellTool, Opcodes.V1_6, packer, container, python);
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = { ShellType.SERVLET,
-            ShellType.FILTER,
-            ShellType.LISTENER,})
-    void testProbeInject(String shellType) {
-        String url = getUrl(container);
-        ShellAssertion.testProbeInject(url, Server.Undertow, shellType, Opcodes.V1_6);
+    @Override
+    protected ContainerTestConfig getConfig() {
+        return CONFIG;
     }
 }