a.set(0, 1.0);
    Thread t =
        newStartedThread(
            new CheckedRunnable() {
              @Override
              @SuppressWarnings("ThreadPriorityCheck") // doing our best to test for races
              public void realRun() {
                while (!a.compareAndSet(0, 2.0, 3.0)) {
                  Thread.yield();
                }
              }
            });

      assertThrows(IllegalArgumentException.class, () -> DoubleMath.fuzzyEquals(1, 2, tolerance));
    }
  }

  /*
   * We've split testFuzzyCompare() into multiple tests so that our internal Android test runner has
   * a better chance of completing each within its per-test-method timeout.
   */

  public void testFuzzyCompare0() {
    runTestFuzzyCompare(0);
  }

type bucket[K comparable, V any] struct {
	entries     map[K]*Entry[K, V]
	newestEntry time.Time
}

// noEvictionTTL - very long ttl to prevent eviction
const noEvictionTTL = time.Hour * 24 * 365 * 10

// because of uint8 usage for nextCleanupBucket, should not exceed 256.
// casting it as uint8 explicitly requires type conversions in multiple places
const numBuckets = 100

        .address.url.host
    ) {
      return true // This connection is a perfect match.
    }

    // At this point we don't have a hostname match. But we still be able to carry the request if
    // our connection coalescing requirements are met. See also:
    // https://hpbn.co/optimizing-application-delivery/#eliminate-domain-sharding
    // https://daniel.haxx.se/blog/2016/08/18/http2-connection-coalescing/

            when(mockLocator.getUNCPath()).thenReturn("\\localhost\share\newdir");
            when(mockLocator.getShare()).thenReturn("share");
            // Mock tree handle's getConfig() to return our mock config
            when(mockTreeHandle.getConfig()).thenReturn(mockConfig);
        }

        @Test
        void testMkdir() throws SmbException, CIFSException {
            // Arrange

        // Override connectHost to avoid actual network connection on retry
        doAnswer(invocation -> {
            SmbTreeHandleImpl handle = mock(SmbTreeHandleImpl.class);
            // Re-set the same tree to continue using our mock
            setTree(c, tree);
            return handle;
        }).when(c).connectHost(any(), anyString());

        // Execute send - should retry after transport error
        try {

---

<div style="text-align: left; direction: ltr;">"<strong>Netflix</strong> is pleased to announce the open-source release of our <strong>crisis management</strong> orchestration framework: <strong>Dispatch</strong>! [built with <strong>FastAPI</strong>]"</div>

    return (delegate != null) ? delegate.toArray() : Arrays.copyOf(requireElements(), size);
  }

  @CanIgnoreReturnValue
  @Override
  @SuppressWarnings("nullness") // b/192354773 in our checker affects toArray declarations
  public <T extends @Nullable Object> T[] toArray(T[] a) {
    if (needsAllocArrays()) {
      if (a.length > 0) {
        a[0] = null;
      }
      return a;
    }

      // but work beyond that must take at least one second
      assertTrue(afterBurst >= 1000);
    }
  }

  /**
   * This neat test shows that no matter what weights we use in our requests, if we push X amount of
   * permits in a cool state, where X = rate * timeToCoolDown, and we have specified a
   * timeToWarmUp() period, it will cost as the prescribed amount of time. E.g., calling

      // but work beyond that must take at least one second
      assertTrue(afterBurst >= 1000);
    }
  }

  /**
   * This neat test shows that no matter what weights we use in our requests, if we push X amount of
   * permits in a cool state, where X = rate * timeToCoolDown, and we have specified a
   * timeToWarmUp() period, it will cost as the prescribed amount of time. E.g., calling