void testDcerpcFaultInvalidTag() {
        assertEquals(0x1C000006, DcerpcError.DCERPC_FAULT_INVALID_TAG);
    }

    @Test
    @DisplayName("Should verify DCERPC_FAULT_CONTEXT_MISMATCH constant value")
    void testDcerpcFaultContextMismatch() {
        assertEquals(0x1C00001A, DcerpcError.DCERPC_FAULT_CONTEXT_MISMATCH);
    }

    @Test

        corsHandlerFactory.add(specificOrigin, specificHandler);
        corsHandlerFactory.add("*", wildcardHandler);

        // Execute & Verify - specific origin should return specific handler
        assertEquals(specificHandler, corsHandlerFactory.get(specificOrigin));

        // Execute & Verify - unknown origin should return wildcard handler
        assertEquals(wildcardHandler, corsHandlerFactory.get("https://unknown.com"));
    }

        // Verify the bytes written
        assertTrue(bytesWritten > 0);

        // Verify max setup count is written at position 0
        assertEquals(2, dst[0]);

        // Verify reserved bytes
        assertEquals(0, dst[1]);
        assertEquals(0, dst[2]);

        // Verify total parameter count (4 bytes at position 3)

        handle.release();

        // Assert: verify they happened in order
        InOrder inOrder = inOrder(handle);
        inOrder.verify(handle).ensureDFSResolved();
        inOrder.verify(handle).hasCapability(7);
        inOrder.verify(handle).release();
        inOrder.verifyNoMoreInteractions();
    }

    InOrder inOrder = inOrder(elementFunnel);
    inOrder.verify(elementFunnel).funnel("foo", primitiveSink);
    inOrder.verify(elementFunnel).funnel("bar", primitiveSink);
    inOrder.verify(elementFunnel).funnel("baz", primitiveSink);
    inOrder.verify(elementFunnel).funnel("quux", primitiveSink);
  }

  private static void assertNullsThrowException(Funnel<?> funnel) {

            verify(mockReferralData, atLeastOnce()).getPath();
            verify(mockReferralData, atLeastOnce()).next();
            verify(mockReferralData, atLeastOnce()).getKey();
            verify(mockReferralData, atLeastOnce()).isResolveHashes();
            verify(mockReferralData, atLeastOnce()).isIntermediate();
            verify(mockReferralData, atLeastOnce()).combine(any());

            inOrder.verify(mockCtx).isPreferredMech(any());
            inOrder.verify(mockCtx).getFlags();
            inOrder.verify(mockCtx).getSupportedMechs();
            inOrder.verify(mockCtx).supportsIntegrity();
            inOrder.verify(mockCtx).calculateMIC(any(byte[].class));
            inOrder.verify(mockCtx).verifyMIC(any(byte[].class), any(byte[].class));
            inOrder.verify(mockCtx).isMICAvailable();

        assertFalse(negotiationResponse.haveCapabilitiy(cap2));
        assertTrue(negotiationResponse.haveCapabilitiy(cap3));

        verify(negotiationResponse).haveCapabilitiy(cap1);
        verify(negotiationResponse).haveCapabilitiy(cap2);
        verify(negotiationResponse).haveCapabilitiy(cap3);
    }

    @Test
    @DisplayName("Test getSendBufferSize returns standard size")

verify: install-race ## verify minio various setups
	@echo "Verifying build with race"
	@(env bash $(PWD)/buildscripts/verify-build.sh)

verify-healing: install-race ## verify healing and replacing disks with minio binary
	@echo "Verify healing build with race"
	@(env bash $(PWD)/buildscripts/verify-healing.sh)
	@(env bash $(PWD)/buildscripts/verify-healing-empty-erasure-set.sh)

        assertTrue(ex.getMessage().contains("failure"));
        verify(session).getSessionKey();
    }

    // Happy path: transport is returned and verified
    @Test
    @DisplayName("getTransport returns mocked transport")
    void getTransport_happy() {
        when(session.getTransport()).thenReturn(transport);
        assertSame(transport, session.getTransport());
        verify(session).getTransport();
    }