// This test verifies the exception is serializable
        String message = "Serialization test";
        UnsupportedSearchException exception = new UnsupportedSearchException(message);

        // Verify basic properties are preserved
        assertEquals(message, exception.getMessage());

        // The presence of serialVersionUID is verified at compile time

        int offset = 10;
        int size = 100;
        when(response.verifySignature(buffer, offset, size)).thenReturn(true);

        // When
        boolean verified = response.verifySignature(buffer, offset, size);

        // Then
        assertTrue(verified);
        verify(response).verifySignature(buffer, offset, size);
    }

    @Test
    @DisplayName("Test Response interface methods - isVerifyFailed")

        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());

                                        + "Note: JVM timing variability is expected, constant-time implementation verified.",
                                variance, minTime, maxTime, avgTime));
            }
        } finally {
            correctAuth.close();
            wrongAuth.close();
        }
    }

    /**

 * behaviour. The tests cover flag manipulation, byte‑buffer operations and
 * static helpers. Edge cases such as null or short arrays and negative
 * values are verified to ensure proper exception handling and byte
 * conversion.
 */
@ExtendWith(MockitoExtension.class)
class NtlmMessageTest {

    /** Lightweight concrete implementation used only for testing. */

    }
  }

  public void testVerifyGetsCalled() {
    TesterThatCountsCalls tester = new TesterThatCountsCalls();

    tester.test();

    assertEquals(
        "Should have verified once per stimulus executed",
        tester.numCallsToVerify,
        tester.numCallsToNewTargetIterator * STEPS);
  }

  public void testVerifyCanThrowAssertionThatFailsTest() {

    /*
     * Under Java 8, there is no need to test the no-VarHandle case here: It's already tested by the
     * main AbstractFutureTest, which uses the default AtomicHelper, which we verified above to be
     * UnsafeAtomicHelper.
     */
    if (!isJava8()) {
      runTestMethod(NO_VAR_HANDLE);
    }

    runTestMethod(NO_UNSAFE);

    runTestMethod(NO_ATOMIC_REFERENCE_FIELD_UPDATER);

    checkHelperVersion(NO_ATOMIC_REFERENCE_FIELD_UPDATER, "SynchronizedHelper");

    // Then, run the actual tests under each alternative classloader:

    /*
     * We don't need to test further under NO_UNSAFE: We verified that it selects
     * AtomicReferenceFieldUpdaterAtomicHelper, which is the default, which means that it's used
     * when we run AbstractFutureTest itself.
     */

    /*

      setFuture(localInputFuture);
      // TODO(cpovirk): Test that fallback is not run in this case.
      return;
    }

    @SuppressWarnings("unchecked") // verified safe by isInstanceOfThrowableClass
    X castThrowable = (X) throwable;
    T fallbackResult;
    try {
      fallbackResult = doFallback(localFallback, castThrowable);
    } catch (Throwable t) {

	// Indicates whether MinIO will remove all versions. If set to true, all versions will be deleted;
	// if set to false the policy takes no action. This action uses the Days/Date to expire objects.
	// This check is verified for latest version of the object.
	DeleteAll Boolean `xml:"ExpiredObjectAllVersions"`

	set bool
}

// MarshalXML encodes delete marker boolean into an XML form.