// Then
        assertEquals(42, capturedFileId[0], "Anonymous implementation should work correctly");
    }

    @Test
    @DisplayName("Should verify all known implementations")
    void testAllKnownImplementations() {
        // List of all known implementations of RequestWithFileId
        Class<?>[] implementations = { Smb2CloseRequest.class, Smb2QueryInfoRequest.class, Smb2SetInfoRequest.class,

          .build();

  /**
   * type → implementation. Inherently mutable interfaces and abstract classes are mapped to their
   * default implementations and are "new"d upon get().
   */
  private static final ConcurrentMap<Class<?>, Class<?>> implementations = Maps.newConcurrentMap();

  private static <T> void setImplementation(Class<T> type, Class<? extends T> implementation) {

- **Switch Expressions** - Optimized implementations using switch expressions for better performance
- **Sequenced Collections** - Full support for Java 21 sequenced collections API with dedicated utility methods
- **Performance Focused** - Optimized implementations for better runtime performance with reduced memory allocation

    }

    /**
     * Test multiple FileInformation implementations can coexist
     */
    @Test
    @DisplayName("Test multiple FileInformation implementations")
    void testMultipleFileInformationImplementations() {
        // Create different mock implementations
        FileInformation basicInfo = mock(FileInformation.class);

   * any {@code Entry} instances already retrieved from the entry set (this is
   * implementation-dependent). Furthermore, implementations are not required to support
   * modifications to the entry set at all, and the {@code Entry} instances themselves don't even
   * have methods for modification. See the specific implementation class for more details on how
   * its entry set handles modifications.
   *

   * any {@code Entry} instances already retrieved from the entry set (this is
   * implementation-dependent). Furthermore, implementations are not required to support
   * modifications to the entry set at all, and the {@code Entry} instances themselves don't even
   * have methods for modification. See the specific implementation class for more details on how
   * its entry set handles modifications.
   *

   * one of the predefined {@link Policies} or specify a custom implementation. Implementations must
   * be thread-safe.
   *
   * @since 13.0
   */
  public interface Policy {

    /**
     * Called when a potential deadlock is encountered. Implementations can throw the given {@code
     * exception} and/or execute other desired logic.
     *

        try {
            manager.process(null, null, null);
            assertTrue(manager.isProcessCalled());
        } catch (NullPointerException e) {
            // Expected for some implementations
        }
    }

    public void test_process_withStatusCodeSetting() throws IOException, ServletException {
        // Test setting different status codes

/**
 * Test suite for FileSystemInformation interface and its implementations
 */
class FileSystemInformationTest {

    @Mock
    private FileSystemInformation mockFileSystemInfo;

    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this);
    }

    /**
     * Test implementation class for FileSystemInformation interface
     */

 * </ul>
 *
 * <h3>Implementations</h3>
 *
 * <ul>
 *   <li>{@link ImmutableListMultimap}
 *   <li>{@link ImmutableSetMultimap}
 *   <li>Configure your own mutable multimap with {@link MultimapBuilder}
 *   <li>{@link LinkedListMultimap} (for one unusual kind of mutable {@code Multimap})
 * </ul>
 *
 * Guava contains a number of other multimap implementations, such as {@link ArrayListMultimap}. In