* views are modifiable.
 *
 * <p>This class is not threadsafe when any concurrent operations update the multimap. Concurrent
 * read operations will work correctly. To allow concurrent update operations, wrap your multimap
 * with a call to {@link Multimaps#synchronizedSetMultimap}.
 *
 * <p><b>Warning:</b> Do not modify either a key <i>or a value</i> of a {@code LinkedHashMultimap}

        assertEquals(testData, new String(decompressed));
        // For small strings, gzip overhead might make compressed data larger
        // So we just verify that compression/decompression works correctly
        assertNotNull(compressed);
        assertTrue(compressed.length > 0);
    }

    // Helper methods for creating mock objects
    private SearchRequestParams createMockSearchRequestParams() {

///

#### Using `list`s instead of `set`s { #using-lists-instead-of-sets }

If you forget to use a `set` and use a `list` or `tuple` instead, FastAPI will still convert it to a `set` and it will work correctly:

{* ../../docs_src/response_model/tutorial006_py310.py hl[29,35] *}

## Recap { #recap }

        assertNotNull(securityDescriptor.getOwnerGroupSid());
        assertNull(securityDescriptor.getAces());
    }

    @Test
    @DisplayName("Test decode handles SACL offset correctly")
    void testDecodeHandlesSaclOffset() throws SMBProtocolDecodingException {
        // Prepare buffer with SACL offset (should be ignored)
        testBuffer[0] = 0x01; // revision
        testBuffer[1] = 0x00; // padding

        assertNotNull(groupIdsForParentLookup, "groupIdsForParentLookup should not be null");
    }

    /**
     * Test that scheduleParentGroupLookup uses TimeoutManager correctly.
     * This test verifies the method signature and can be called via reflection.
     */
    @Test
    public void test_scheduleParentGroupLookup_schedulesTask() throws Exception {

        } catch (NullPointerException e) {
            // Expected behavior
        }
    }

    @Test
    public void test_roundtrip_parsing() {
        // Test that parse(quoteEscape(x)) works correctly for simple values
        // Note: The implementation has a quirk where strings with escaped quotes don't get unquoted
        String[] simpleValues = { "simple", "", "no quotes or commas" };

        char[] testPassword = "CharArrayPass789!".toCharArray();
        NtlmPasswordAuthenticator auth = new NtlmPasswordAuthenticator("testuser", testPassword);

        // Verify password is stored correctly
        assertArrayEquals(testPassword, auth.getPasswordAsCharArray());
        assertEquals(new String(testPassword), auth.getPassword());

        // Verify that modifying original array doesn't affect stored password

        // Note: This IOCTL must be sent on an existing session
        // The actual sending would need integration with the session's transport
        // For now, we're preparing the request structure correctly

        // TODO: Integration point - send request through session.send()
        // Smb2IoctlResponse response = (Smb2IoctlResponse) session.send(request);
        // if (response.isSuccess()) {

   * of the function in [7.0, 10.0] is equivalent to the sum of the integrals of [7.0, 8.0], [8.0,
   * 9.0], [9.0, 10.0] (and so on), no matter what the function is. This guarantees that we handle
   * correctly requests of varying weight (permits), /no matter/ what the actual function is - so we
   * can tweak the latter freely. (The only requirement, obviously, is that we can compute its
   * integrals).
   *

When you don't use `Annotated` and instead use the **(old) default value style**, if you call that function without FastAPI in **other places**, you have to **remember** to pass the arguments to the function for it to work correctly, otherwise the values will be different from what you expect (e.g. `QueryInfo` or something similar instead of `str`). And your editor won't complain, and Python won't complain running that function, only when the operations inside error out.