assertNotNull(handle);
            ArgumentCaptor<MsrpcSamrConnect4> captor = ArgumentCaptor.forClass(MsrpcSamrConnect4.class);
            verify(mockHandle).sendrecv(captor.capture());
            assertEquals("\\\\", captor.getValue().system_name); // Verify server name in RPC call
        }
    }

    @Test

        ArgumentCaptor<SmbResource> captor = ArgumentCaptor.forClass(SmbResource.class);
        verify(filter, times(2)).accept(captor.capture());
        assertNotNull(r);
        assertTrue(r.getName().startsWith("TAKEME"));

        // The first filtered resource name should correspond to the rejected entry
        assertTrue(captor.getAllValues().get(0).getName().startsWith("SKIPME"));
    }

        // Assert: verify return and the captured argument equals input
        assertTrue(result);
        ArgumentCaptor<Integer> captor = ArgumentCaptor.forClass(Integer.class);
        verify(handle, times(1)).hasCapability(captor.capture());
        assertEquals(cap, captor.getValue());
    }

    @Test
    @DisplayName("hasCapability(cap): propagates CIFSException on failure")

        verify(locator).handleDFSReferral(referral, null);
        verifyNoMoreInteractions(locator);
    }

    // Interaction detail: capture arguments passed to handleDFSReferral
    @Test
    @DisplayName("handleDFSReferral receives the exact arguments via captor")
    void handleDfsReferralArgumentCapture() {
        when(locator.handleDFSReferral(any(), any())).thenReturn("ok");
        String req = "some/path";

    // Use ArgumentCaptor to capture the MsrpcSamrOpenDomain instance passed to sendrecv
    private ArgumentCaptor<MsrpcSamrOpenDomain> openDomainCaptor;
    // Use ArgumentCaptor to capture the MsrpcSamrCloseHandle instance passed to sendrecv
    private ArgumentCaptor<MsrpcSamrCloseHandle> closeHandleCaptor;

    @BeforeEach
    void setUp() {
        // Initialize mocks and captors before each test

        ArgumentCaptor<Integer> ntCaptor = ArgumentCaptor.forClass(Integer.class);
        verify(consumer, times(3)).accept(dosCaptor.capture(), ntCaptor.capture());
        assertIterableEquals(Arrays.asList(0x00000000, 0x00050001, 0x007b0001), dosCaptor.getAllValues());
        assertIterableEquals(Arrays.asList(0x00000000, 0xc0000022, 0xc0000033), ntCaptor.getAllValues());

            sink.writeUtf8(String.format(" * %s = %s\n", i, factor(i)));
          }
          sink.close();
        } catch (IOException | InterruptedException e) {
          e.printStackTrace();
        }
      }

      private String factor(int n) {
        for (int i = 2; i < n; i++) {
          int x = n / i;
          if (x * i == n) return factor(x) + " × " + i;
        }
        return Integer.toString(n);

            .where(
                new TypeCapture<Iterable<Map<?, V>>>() {}.capture(),
                new TypeCapture<Iterable<Map<String, Integer>>>() {}.capture());
    assertEquals(
        new TypeCapture<K>() {}.capture(), resolver.resolveType(new TypeCapture<K>() {}.capture()));
    assertEquals(Integer.class, resolver.resolveType(new TypeCapture<V>() {}.capture()));
  }

  public <T> void testWhere_mapFromWildcard() {

            .where(
                new TypeCapture<Iterable<Map<?, V>>>() {}.capture(),
                new TypeCapture<Iterable<Map<String, Integer>>>() {}.capture());
    assertEquals(
        new TypeCapture<K>() {}.capture(), resolver.resolveType(new TypeCapture<K>() {}.capture()));
    assertEquals(Integer.class, resolver.resolveType(new TypeCapture<V>() {}.capture()));
  }

  public <T> void testWhere_mapFromWildcard() {

        listener.start(String.format("class %s", classDoc.getName()));
        try {
            Element chapter = parent.getOwnerDocument().createElement("chapter");
            parent.appendChild(chapter);
            chapter.setAttribute("id", classDoc.getId());
            descriptionRenderer.renderTo(classDoc, chapter);
            merge(classDoc, chapter);
        } finally {
            listener.finish();
        }
    }