Fix race condition in IsRunningStartupCheckStrategy with stale cached container state

IsRunningStartupCheckStrategy used container.getContainerInfo().getState() which returns stale cached state from the port-mapping check. If the container exits between the port-mapping check and the startup check, the stale 'running' state caused the startup check to pass prematurely, and the wait strategy would start on a crashed/removed container.

Fix by using the cached state as a hint (fast path) but verifying it with a single live Docker inspect. If the live inspect confirms the container is running, return success immediately. If it shows a different state (stale cache), fall through to rate-limited polling. If the live inspect fails/timeout (e.g., Docker unresponsive on slow CI), gracefully fall back to trusting the cached state as the best available information.

Also improve diagnostics:
- Include containerId in 'Container is removed' error message
- Handle NotFoundException gracefully when retrieving logs from a removed container during cleanup
- Wrap stop() in try-catch to prevent cleanup failures from suppressing the original ContainerLaunchException

Re-enable testCommandQuickExitFailure which was disabled due to this race, and add testQuickExitWithDifferentExitCode.

Author: vpelikh

core/src/main/java/org/testcontainers/containers/GenericContainer.java

@@ -495,7 +495,10 @@ private void tryStart() {
                 }
 
                 if (inspectContainerResponse == null) {
-                    throw new IllegalStateException("Wait strategy failed. Container is removed", e);
+                    throw new IllegalStateException(
+                        "Wait strategy failed. Container " + containerId + " is removed",
+                        e
+                    );
                 }
 
                 InspectContainerResponse.ContainerState state = inspectContainerResponse.getState();
@@ -538,14 +541,23 @@ private void tryStart() {
 
             if (containerId != null) {
                 // Log output if startup failed, either due to a container failure or exception (including timeout)
-                final String containerLogs = getLogs();
+                try {
+                    final String containerLogs = getLogs();
 
-                if (containerLogs.length() > 0) {
-                    logger().error("Log output from the failed container:\n{}", containerLogs);
-                } else {
-                    logger().error("There are no stdout/stderr logs available for the failed container");
+                    if (containerLogs.length() > 0) {
+                        logger().error("Log output from the failed container:\n{}", containerLogs);
+                    } else {
+                        logger().error("There are no stdout/stderr logs available for the failed container");
+                    }
+                } catch (NotFoundException e2) {
+                    logger().error("Could not retrieve logs for container {}: container not found", containerId);
+                }
+
+                try {
+                    stop();
+                } catch (Exception e2) {
+                    logger().debug("Failed to stop container {}", containerId, e2);
                 }
-                stop();
             }
 
             throw new ContainerLaunchException("Could not create/start container", e);

core/src/main/java/org/testcontainers/containers/startupcheck/IsRunningStartupCheckStrategy.java

@@ -11,13 +11,35 @@
  */
 public class IsRunningStartupCheckStrategy extends StartupCheckStrategy {
 
-    @SuppressWarnings("deprecation")
     @Override
+    @SuppressWarnings("deprecation")
     public boolean waitUntilStartupSuccessful(GenericContainer<?> container) {
-        // Optimization: container already has the initial "after start" state, check it first
-        if (checkState(container.getContainerInfo().getState()) == StartupStatus.SUCCESSFUL) {
-            return true;
+        InspectContainerResponse.ContainerState cachedState = container.getContainerInfo().getState();
+        StartupStatus cachedStatus = checkState(cachedState);
+
+        if (cachedStatus == StartupStatus.SUCCESSFUL) {
+            // Cached state shows the container as running/exited-success — verify with
+            // one live Docker inspect to detect stale state (e.g., container crashed
+            // between the port-mapping check and this startup check).
+            try {
+                if (
+                    checkStartupState(container.getDockerClient(), container.getContainerId()) ==
+                    StartupStatus.SUCCESSFUL
+                ) {
+                    return true;
+                }
+                // Live state doesn't match cached — container may have crashed.
+                // Fall through to full rate-limited polling.
+            } catch (Exception e) {
+                // Live inspect failed (e.g., Docker timeout on slow CI) — trust
+                // the cached state as the best available information.
+                return true;
+            }
+        } else if (cachedStatus == StartupStatus.FAILED) {
+            // Container already exited with a non-zero exit code
+            return false;
         }
+
         return super.waitUntilStartupSuccessful(container);
     }
 

core/src/test/java/org/testcontainers/containers/startupcheck/IsRunningStartupCheckStrategyTest.java

@@ -1,6 +1,5 @@
 package org.testcontainers.containers.startupcheck;
 
-import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 import org.testcontainers.TestImages;
 import org.testcontainers.containers.GenericContainer;
@@ -17,7 +16,6 @@ void testCommandQuickExitSuccess() {
     }
 
     @Test
-    @Disabled("This test can fail to throw an AssertionError if the container doesn't fail quickly enough")
     void testCommandQuickExitFailure() {
         try (GenericContainer container = new GenericContainer<>(TestImages.TINY_IMAGE).withCommand("/bin/false")) {
             assertThatThrownBy(container::start)
@@ -34,4 +32,16 @@ void testCommandStaysRunning() {
             container.start(); // should start with no Exception
         }
     }
+
+    @Test
+    void testQuickExitWithDifferentExitCode() {
+        try (
+            GenericContainer container = new GenericContainer<>(TestImages.TINY_IMAGE)
+                .withCommand("/bin/sh", "-c", "exit 42")
+        ) {
+            assertThatThrownBy(container::start)
+                .hasStackTraceContaining("Container startup failed")
+                .hasStackTraceContaining("Container did not start correctly");
+        }
+    }
 }

modules/postgresql/src/test/java/org/testcontainers/postgresql/PostgreSQLContainerTest.java

@@ -2,6 +2,7 @@
 
 import org.junit.jupiter.api.Test;
 import org.testcontainers.PostgreSQLTestImages;
+import org.testcontainers.containers.ContainerLaunchException;
 import org.testcontainers.db.AbstractContainerDatabaseTest;
 
 import java.sql.ResultSet;
@@ -11,6 +12,7 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatNoException;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
 class PostgreSQLContainerTest extends AbstractContainerDatabaseTest {
     static {
@@ -122,6 +124,21 @@ void testWithAdditionalUrlParamInJdbcUrl() {
         }
     }
 
+    @Test
+    void testContainerExitBeforeStartupCheck() {
+        // Regression test for #11860: verify that a PostgreSQLContainer which exits before/during
+        // startup produces a handled ContainerLaunchException from the startup check, not a
+        // suppressed or cascading error from cleanup (getLogs/stop throwing NotFoundException).
+        try (
+            PostgreSQLContainer postgres = new PostgreSQLContainer(PostgreSQLTestImages.POSTGRES_TEST_IMAGE)
+.withCommand("/bin/false")
+        ) {
+            assertThatThrownBy(postgres::start)
+                .isInstanceOf(ContainerLaunchException.class)
+                .hasStackTraceContaining("Container startup failed");
+        }
+    }
+
     private void assertHasCorrectExposedAndLivenessCheckPorts(PostgreSQLContainer postgres) {
         assertThat(postgres.getExposedPorts()).containsExactly(PostgreSQLContainer.POSTGRESQL_PORT);
         assertThat(postgres.getLivenessCheckPortNumbers())