void testGetDefaultPort() {
        // This test verifies that the handler returns the correct default HTTP port.
        assertEquals(Handler.DEFAULT_HTTP_PORT, handler.getDefaultPort(), "Default port should be 80 for HTTP.");
    }

    @Test
    void testOpenConnection_HttpProtocol_ReturnsNtlmHttpURLConnection() throws Exception {
        // This test ensures that for a standard HTTP URL, openConnection wraps the connection

# Middleware { #middleware }

You can add middleware to **FastAPI** applications.

A "middleware" is a function that works with every **request** before it is processed by any specific *path operation*. And also with every **response** before returning it.

* It takes each **request** that comes to your application.
* It can then do something to that **request** or run any needed code.

    /** String object indicating that {@link #line} is empty */
    protected static final String EMPTY = new String();

    /** {@link BufferedReader} */
    protected final BufferedReader reader;

    /** The line that has been read */
    protected String line = EMPTY;

    /**
     * Returns an {@link Iterable} that wraps a {@link LineIterator} for use in enhanced for-loops.
     *

 * <ul>
 * <li>{@link Experimental}: Indicates that this interface or its implementation
 * may still be evolving and could change in future versions.</li>
 * <li>{@link FunctionalInterface}: Denotes that this is a functional interface,
 * allowing implementations as lambda expressions or method references.</li>
 * <li>{@link Consumer}: Signifies that this type is intended to be implemented

          <sourcepath>doesnotexist</sourcepath>
          <!-- Note that we do need to build Javadoc for *some* class. Otherwise, we get an empty Javadoc jar, which the Sonatype repository manager rejects. To avoid that, we've introduced a dummy class. But we made it package-private so that no one can depend on it. That in turn forced us to configure Javadoc to show package-private APIs. -->
          <show>package</show>

    val c1 = factory.newConnection(pool, routeA1, 50L)

    // Running at time 50, the pool returns that nothing can be evicted until time 150.
    assertThat(pool.closeConnections(50L)).isEqualTo(100L)
    assertThat(pool.connectionCount()).isEqualTo(1)
    assertThat(c1.socket().isClosed).isFalse()

    // Running at time 60, the pool returns that nothing can be evicted until time 150.
    assertThat(pool.closeConnections(60L)).isEqualTo(90L)

        String actualUserName = ntlmRequest.getRemoteUser();

        // Assert: Verify that the returned user name is the expected one
        assertEquals(expectedUserName, actualUserName, "getRemoteUser should return the principal's name.");
    }

    /**
     * Test method for {@link NtlmHttpServletRequest#getUserPrincipal()}.
     * Verifies that the method returns the correct principal object.
     */
    @Test

## Wildcards { #wildcards }

It's also possible to declare the list as `"*"` (a "wildcard") to say that all are allowed.

But that will only allow certain types of communication, excluding everything that involves credentials: Cookies, Authorization headers like those used with Bearer Tokens, etc.

     * Test case for the encode method.
     * Verifies that the encode method of a concrete implementation is called
     * and interacts with the NdrBuffer as expected.
     * @throws NdrException if encoding fails.
     */
    @Test
    void testEncode() throws NdrException {
        // When
        ndrObject.encode(mockBuffer);

        // Then
        // Verify that our mock buffer had the expected method called.

/*! For license information please see redoc.standalone.js.LICENSE.txt */
!function(e,t){"object"==typeof exports&&"object"==typeof module?module.exports=t(require("null")):
...
```

That confirms that you are being able to serve static files from your app, and that you placed the static files for the docs in the correct place.

Now we can configure the app to use those static files for the docs.