//// tab | Python 3.8+ non-Annotated

/// tip

Prefer to use the `Annotated` version if possible.

///

```Python
commons: CommonQueryParams ...
```

////

...doesn't have any special meaning for **FastAPI**. FastAPI won't use it for data conversion, validation, etc. (as it is using the `Depends(CommonQueryParams)` for that).

You could actually write just:

//// tab | Python 3.8+

```Python

    @DisplayName("Test decode with various file names")
    @CsvSource({ "a.txt", "very_long_filename_with_many_characters_to_test_buffer_handling.docx", "file with spaces.pdf", "文件.txt", // Unicode filename
            "file-with-special-chars!@#$%^&().bin" })
    void testDecodeWithVariousFileNames(String fileName) throws SMBProtocolDecodingException {
        byte[] buffer = createValidNotificationBuffer(fileName, FileNotifyInformation.FILE_ACTION_ADDED);

            assertEquals(CLOCK_SEQ_LOW, uuid.clock_seq_low);
            assertArrayEquals(NODE, uuid.node);
        }

        @Test
        @DisplayName("Constructor should handle special boundary values")
        void testBoundaryValues() {
            // Arrange
            String boundaryUuid = "80000000-8000-8000-8080-808080808080";

            // Act

        ScriptEngine retrieved = scriptEngineFactory.getScriptEngine("TestScriptEngine");
        assertNotNull(retrieved);
        assertEquals(engine, retrieved);
    }

    // Test add with special characters in name
    public void test_add_specialCharactersInName() {
        TestScriptEngine engine = new TestScriptEngine();
        scriptEngineFactory.add("test-engine.v1", engine);

        verify(spy).getFileInformationLevel();
        verify(spy).size();
        verify(spy).encode(buffer, 0);
        verify(spy).decode(buffer, 0, 8);
        // Note: Cannot verify toString() with Mockito - it's a special method

        // Verify return values
        assertEquals(FileInformation.FILE_ENDOFFILE_INFO, level);
        assertEquals(8, size);
        assertEquals(8, encoded);
        assertEquals(8, decoded);

     * regrettable implementations like our own Sets.filter, Collection.size() is sometimes a
     * linear-time operation, and it can even have side effects. Thus, we limit the special case to
     * List, which is _even more likely_ to have size() implemented to be fast and side-effect-free.
     *
     * We could consider recognizing specific other collections as safe (like ImmutableCollection,

                }
            });
            return sessionIdList;
        });
    }

    /**
     * Generates a hashed ID from the provided URL ID string.
     * Encodes special characters using URL encoding or Base64 encoding as needed,
     * then applies a message digest algorithm to create a unique hash.
     *
     * @param urlId the URL ID string to generate a hash for

      unless required by applicable law (such as deliberate and grossly
      negligent acts) or agreed to in writing, shall any Contributor be
      liable to You for damages, including any direct, indirect, special,
      incidental, or consequential damages of any character arising as a
      result of this License or out of the use or inability to use the
      Work (including but not limited to damages for loss of goodwill,

   * {@code [1]} and {@code [1, 1]}).
   */
  // Note: 90% of the time we don't add type parameters or wildcards that serve only to "tweak" the
  // desired return type. However, *nested* generics introduce a special class of problems that we
  // think tip it over into being worthwhile.
  public static <T extends @Nullable Object, S extends T> Comparator<Iterable<S>> lexicographical(
      Comparator<T> comparator) {

///

* An optional `client_id` (we don't need it for our example).
* An optional `client_secret` (we don't need it for our example).

/// info

The `OAuth2PasswordRequestForm` is not a special class for **FastAPI** as is `OAuth2PasswordBearer`.

`OAuth2PasswordBearer` makes **FastAPI** know that it is a security scheme. So it is added that way to OpenAPI.