}
    }

    @Override
    public void send(ByteBuffer data, RdmaMemoryRegion region) throws IOException {
        if (state != RdmaConnectionState.ESTABLISHED && state != RdmaConnectionState.CONNECTED) {
            throw new IOException("Connection not established");
        }

        try {
            // In real implementation, this would send using DiSNI:

    public static final char MINUS_SIGN = '\u2212';

    /** FULLWIDTH HYPHEN-MINUS */
    public static final char FULLWIDTH_HYPHEN_MINUS = '\uFF0D';

    /** CENT SIGN */
    public static final char CENT_SIGN = '\u00A2';

    /** FULLWIDTH CENT SIGN */
    public static final char FULLWIDTH_CENT_SIGN = '\uFFE0';

    /** POUND SIGN */
    public static final char POUND_SIGN = '\u00A3';

You can use Pydantic's model configuration to `forbid` any `extra` fields:

{* ../../docs_src/request_form_models/tutorial002_an_py39.py hl[12] *}

If a client tries to send some extra data, they will receive an **error** response.

For example, if the client tries to send the form fields:

* `username`: `Rick`
* `password`: `Portal Gun`
* `extra`: `Mr. Poopybutthole`

        assertEquals(8192, config.getRdmaReadWriteThreshold(), "Default threshold should be 8KB");
        assertEquals(65536, config.getRdmaMaxSendSize(), "Default max send size should be 64KB");
        assertEquals(65536, config.getRdmaMaxReceiveSize(), "Default max receive size should be 64KB");
        assertEquals(255, config.getRdmaCredits(), "Default credits should be 255");
    }

    }

    @Override
    public boolean isAvailable() {
        return true; // TCP is always available
    }

    @Override
    public Set<RdmaCapability> getSupportedCapabilities() {
        // TCP fallback only supports send/receive
        return EnumSet.of(RdmaCapability.RDMA_SEND_RECEIVE);
    }

    @Override
    public RdmaConnection createConnection(InetSocketAddress remote, InetSocketAddress local) throws IOException {

 * multiplexing requests. It encapsulates a stream and some protocol
 * knowledge (provided by a concrete subclass) so that connecting,
 * disconnecting, sending, and receiving can be syncronized
 * properly. Apparatus is provided to send and receive requests
 * concurrently.
 */

public abstract class Transport implements Runnable {

    /**
     * Default constructor for Transport.
     */
    public Transport() {

            } catch (final IOException ioe) {
                this.state = 0;
                throw ioe;
            }
        }
    }

    /**
     * Send and receive a DCE/RPC message
     *
     * @param msg
     *            the message to send
     * @throws DcerpcException
     *            if there is a DCE/RPC protocol error
     * @throws IOException

        when(response.getService()).thenReturn("A:");
        when(response.isValidTid()).thenReturn(true);
        when(response.getTid()).thenReturn(1);
        when(session.send(any(), any())).thenReturn(response);
        when(config.isIpcSigningEnforced()).thenReturn(false);

        SmbTreeImpl tree = new SmbTreeImpl(session, "SHARE", "A:");
        tree.treeConnect(null, null);

If you open a GitHub Issue, here is our policy:

1.  It must be a bug/performance issue or a feature request or a build issue or
    a documentation issue (for small doc fixes please send a PR instead).
1.  Make sure the Issue Template is filled out.
1.  The issue should be related to the repo it is created in.

**Here's why we have this policy:** We want to focus on the work that benefits
the whole community, e.g., fixing bugs and adding features. Individual support

Also, the best approach was to use already existing standards.

So, before even starting to code **FastAPI**, I spent several months studying the specs for OpenAPI, JSON Schema, OAuth2, etc. Understanding their relationship, overlap, and differences.

## Design { #design }

Then I spent some time designing the developer "API" I wanted to have as a user (as a developer using FastAPI).