if (usingVarHandle != null) {
      return usingVarHandle;
    }

    try {
      /*
       * UnsafeByteArray uses Unsafe.getLong() in an unsupported way, which is known to cause
       * crashes on Android when running in 32-bit mode. For maximum safety, we shouldn't use
       * Unsafe.getLong() at all, but the performance benefit on x86_64 is too great to ignore, so

   * addresses, the output follows <a href="http://tools.ietf.org/html/rfc5952">RFC 5952</a> section
   * 4. The main difference is that this method uses "::" for zero compression, while Java's version
   * uses the uncompressed form (except on Android, where the zero compression is also done). The
   * other difference is that this method outputs any scope ID in the format that it was provided at

    // again with a different route.
    if (e is SSLHandshakeException) {
      // If the problem was a CertificateException from the X509TrustManager,
      // do not retry.
      if (e.cause is CertificateException) {
        return false
      }
    }
    if (e is SSLPeerUnverifiedException) {
      // e.g. a certificate pinning error.
      return false
    }

            when(parent.getLocator()).thenReturn(locator);
            when(locator.getURL()).thenReturn(new URL("file:/"));
            // Throw CIFSException with different cause
            CIFSException differentException = new CIFSException("different error");
            when(locator.getAddress()).thenThrow(differentException);

            // Act + Assert

        assertDoesNotThrow(() -> sidResolver.resolveSids(mockContext, testServerName, testSids, 2, 1));
    }

    // Test edge cases for getGroupMemberSids
    @Test
    void testGetGroupMemberSids_MaxRid() throws CIFSException {
        when(sidResolver.getGroupMemberSids(any(CIFSContext.class), anyString(), any(SID.class), eq(Integer.MAX_VALUE), anyInt()))

   */
  public void testLoadingExceptionWithCause() {
    Exception cause = new Exception();
    UncheckedExecutionException uee = new UncheckedExecutionException(cause);
    ExecutionException ee = new ExecutionException(cause);

    LoadingCache<Object, Object> cacheUnchecked =
        CacheBuilder.newBuilder().build(exceptionLoader(uee));

	case errUploadIDNotFound.Error():
		return errUploadIDNotFound
	case errFaultyDisk.Error():
		return errFaultyDisk
	case errFaultyRemoteDisk.Error():
		return errFaultyRemoteDisk
	case errFileCorrupt.Error():
		return errFileCorrupt
	case errUnexpected.Error():
		return errUnexpected
	case errDiskFull.Error():
		return errDiskFull
	case errVolumeNotFound.Error():
		return errVolumeNotFound

		dev := uint64(sys.Rdev) // May be int32 or uint32
		switch runtime.GOOS {
		case "aix":
			var major, minor uint32
			major = uint32((dev & 0x3fffffff00000000) >> 32)
			minor = uint32((dev & 0x00000000ffffffff) >> 0)
			h.Devmajor, h.Devminor = int64(major), int64(minor)
		case "linux":
			// Copied from golang.org/x/sys/unix/dev_linux.go.
			major := uint32((dev & 0x00000000000fff00) >> 8)

import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

/**
 * Security-focused test cases for NtlmPasswordAuthenticator to verify timing attack resistance.
 */
public class NtlmPasswordAuthenticatorTimingAttackTest {

    private static final int TIMING_ITERATIONS = 1000;

   * {@link #add(Object)} or {@link #pollFirstEntry}. This skeleton implementation correctly
   * delegates each of its operations to the appropriate methods of this {@code
   * ForwardingSortedMultiset}.
   *
   * <p>In many cases, you may wish to override {@link #descendingMultiset()} to return an instance
   * of a subclass of {@code StandardDescendingMultiset}.
   *
   * @since 15.0
   */