// Execute
        NtlmPasswordAuthentication result = ntlmSsp.doAuthentication(mockCifsContext, mockRequest, mockResponse, challenge);

        // Verify that the behavior is the same as calling the static method directly
        assertNull(result, "Authentication result should be null");
        verify(mockResponse).setHeader("WWW-Authenticate", "NTLM");

      this.original = original;
    }

    /*
     * These gymnastics are a little confusing. Basically this class has neither legacy nor
     * non-legacy behavior; it just needs to let the behavior of the backing converter shine
     * through. So, we override the correctedDo* methods, after which the do* methods should never
     * be reached.
     */

    @Override
    protected A doForward(B b) {

          //
          // If an exception is thrown by the subclass then we need to make sure that the service
          // notices and transitions to the FAILED state. We do it by calling notifyFailed directly
          // because the service does not monitor the state of the future so if the exception is not
          // caught and forwarded to the service the task would stop executing but the service would

    * PR [#294](https://github.com/tiangolo/fastapi/pull/294).

## 0.28.0

* Implement dependency cache per request.
    * This avoids calling each dependency multiple times for the same request.
    * This is useful while calling external services, performing costly computation, etc.

      decodeException.initCause(e);
      throw decodeException;
    }
  }

  /*
   * We move the static constants into this class so ProGuard can inline UnsignedLongs entirely
   * unless the user is actually calling a parse method.
   */
  private static final class ParseOverflowDetection {
    private ParseOverflowDetection() {}

    // calculated as 0xffffffffffffffff / radix

                }
                form.sort = sortValueSb.toString();
            }
        }
    }

    /**
     * Builds initial parameters for facet and geo search functionality
     * by calling buildInitParamMap for both parameter types.
     */
    protected void buildInitParams() {
        buildInitParamMap(viewHelper.getInitFacetParamMap(), Constants.FACET_QUERY, Constants.FACET_FORM);

`HTTPException` is a normal Python exception with additional data relevant for APIs.

Because it's a Python exception, you don't `return` it, you `raise` it.

    List<Object> result = doConcurrentGet(cache, "bar", count, startSignal);

    assertEquals(1, callCount.get());
    for (int i = 0; i < count; i++) {
      // doConcurrentGet alternates between calling getUnchecked and calling get, but an unchecked
      // exception thrown by the loader is always wrapped as an UncheckedExecutionException.
      assertThat(result.get(i)).isInstanceOf(UncheckedExecutionException.class);

    }

    @GwtIncompatible @J2ktIncompatible private static final long serialVersionUID = 0;
  }

  /**
   * Returns a supplier whose {@code get()} method synchronizes on {@code delegate} before calling
   * it, making it thread-safe.
   */
  @J2ktIncompatible
  public static <T extends @Nullable Object> Supplier<T> synchronizedSupplier(
      Supplier<T> delegate) {
    return new ThreadSafeSupplier<>(delegate);

   * @since 30.0
   */
  @J2ktIncompatible
  @GwtIncompatible // concurrency
  public static void awaitTerminationUninterruptibly(ExecutorService executor) {
    // TODO(cpovirk): We could optimize this to avoid calling nanoTime() at all.
    verify(awaitTerminationUninterruptibly(executor, Long.MAX_VALUE, NANOSECONDS));
  }

  /**
   * Invokes {@code executor.}{@link ExecutorService#awaitTermination(long, TimeUnit)