// Assert: filter was invoked twice and we got the accepted one
        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

            // Give the writer thread time to process and set exception
            w.wait(100);
        }

        // Wait a bit more to ensure exception is captured
        Thread.sleep(100);

        // Act + Assert: checkException should throw the SmbException captured by the thread
        assertThrows(SmbException.class, w::checkException);

        // Stop the thread
        synchronized (w) {

        if (new TypeCapture<Entry<String, int[][]>>() {}.capture()
            .toString()
            .contains("java.util.Map.java.util.Map")) {
          CURRENT = JAVA8;
        } else {
          CURRENT = JAVA9;
        }
      } else if (new TypeCapture<int[]>() {}.capture() instanceof Class) {
        CURRENT = JAVA7;
      } else {
        CURRENT = JAVA6;
      }

		mustGetPutObjReader(t, bytes.NewReader([]byte("initial-value")),
			int64(len("initial-value")), "", ""), ObjectOptions{})
	if err != nil {
		t.Fatal(err)
	}

	// Get object info to capture the ETag
	objInfo, err := obj.GetObjectInfo(ctx, bucket, object, ObjectOptions{})
	if err != nil {
		t.Fatal(err)
	}
	existingETag := objInfo.ETag

	// Simulate read quorum failure by taking enough disks offline

        .head()
        .build()

    client.newCall(request).execute().use {
      assertEquals(204, it.code)
    }
  }

  @Test
  fun staleConnectionNotReusedForNonIdempotentRequest() {
    // Capture the connection so that we can later make it stale.
    var connection: RealConnection? = null
    client =
      client
        .newBuilder()
        .addNetworkInterceptor(
          Interceptor { chain ->

        ArgumentCaptor<NtlmPasswordAuthentication> authCaptor = ArgumentCaptor.forClass(NtlmPasswordAuthentication.class);
        verify(session).setAttribute(eq("NtlmHttpAuth"), authCaptor.capture());

        NtlmPasswordAuthentication capturedAuth = authCaptor.getValue();
        assertEquals("user", capturedAuth.getUsername());
        assertEquals("TEST_DOMAIN", capturedAuth.getUserDomain());

        assertEquals(42, read);

        // Verify we issued an SMB2 IOCTL
        ArgumentCaptor<Smb2IoctlRequest> captor = ArgumentCaptor.forClass(Smb2IoctlRequest.class);
        verify(tree).send(captor.capture(), any());
        assertNotNull(captor.getValue());
    }

    @Test
    @DisplayName("recv delegates to input.readDirect and returns its value")
    void testRecvDelegation() throws Exception {

func (dm *DRWMutex) lockBlocking(ctx context.Context, lockLossCallback func(), id, source string, isReadLock bool, opts Options) (locked bool) {
	restClnts, _ := dm.clnt.GetLockers()

	// Create lock array to capture the successful lockers
	locks := make([]string, len(restClnts))

	// Add total timeout
	ctx, cancel := context.WithTimeout(ctx, opts.Timeout)
	defer cancel()

        // Mock parserRequest and logger
        ParserRequest parserRequest = mock(ParserRequest.class);
        Logger logger = mock(Logger.class);

        // Capture error messages for debugging
        doAnswer(invocation -> {
                    System.err.println("[ERROR] " + invocation.getArgument(0));
                    return null;
                })

        // Close should have sent FindClose2 exactly once
        ArgumentCaptor<SmbComFindClose2> captor = ArgumentCaptor.forClass(SmbComFindClose2.class);
        verify(tree, times(1)).send(captor.capture(), any());
        assertNotNull(captor.getValue());

        // Tree handle is released after close
        verify(tree, atLeastOnce()).release();
    }

    @Test