Make name lookup null-safe and add typed lookup overload

- TestcontainerRegistry.lookup(String): flip the equals direction so
  callers passing null get a null result instead of an NPE on a
  populated registry. The compared `containerDesc.name` is sourced from
  Testcontainer.name(), which by annotation rules cannot be null.
- TestcontainerRegistry.lookup(String, Class<T>): typed overload that
  casts the looked-up container to the requested type, throwing
  IllegalArgumentException if the registered container is not assignable
  to the requested type. Returns null if no container with the given
  name is registered.

Tests cover the null-name path on a populated registry, the typed-lookup
happy path including a missing-name null return, and the type-mismatch
throw path.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: haster

src/main/java/org/arquillian/testcontainers/TestcontainerRegistry.java

@@ -69,13 +69,35 @@ GenericContainer<?> lookupOrCreate(final Class<GenericContainer<?>> type, final
      */
     GenericContainer<?> lookup(final String name) {
         for (TestcontainerDescription containerDesc : this.containers) {
-            if (name.equals(containerDesc.name)) {
+            if (containerDesc.name.equals(name)) {
                 return containerDesc.instance;
             }
         }
         return null;
     }
 
+    /**
+     * Typed lookup by name. Throws {@link IllegalArgumentException} if a container with the given name is registered
+     * but its runtime type is not assignable to {@code type}.
+     *
+     * @param name the container name
+     * @param type the expected container type
+     *
+     * @return the container cast to {@code type}, or {@code null} if no container with the given name is registered
+     */
+    <T extends GenericContainer<?>> T lookup(final String name, final Class<T> type) {
+        final GenericContainer<?> container = lookup(name);
+        if (container == null) {
+            return null;
+        }
+        if (!type.isInstance(container)) {
+            throw new IllegalArgumentException(
+                    String.format("Container with name '%s' is of type %s, which is not assignable to %s",
+                            name, container.getClass().getName(), type.getName()));
+        }
+        return type.cast(container);
+    }
+
     /**
      * Lookup the container in the test container instances. If more than one container is found for the type or
      * qualifier, an {@link IllegalArgumentException} is thrown.

src/test/java/org/arquillian/testcontainers/TestcontainerRegistryTest.java

@@ -51,6 +51,37 @@ public void emptyNameLookupDoesNotMatchNamedContainers() throws Exception {
                 "Empty-string lookup should not return any registered container");
     }
 
+    @Test
+    public void lookupTreatsNullNameAsAbsent() throws Exception {
+        TestcontainerRegistry registry = new TestcontainerRegistry();
+        registry.lookupOrCreate(simpleType(), annotation("alphaFixture"), List.of());
+
+        Assertions.assertNull(registry.lookup((String) null));
+    }
+
+    @Test
+    public void typedLookupReturnsTypedContainer() throws Exception {
+        TestcontainerRegistry registry = new TestcontainerRegistry();
+        GenericContainer<?> alpha = registry.lookupOrCreate(simpleType(), annotation("alphaFixture"), List.of());
+
+        SimpleTestContainer typed = registry.lookup("alpha", SimpleTestContainer.class);
+        Assertions.assertSame(alpha, typed);
+        Assertions.assertNull(registry.lookup("missing", SimpleTestContainer.class));
+    }
+
+    @Test
+    public void typedLookupThrowsOnTypeMismatch() throws Exception {
+        TestcontainerRegistry registry = new TestcontainerRegistry();
+        registry.lookupOrCreate(simpleType(), annotation("alphaFixture"), List.of());
+
+        Assertions.assertThrows(IllegalArgumentException.class,
+                () -> registry.lookup("alpha", IncompatibleContainer.class));
+    }
+
+    /** Distinct {@link GenericContainer} subtype used to exercise the type-mismatch path on typed lookup. */
+    private static class IncompatibleContainer extends GenericContainer<IncompatibleContainer> {
+    }
+
     @SuppressWarnings("unchecked")
     private static Class<GenericContainer<?>> simpleType() {
         return (Class<GenericContainer<?>>) (Class<?>) SimpleTestContainer.class;