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<DfsReferralData> drCap = ArgumentCaptor.forClass(DfsReferralData.class);
        ArgumentCaptor<String> pathCap = ArgumentCaptor.forClass(String.class);
        verify(locator).handleDFSReferral(drCap.capture(), pathCap.capture());

        assertSame(referral, drCap.getValue());
        assertEquals(req, pathCap.getValue());
        verifyNoMoreInteractions(locator);
    }

        ArgumentCaptor<String> shareCap = ArgumentCaptor.forClass(String.class);
        ArgumentCaptor<String> svcCap = ArgumentCaptor.forClass(String.class);
        verify(session).getSmbTree(shareCap.capture(), svcCap.capture());
        assertEquals(share, shareCap.getValue());
        assertEquals(svc, svcCap.getValue());
    }

    // Edge/invalid inputs: null or empty share/service cause IllegalArgumentException (mocked)

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

/**
 * Captures the actual type of {@code T}.
 *
 * @author Ben Yu
 */
abstract class TypeCapture<T> {

  /** Returns the captured type. */
  final Type capture() {
    Type superclass = getClass().getGenericSuperclass();

                fail("Expected IOException due to short-circuit");
            } catch (IOException expected) {
                // expected
            }

            // Assert captured request parameters
            verify(mockTree).send(cap.capture(), any(jcifs.internal.CommonServerMessageBlockResponse.class), any(RequestParam.class));
            jcifs.internal.smb1.com.SmbComReadAndX req = cap.getValue();

  /**
   * An object that can capture objects to be closed later, when a {@link ClosingFuture} pipeline is
   * done.
   */
  public static final class DeferredCloser {
    @RetainedWith private final CloseableList list;

    DeferredCloser(CloseableList list) {
      this.list = list;
    }

    /**
     * Captures an object to be closed when a {@link ClosingFuture} pipeline is done.

 */
public abstract class TypeParameter<T> extends TypeCapture<T> {

  final TypeVariable<?> typeVariable;

  protected TypeParameter() {
    Type type = capture();
    checkArgument(type instanceof TypeVariable, "%s should be a type variable.", type);
    this.typeVariable = (TypeVariable<?>) type;
  }

  @Override
  public final int hashCode() {

     * Thread that reads input stream data and buffers it for later retrieval.
     * Captures output from command execution with configurable line buffering.
     */
    protected static class InputStreamThread extends Thread {

        /** Buffered reader for input stream. */
        private BufferedReader br;

        /** List to store captured output lines. */
        private final List<String> list = new LinkedList<>();

func TestReadDir(t *testing.T) {
	var testResults []result

	// Setup and capture test results for empty directory.
	testResults = append(testResults, setupTestReadDirEmpty(t)...)
	// Setup and capture test results for directory with only files.
	testResults = append(testResults, setupTestReadDirFiles(t)...)
	// Setup and capture test results for directory with files and directories.

<!--- reproduce this bug. Include code to reproduce, if relevant -->
<!--- and make sure you have followed https://github.com/minio/minio/tree/release/docs/debugging to capture relevant logs -->

1.
2.
3.
4.

## Context
<!--- How has this issue affected you? What are you trying to accomplish? -->