assertSame(referralData, unwrapped);
        }

        @Test
        @DisplayName("Should throw ClassCastException for incompatible type")
        void testUnwrapToIncompatibleType() {
            // Create a mock class that extends DfsReferralData but is not compatible
            class IncompatibleReferralData implements DfsReferralData {
                @Override

 *
 * @since 4.0.0
 */
@Experimental
public interface Parser {
    /**
     * Parses the given ParserRequest to create an {@link InvokerRequest}.
     * This method does interpret tool arguments.
     *
     * @param parserRequest the request containing all necessary information for parsing

        step4 = settings.getAsBoolean("step4", true);
        step5 = settings.getAsBoolean("step5", true);
        step6 = settings.getAsBoolean("step6", true);
    }

    @Override
    public TokenStream create(final TokenStream tokenStream) {
        return new FlexiblePorterStemFilter(tokenStream, step1, step2, step3, step4, step5, step6);
    }

        if (wordList != null) {
            stopTags.addAll(wordList);
        } else {
            stopTags.addAll(JapaneseAnalyzer.getDefaultStopTags());
        }
    }

    @Override
    public TokenStream create(TokenStream tokenStream) {
        return new JapanesePartOfSpeechStopFilter(tokenStream, stopTags);
    }

    /** Virtual address of the memory region */
    protected final long address;
    /** Flag indicating if the memory region is still valid */
    protected volatile boolean valid;

    /**
     * Create new RDMA memory region
     *
     * @param buffer memory buffer to register
     * @param access access permissions
     */
    public RdmaMemoryRegion(ByteBuffer buffer, EnumSet<RdmaAccess> access) {

                mode = JapaneseTokenizer.Mode.EXTENDED;
            }
        }
        return mode;
    }

    @Override
    public Tokenizer create() {
        JapaneseTokenizer t = new JapaneseTokenizer(userDictionary, discartPunctuation, mode);
        int nBestCost = this.nBestCost;
        if (nBestExamples != null) {

You can define this *startup* and *shutdown* logic using the `lifespan` parameter of the `FastAPI` app, and a "context manager" (I'll show you what that is in a second).

Let's start with an example and then see it in detail.

We create an async function `lifespan()` with `yield` like this:

{* ../../docs_src/events/tutorial003.py hl[16,19] *}

	if err != nil {
		writeCustomErrorResponseJSON(ctx, w, errorCodes.ToAPIErr(ErrInternalError), err.Error(), r.URL)
		return
	}
	writeSuccessResponseJSON(w, v)
}

// KMSCreateKeyHandler - POST /minio/kms/v1/key/create?key-id=<master-key-id>
func (a kmsAPIHandlers) KMSCreateKeyHandler(w http.ResponseWriter, r *http.Request) {
	// If env variable MINIO_KMS_SECRET_KEY is populated, prevent creation of new keys

for idx in {1..10}; do
	# generate random nr of blocks
	COUNT=$((RANDOM % 100 + 100))
	# generate random content
	dd if=/dev/urandom bs=50K count="${COUNT}" of="${SRC_DIR}"/file"$idx"
done

# create small object that will be inlined into xl.meta
dd if=/dev/urandom bs=50K count=1 of="${INLINED_DIR}"/inlined

if ./mc cp --quiet --recursive "${SRC_DIR}/" "${ALIAS_NAME}"/"${BUCKET}"/initial-data/; then

    private static final int BUF_SIZE = 4096;

    /**
     * Creates a {@link FileInputStream}.
     *
     * @param file the file (must not be {@literal null})
     * @return a {@link FileInputStream} to read from the file
     * @see FileInputStream#FileInputStream(File)
     */
    public static FileInputStream create(final File file) {
        assertArgumentNotNull("file", file);

        try {