private final ProgressListener progressListener;
    private final RequestBody delegate;

    public ProgressRequestBody(RequestBody delegate, ProgressListener progressListener) {
      this.delegate = delegate;
      this.progressListener = progressListener;
    }

    @Override
    public MediaType contentType() {
      return delegate.contentType();
    }

    @Override

    private final Configuration delegate;

    /**
     * Creates a delegating configuration that forwards calls to another configuration
     * @param delegate
     *            delegate to pass all non-overridden method calls to
     *
     */
    public DelegatingConfiguration(final Configuration delegate) {
        this.delegate = delegate;
    }

    /**
     * {@inheritDoc}
     *

     * @param context the CIFS context for configuration
     */
    public RdmaTransport(SmbTransportInternal delegate, CIFSContext context) {
        this.delegate = delegate;
        this.rdmaProvider = RdmaProviderFactory.getProvider(context.getConfig());
        this.bufferManager = new RdmaBufferManager(rdmaProvider);
        this.statistics = new RdmaStatistics();

                // release
                old.release(true);
            }
            if (this.delegate != null && this.delegateAcquired) {
                log.debug("Releasing delegate");
                this.delegateAcquired = false;
                this.delegate.release();
            }
        }
    }

    /**
     * @return tree connection with increased usage count
     */

    }
  }

  private class ProgressRequestBody(
    private val delegate: RequestBody,
    private val progressListener: ProgressListener,
  ) : RequestBody() {
    override fun contentType() = delegate.contentType()

    @Throws(IOException::class)
    override fun contentLength(): Long = delegate.contentLength()

    @Throws(IOException::class)
    override fun writeTo(sink: BufferedSink) {

          private final RequestBody delegate;

          public ProgressRequestBody(RequestBody delegate, ProgressListener progressListener) {
            this.delegate = delegate;
            this.progressListener = progressListener;
          }

          @Override public MediaType contentType() {
            return delegate.contentType();
          }

  }

  public void testPadEnd_null() {
    assertThrows(NullPointerException.class, () -> Strings.padEnd(null, 5, '0'));
  }

  @SuppressWarnings("InlineMeInliner") // test of method that doesn't just delegate
  public void testRepeat() {
    String input = "20";
    assertEquals("", Strings.repeat(input, 0));
    assertEquals("20", Strings.repeat(input, 1));
    assertEquals("2020", Strings.repeat(input, 2));

            private final FessConfig baseConfig = createBaseFessConfig();

            @Override
            public String getQueryDefaultQueryType() {
                return queryType;
            }

            // Delegate all other methods to base config
            @Override
            public String get(String key) {
                return baseConfig.get(key);
            }

            @Override

---

FastAPI è un web framework moderno e veloce (a prestazioni elevate) che serve a creare API con Python 3.6+ basato sulle annotazioni di tipo di Python.

Le sue caratteristiche principali sono:

* **Velocità**: Prestazioni molto elevate, alla pari di **NodeJS** e **Go** (grazie a Starlette e Pydantic). [Uno dei framework Python più veloci in circolazione](#performance).

        verify(mockResponse, never()).setStatus(any(int.class));
    }

    /**
     * Test case for the instance method doAuthentication.
     * It should just delegate to the static authenticate method.
     * @throws IOException
     */
    @Test
    public void testDoAuthentication() throws IOException {
        // Setup: No "Authorization" header to follow a simple path