return new FunctionToCacheLoader<>(function);
  }

  /**
   * Returns a cache loader based on an <i>existing</i> supplier instance. Note that there's no need
   * to create a <i>new</i> supplier just to pass it in here; just subclass {@code CacheLoader} and
   * implement {@link #load load} instead.
   *

    void testGetNextResponse() {
        // When
        CommonServerMessageBlockResponse nextResponse = response.getNextResponse();

        // Then - should return null as no next response is set
        assertEquals(null, nextResponse);
    }

    @Test
    @DisplayName("Should handle prepare method correctly")
    void testPrepareMethod() {
        // Given

        assertFalse(cacheEntry.isComplete());

        // Step 3: Verify can cache directory listing
        assertTrue(directoryLeaseManager.canCacheDirectoryListing(directoryPath));

        // Step 4: Initially no cached listing
        assertNull(directoryLeaseManager.getCachedDirectoryListing(directoryPath));

        // Step 5: Simulate directory enumeration and update cache

                Arguments.of(DACL_SECURITY_INFORMATION | SACL_SECURITY_INFORMATION, "DACL and SACL"),
                Arguments.of(ALL_SECURITY_INFORMATION, "All security information"), Arguments.of(0x00000000, "No security information"),
                Arguments.of(0xFFFFFFFF, "All bits set"));
    }

    @Test
    @DisplayName("Test writeParametersWireFormat buffer boundary")

            assertNull(testRequest.getNext());
            assertEquals(0, nextRequest.getFlags() & SMB2_FLAGS_RELATED_OPERATIONS);
        }

        @Test
        @DisplayName("split should return null when no next request")
        void testSplitNoNext() {
            CommonServerMessageBlockRequest result = testRequest.split();
            assertNull(result);
        }
    }

    @Nested

        assertEquals("TEST_ja", readings.get(1));
        assertEquals("TEST_fr", readings.get(2));
    }

    @Test
    public void testConvertWithNoLanguages() throws IOException {
        // Test convert with no languages specified
        converter.init();
        String text = "test";
        String field = "content";

        List<String> readings = converter.convert(text, field);

        assertNotNull(readings);

            <![CDATA[
    /**
     * @deprecated this was unused and has no replacement, this method returns {@code null} now.
     */
    @Deprecated(since = "4.0.0")
    public String getMergeId() {
        return null;
    }

    /**
     * @deprecated this was unused and has no replacement, this method is a no-op now.
     */
    @Deprecated(since = "4.0.0")

        }

        /**
         * Commits the changes to the dictionary file.
         * If there is a pending new item, it is written to the file.
         *
         * @return The committed item, or null if no item was committed.
         * @throws DictionaryException if an I/O error occurs.
         */
        public StemmerOverrideItem commit() {
            isCommit = true;
            if (item != null && item.isUpdated()) {

* providers
* services
* injectables
* components

## **FastAPI** plug-ins { #fastapi-plug-ins }

Integrations and "plug-ins" can be built using the **Dependency Injection** system. But in fact, there is actually **no need to create "plug-ins"**, as by using dependencies it's possible to declare an infinite number of integrations and interactions that become available to your *path operation functions*.

  if (it == func->record->fdef().attr().end()) {
    status->status =
        InvalidArgument("Function '", func->record->fdef().signature().name(),
                        "' has no attr named '", attr_name, "'.");
    return;
  }
  status->status = MessageToBuffer(it->second, output_attr_value);
}

void TF_DeleteFunction(TF_Function* func) {
  if (func == nullptr) {
    return;