private static final class PrintingEventListener extends EventListener {
    private static final Factory FACTORY = new Factory() {
      final AtomicLong nextCallId = new AtomicLong(1L);

      @Override public EventListener create(Call call) {
        long callId = nextCallId.getAndIncrement();
        System.out.printf("%04d %s%n", callId, call.request().url());
        return new PrintingEventListener(callId, System.nanoTime());
      }
    };

   *
   * <p>When {@code maxSize} is zero, elements will be evicted immediately after being added to the
   * queue.
   */
  public static <E> EvictingQueue<E> create(int maxSize) {
    return new EvictingQueue<>(maxSize);
  }

  /**
   * Returns the number of additional elements that this queue can accept without evicting; zero if
   * the queue is currently full.
   *

    // we intercept the factory call.
    private MockedStatic<SmbTransport> smbtStatic;

    @BeforeEach
    void setUp() throws Exception {
        // Create a real NtlmPasswordAuthentication instance
        auth = new NtlmPasswordAuthentication("TESTDOMAIN", "testuser", "testpass");

        // Initialize ServerData to avoid NullPointerException

#### MINIO_DOMAIN

This is the top level domain name used for the federated setup. This domain name should ideally resolve to a load-balancer
running in front of all the federated MinIO instances. The domain name is used to create sub domain entries to etcd. For
example, if the domain is set to `domain.com`, the buckets `bucket1`, `bucket2` will be accessible as `bucket1.domain.com`
and `bucket2.domain.com`.

#### MINIO_PUBLIC_IPS

import gradlebuild.identity.provider.BuildTimestampValueSource
import gradlebuild.identity.tasks.BuildReceipt
import java.util.Optional

plugins {
    `java-base`
}

val gradleModule = extensions.create<GradleModuleExtension>(GradleModuleExtension.NAME).apply {
    published = false

    requiredRuntimes {
        client = false
        daemon = false
        worker = false
    }

    computedRuntimes {

   */
  @SuppressWarnings("UndefinedEquals")
  public void testRetainAllPropagatesToMultimap() {
    multimap().entries().retainAll(singleton(mapEntry(k0(), v0())));
    assertEquals(getSubjectGenerator().create(mapEntry(k0(), v0())), multimap());
    assertEquals(1, multimap().size());
    assertTrue(multimap().containsEntry(k0(), v0()));
  }

  @CollectionSize.Require(ONE)

    expectUnchanged();
  }

  @CollectionFeature.Require({SUPPORTS_REMOVE, ALLOWS_NULL_VALUES})
  @CollectionSize.Require(absent = ZERO)
  public void testRemove_nullPresent() {
    collection = getSubjectGenerator().create(createArrayWithNullElement());

    int initialSize = collection.size();
    assertTrue("remove(null) should return true", collection.remove(null));
    assertEquals(

    }

    /**
     * Creates a stream of map entries from the given map.
     *
     * @param <K> the type of keys in the map
     * @param <V> the type of values in the map
     * @param map the map to create a stream from; if {@code null}, an empty stream is returned
     * @return a {@link StreamOf} containing the entries of the map, or an empty stream if the map is {@code null}
     */

    @BeforeEach
    void setUp() {
        handler = new Handler(null);
    }

    @Nested
    @DisplayName("Constructor Tests")
    class ConstructorTests {

        @Test
        @DisplayName("Should create handler with null context")
        void testConstructorWithNullContext() {
            // When
            Handler testHandler = new Handler(null);

            // Then
            assertNotNull(testHandler);

        assert (str.startsWith("TransTransactNamedPipeResponse["));
        assert (str.endsWith("]"));
    }
}

// We need to add a helper method to TransTransactNamedPipeResponse to make the test more precise
// Or create a visible subclass for testing.
// For now, let's assume we can modify the original class slightly for testability,
// or we accept the less precise testToStringFormat test.