steps:
      - name: Checkout
        uses: actions/checkout@v6

      - name: Configure JDK
        uses: actions/setup-java@v5
        with:
          distribution: 'zulu'
          java-version: 17

      - name: Setup Gradle
        uses: gradle/actions/setup-gradle@v5

      - name: Run Container Tests

        <constraint name="__context__" within="" contains="" />
        <constraint name="TYPE" within="" contains="" />
        <constraint name="ARR" nameOfExprType=".*\[\]" within="" contains="" />
        <constraint name="RES" nameOfExprType="boolean" exprTypeWithinHierarchy="true" within="" contains="" />
        <constraint name="ITEM" within="" contains="" />
        <constraint name="TARGET" within="" contains="" />
      </replaceConfiguration>

  public void testContains_yes() {
    assertTrue("contains(present) should return true", collection.contains(e0()));
  }

  public void testContains_no() {
    assertFalse("contains(notPresent) should return false", collection.contains(e3()));
  }

  @CollectionFeature.Require(ALLOWS_NULL_QUERIES)
  public void testContains_nullNotContainedButQueriesSupported() {
    assertFalse("contains(null) should return false", collection.contains(null));

            case FAMILY_ZOS -> actualOsName.contains(FAMILY_ZOS) || actualOsName.contains(FAMILY_OS390);
            case FAMILY_OS400 -> actualOsName.contains(FAMILY_OS400);
            case FAMILY_OPENVMS -> actualOsName.contains(FAMILY_OPENVMS);
            default -> actualOsName.contains(family.toLowerCase(Locale.US));
        };
    }

    /**
     * Helper method to determine the current OS family.
     *

        assertEquals(4, labels.size());
        assertTrue(labels.contains("a"), "Expected " + labels + " to contain " + "a");
        assertTrue(labels.contains("b"), "Expected " + labels + " to contain " + "b");
        assertTrue(labels.contains("c"), "Expected " + labels + " to contain " + "c");
        assertTrue(labels.contains("d"), "Expected " + labels + " to contain " + "d");

        addEdge(graph, "a", "d");

        // Test toString
        String toString = request1.toString();
        assertTrue(toString.contains("coordinates="), "Expected " + toString + " to contain " + "coordinates=");
        assertTrue(toString.contains("repositories="), "Expected " + toString + " to contain " + "repositories=");
    }

    @Test
    void testRequestTraceIntegration() {
        Session session = mock(Session.class);

import org.mockserver.proxyconfiguration.ProxyConfiguration
import org.mockserver.socket.tls.KeyStoreFactory
import org.testcontainers.containers.MockServerContainer
import org.testcontainers.junit.jupiter.Container
import org.testcontainers.junit.jupiter.Testcontainers

@Testcontainers
class BasicProxyTest {
  @Container
  val mockServer: MockServerContainer =
    MockServerContainer(MOCKSERVER_IMAGE)
      .withNetworkAliases("mockserver")

    assertThat(throwable).hasMessageThat().startsWith(NODE_STRING);
    assertThat(throwable).hasMessageThat().contains(ERROR_ELEMENT_NOT_IN_GRAPH);
  }

  static void assertEdgeNotInGraphErrorMessage(Throwable throwable) {
    assertThat(throwable).hasMessageThat().startsWith(EDGE_STRING);
    assertThat(throwable).hasMessageThat().contains(ERROR_ELEMENT_NOT_IN_GRAPH);
  }

  static void assertNodeRemovedFromGraphErrorMessage(Throwable throwable) {

        assertEquals(3, selectors.size());
        assertTrue(selectors.contains(":module-a"), "Expected selectors " + selectors + " to contain :module-a");
        assertTrue(selectors.contains(":module-b"), "Expected selectors " + selectors + " to contain :module-b");
        assertTrue(selectors.contains(":module-c"), "Expected selectors " + selectors + " to contain :module-c");
    }

    @Test

        }
        assertThat(
                graph.predecessors(node).contains(adjacentNode)
                    || graph.successors(node).contains(adjacentNode))
            .isTrue();
      }

      for (N predecessor : sanityCheckSet(graph.predecessors(node))) {
        assertThat(graph.successors(predecessor)).contains(node);
        assertThat(graph.hasEdgeConnecting(predecessor, node)).isTrue();