Kerb5Authenticator auth = new Kerb5Authenticator(new Subject(), "DOM", "user", "pass");
        auth.setForceFallback(true);

        // Token advertising Kerberos mech (so foundKerberos == true), but forceFallback should still route to NTLM
        byte[] init = spnegoInitWithMechs(Kerb5Context.SUPPORTED_MECHS);

        // NtlmPasswordAuthenticator#createContext will inspect mechs and throw because NTLM is not advertised

        differences between them.


        Additionally, it's very useful to us if you can provide a "straw API" — what the
        method signatures would look like, for example, even if the method and class names are still
        in flux. This can make the feature you're suggesting much clearer to us.

  - type: textarea
    attributes:
      label: (Optional) What would the method signatures for your feature look like?
      placeholder: |

      if (activeTask == null && futureTasks.isEmpty()) {
        return CountDownLatch(0)
      }

      // If there's an existing AwaitIdleTask, use it. This is necessary when the executor is
      // shutdown but still busy as we can't enqueue in that case.
      val existingTask = activeTask
      if (existingTask is AwaitIdleTask) {
        return existingTask.latch
      }
      for (futureTask in futureTasks) {

    assertThrows(UncheckedTimeoutException.class, () -> proxy.sleepThenReturnInput("x"));

    assertThat(stopwatch.elapsed(MILLISECONDS)).isIn(Range.closed(NOT_ENOUGH_MS, DELAY_MS * 2));
    // Is it still computing away anyway?
    assertThat(target.finished).isFalse();
    MILLISECONDS.sleep(ENOUGH_MS);
    assertThat(target.finished).isFalse();
  }

        byte[] data = "Hello, World!".getBytes();
        ContentCache cache = new ContentCache(data);

        // Memory-based cache close should not throw exception
        cache.close();

        // Should still be able to get input stream after close for memory cache
        try (InputStream stream = cache.getInputStream()) {
            assertNotNull(stream);
        }
    }

    @Test

        // Test init method with null values
        AccessResultImpl<Long> result = new AccessResultImpl<>();

        result.init(null, null);

        // CreateTime should still be set
        assertNotNull(result.getCreateTime());

        // AccessResultData should be created
        assertNotNull(result.getAccessResultData());
    }

    public void test_toString() {

        DirectoryCacheEntry entry = directoryCache.get(directoryPath);

        // Check if cache entry is valid
        if (entry != null && entry.needsRefresh()) {
            // Check if lease is still valid
            LeaseManager.LeaseEntry leaseEntry = baseLeaseManager.getLease(entry.getLeaseKey());
            if (leaseEntry == null || !leaseEntry.hasReadCache()) {
                // Lease lost, remove cache entry

    // notifications for all of them.
    for (int i = 0; i < nSeededEntries; i++) {
      assertThat(removalNotifications.get("b" + i)).isEqualTo("b" + i);
    }

    // Each of the values added to the map should either still be there, or have seen a removal
    // notification.
    assertThat(Sets.union(cache.asMap().keySet(), removalNotifications.keySet()))
        .isEqualTo(expectedKeys);

       * timeoutFuture can be set (and delegate cancelled) only once. (And "set only once" is
       * important for other reasons: run() can still be invoked concurrently in different threads,
       * even with the above null checks.)
       */
      timeoutFutureRef = null;
      if (delegate.isDone()) {
        timeoutFuture.setFuture(delegate);

          // For convenience, testing only with big endianness, to match DataOutputStream.
          // I regard highly unlikely that both the little endianness tests above and this one
          // passes, and there is still a little endianness bug lurking around.
        }
      }

      Control control = new Control();
      Hasher controlSink = control.newHasher(1024);

      Iterable<Hasher> sinksAndControl =