assertFalse(robotsTxt.allows("/temp", "EndPathBot"));
        assertTrue(robotsTxt.allows("/temporary", "EndPathBot"));
        assertTrue(robotsTxt.allows("/fishing", "EndPathBot"));

        // Test ComplexBot - complex patterns
        // Disallow: / but Allow: /$ (only root), Allow: /index.html$, Allow: /public/
        assertFalse(robotsTxt.allows("/about", "ComplexBot"));
        assertTrue(robotsTxt.allows("/", "ComplexBot")); // Allow: /$

        }
    }

    @Nested
    @DisplayName("Integration Tests")
    class IntegrationTests {

        @Test
        @DisplayName("Should handle complete lock request workflow")
        void testCompleteLockWorkflow() {
            // Setup complete request with multiple locks
            Smb2Lock[] locks = new Smb2Lock[] { new Smb2Lock(0L, 1024L, Smb2Lock.SMB2_LOCKFLAG_EXCLUSIVE_LOCK),

    schema_: Optional[Union[Schema, Reference]] = Field(default=None, alias="schema")
    example: Optional[Any] = None
    examples: Optional[dict[str, Union[Example, Reference]]] = None
    # Serialization rules for more complex scenarios
    content: Optional[dict[str, MediaType]] = None


class Parameter(ParameterBase):
    name: str
    in_: ParameterInType = Field(alias="in")


class Header(ParameterBase):
    pass

### Java Toolchain

The Gradle build uses [Java Toolchain](https://docs.gradle.org/current/userguide/toolchains.html) support to compile and execute tests across multiple versions of Java.

Available JDKs on your machine are automatically detected and wired for the various compile and test tasks.
Some tests require multiple JDKs to be installed on your computer, be aware of this if you make changes related to anything toolchains related.

            request.header("X-Header-" + i, "value" + i);
        }

        assertNotNull(request);
    }

    @Test
    public void testComplexFluentChaining() {
        // Test complex fluent chaining with various configurations
        CurlRequest request = new CurlRequest(Method.POST, "https://api.example.com/v1/users").encoding("UTF-8").threshold(2048).gzip()

But now you know how it works, so you can use relative imports in your own apps no matter how complex they are. 🤓

### Add some custom `tags`, `responses`, and `dependencies` { #add-some-custom-tags-responses-and-dependencies }

        // When no DACL is present, decode returns 0 based on the implementation
        assertEquals(0, size);
        assertNull(securityDescriptor.getAces());
    }

    @Test
    @DisplayName("Test decode with complex SID structure")
    void testDecodeWithComplexSid() throws SMBProtocolDecodingException {
        // Prepare buffer with multi-authority SID
        testBuffer[0] = 0x01; // revision
        testBuffer[1] = 0x00; // padding

        assertNotNull(keywords);
        assertEquals(0, keywords.size()); // No keywords because no fields match
    }

    @Test
    public void testGetKeywordsWithComplexQuery() {
        // Test with complex query structure
        String query = "(test AND query) OR (another AND search)";
        String[] fields = { "content" };
        List<String> keywords = SuggestUtil.getKeywords(query, fields);

You can use simple tools like `htop` to see the CPU and RAM used in your server or the amount used by each process. Or you can use more complex monitoring tools, which may be distributed across servers, etc.

## Recap { #recap }

   *       <ol>
   *         <li>When a thread attaches a listener to a {@code ListenableFuture} that's already
   *             complete, the listener runs immediately in that thread.
   *         <li>When a thread attaches a listener to a {@code ListenableFuture} that's
   *             incomplete and the {@code ListenableFuture} later completes normally, the