assertTrue(actual.contains(expectedContains), "toString should contain the 'addrEntry' part");
        assertTrue(actual.contains("192.168.1.1"), "toString should contain the first NbtAddress string representation");
        assertTrue(actual.contains("10.0.0.5"), "toString should contain the second NbtAddress string representation");
    }

    /**

 */
@Experimental
public interface VersionRange {
    /**
     * Determines whether the specified version is contained within this range.
     *
     * @param version the version to test, must not be {@code null}
     * @return {@code true} if this range contains the specified version, {@code false} otherwise
     */
    boolean contains(@Nonnull Version version);

    /**
     * Returns the upper boundary of this range, or {@code null} if none.

 *
 * <h4>Warnings</h4>
 *
 * <ul>
 *   <li><b>Warning:</b> as with any collection, it is almost always a bad idea to modify an element
 *       (in a way that affects its {@link Object#equals} behavior) while it is contained in a
 *       collection. Undefined behavior and bugs will result. It's generally best to avoid using
 *       mutable objects as elements at all, as many users may expect your "immutable" object to be

    assertTrue(
        "addAll(somePresent) should return true",
        collection.addAll(MinimalCollection.of(e3(), e0())));
    assertTrue("should contain " + e3(), collection.contains(e3()));
    assertTrue("should contain " + e0(), collection.contains(e0()));
  }

  @CollectionFeature.Require(absent = SUPPORTS_ADD)
  @CollectionSize.Require(absent = ZERO)
  public void testAddAll_unsupportedSomePresent() {

        assertTrue(result.startsWith("Trans2QueryPathInformation["), "String should start with the class name.");
        assertTrue(result.contains("informationLevel=0x101"), "String should contain the correct information level.");
        assertTrue(result.contains("filename=test.txt"), "String should contain the correct filename.");
        assertTrue(result.endsWith("]"), "String should end with a closing bracket.");
    }

  }

  // Graph copy methods

  /**
   * Returns the subgraph of {@code graph} induced by {@code nodes}. This subgraph is a new graph
   * that contains all of the nodes in {@code nodes}, and all of the {@link Graph#edges() edges}
   * from {@code graph} for which both nodes are contained by {@code nodes}.
   *
   * @throws IllegalArgumentException if any element in {@code nodes} is not a node in the graph
   */

  }

  // Graph copy methods

  /**
   * Returns the subgraph of {@code graph} induced by {@code nodes}. This subgraph is a new graph
   * that contains all of the nodes in {@code nodes}, and all of the {@link Graph#edges() edges}
   * from {@code graph} for which both nodes are contained by {@code nodes}.
   *
   * @throws IllegalArgumentException if any element in {@code nodes} is not a node in the graph
   */

                }
            });
            doSetupServerConfig(logger, props, "sameSiteCookies", value -> {
                for (final Container container : server.getHost().findChildren()) {
                    if (container instanceof final Context context
                            && context.getCookieProcessor() instanceof final CookieProcessorBase cookieProcessor) {

                System.clearProperty(FesenClient.HTTP_ADDRESS);
            }
        }
    }

    // Test destroy container
    public void test_destroyContainer() {
        // Test destroyContainer method - skip this test as it conflicts with container management
        // The test framework manages the container lifecycle
        assertTrue(true);
    }

    // Helper method to setup minimal mock components

      BiMap<V, K> inv = getMap().inverse();
      assertFalse(
          "Inverse should not contain entry " + reversed, inv.entrySet().contains(reversed));
      assertFalse(
          "Inverse should not contain key " + reversed.getKey(),
          inv.containsKey(reversed.getKey()));
      assertFalse(
          "Inverse should not contain value " + reversed.getValue(),
          inv.containsValue(reversed.getValue()));
      /*