.endTag(NAMESPACE, "version");
        }
        if ((coreExtension.getClassLoadingStrategy() != null)
                && !coreExtension.getClassLoadingStrategy().equals("self-first")) {
            serializer
                    .startTag(NAMESPACE, "classLoadingStrategy")
                    .text(coreExtension.getClassLoadingStrategy())
                    .endTag(NAMESPACE, "classLoadingStrategy");

Because **FastAPI** doesn't make any changes to a `Response` you return, you have to make sure its contents are ready for it.

For example, you cannot put a Pydantic model in a `JSONResponse` without first converting it to a `dict` with all the data types (like `datetime`, `UUID`, etc) converted to JSON-compatible types.

For those cases, you can use the `jsonable_encoder` to convert your data before passing it to a response:

    protected boolean existNextPage;

    /** Flag indicating whether there is a previous page available. */
    protected boolean existPrevPage;

    /** The record number of the first record on the current page (1-based). */
    protected long currentStartRecordNumber;

    /** The record number of the last record on the current page (1-based). */
    protected long currentEndRecordNumber;

    for (int i = 0; i < threadCount; i++) {
      futures.add(
          executor.submit(
              () -> {
                barrier.await();
                Integer first = graph.nodes().iterator().next();
                for (Integer node : graph.nodes()) {
                  Set<Integer> unused = graph.successors(node);
                }
                /*

        assertTrue(signingEnforced, "Should delegate signing enforced setting");
        assertTrue(ipcSigningEnforced, "Should delegate IPC signing enforced setting");
        assertTrue(firstExtendedSecurityCall, "First call should return true");
        assertFalse(secondExtendedSecurityCall, "Second call should return false");

        verify(mockDelegate).isEncryptionEnabled();
        verify(mockDelegate).isSigningEnabled();

// is its content MD5.
//
// # Multi-part Upload
//
// The ETag of an object does not correspond to its content MD5
// when the object is uploaded in multiple parts via the S3
// multipart API. Instead, S3 first computes a MD5 of each part:
//
//	 e1 := MD5(part-1)
//	 e2 := MD5(part-2)
//	...
//	 eN := MD5(part-N)
//
// Then, the ETag of the object is computed as MD5 of all individual

            assertEquals(DcerpcConstants.DCERPC_FIRST_FRAG | DcerpcConstants.DCERPC_LAST_FRAG, bindWithParams.getFlags(),
                    "Flags should be set for first and last fragment");

            // Verify private fields using reflection
            Field bindingField = DcerpcBind.class.getDeclaredField("binding");
            bindingField.setAccessible(true);

		})
	}
}

func TestKMSHandlersKeyStatus(t *testing.T) {
	adminTestBed, tearDown := setupKMSTest(t, true)
	defer tearDown()

	tests := []kmsTestCase{
		{
			name:   "create a first key root user",
			method: http.MethodPost,
			path:   kmsKeyCreatePath,
			query:  map[string]string{"key-id": "abc-test-key"},
			asRoot: true,

			wantStatusCode: http.StatusOK,
		},
		{

So, about the egg and the chicken, how do you call the first `async` function?

If you are working with **FastAPI** you don't have to worry about that, because that "first" function will be your *path operation function*, and FastAPI will know how to do the right thing.

    final CharMatcher trimmer;
    final boolean omitEmptyStrings;

    /**
     * Returns the first index in {@code toSplit} at or after {@code start} that contains the
     * separator.
     */
    abstract int separatorStart(int start);

    /**
     * Returns the first index in {@code toSplit} after {@code separatorPosition} that does not