// we need to catch it to verify that pipe.close() was still called
            try {
                handle.close();
                fail("Expected IOException to be thrown");
            } catch (IOException e) {
                assertEquals("Handle close failed", e.getMessage());
            }

            verify(mockSmbPipeHandleInternal).close();

/** Unit test for {@link com.google.common.base.Verify}. */
@GwtCompatible
@NullUnmarked
public class VerifyTest extends TestCase {
  public void testVerify_simple_success() {
    verify(true);
  }

  public void testVerify_simple_failure() {
    assertThrows(VerifyException.class, () -> verify(false));
  }

  public void testVerify_simpleMessage_success() {
    verify(true, "message");
  }

import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.Mockito.clearInvocations;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoInteractions;
import static org.mockito.Mockito.when;

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;

stage/
.sia_temp/
config.json
node_modules/
mc.*
s3-check-md5*
xl-meta*
healing-*
inspect*.zip
200M*
hash-set
minio.RELEASE*
mc
nancy
inspects/*
.bin/
*.gz
docs/debugging/s3-verify/s3-verify
docs/debugging/xl-meta/xl-meta
docs/debugging/s3-check-md5/s3-check-md5
docs/debugging/hash-set/hash-set
docs/debugging/healing-bin/healing-bin
docs/debugging/inspect/inspect

func checkBucketAndObjectNames(ctx context.Context, bucket, object string) error {
	// Verify if bucket is valid.
	if !isMinioMetaBucketName(bucket) && s3utils.CheckValidBucketNameStrict(bucket) != nil {
		return BucketNameInvalid{Bucket: bucket}
	}
	// Verify if object is valid.
	if len(object) == 0 {
		return ObjectNameInvalid{Bucket: bucket, Object: object}
	}

            // Then
            assertNotNull(retrievedTransport);
            assertFalse(hasActiveTransports);
            verify(transportPool).getSmbTransport(context, TEST_HOST, DEFAULT_PORT, false, false);
            verify(transportPool).removeTransport(transport);
            verify(transportPool).close();
        }

        @Test
        @DisplayName("Should handle authentication workflow")

        assertEquals(mockNotifyInfo2, notifications.get(1));

        // Verify first notification
        FileNotifyInformation info1 = notifications.get(0);
        assertEquals(FileNotifyInformation.FILE_ACTION_ADDED, info1.getAction());
        assertEquals("test1.txt", info1.getFileName());

        // Verify second notification
        FileNotifyInformation info2 = notifications.get(1);

        // Verify that the wrap method was called exactly once
        verify(dcerpcSecurityProvider, times(1)).wrap(mockNdrBuffer);
    }

    @Test
    void testUnwrapMethodIsCalled() throws DcerpcException {
        // Test that the unwrap method can be called without throwing an exception
        dcerpcSecurityProvider.unwrap(mockNdrBuffer);

            // Verify input buffer offset (should be 0 when no input buffer)
            assertEquals(0, SMBUtil.readInt2(buffer, 72));

            // Verify input buffer length (should be 0 when no input buffer)
            assertEquals(0, SMBUtil.readInt4(buffer, 76));

            // Verify additional information
            assertEquals(0x12345678, SMBUtil.readInt4(buffer, 80));

            // Verify query flags

        MsrpcLsarOpenPolicy2 msrpcLsarOpenPolicy2 = new MsrpcLsarOpenPolicy2(server, access, mockPolicyHandle);

        // Then
        // Verify that the super constructor is called with correct arguments
        // Note: Directly verifying super constructor calls is not straightforward in JUnit/Mockito.
        // We verify the effects of the super constructor by checking the fields of the created object.

        // Assert object_attributes fields