FsctlPipeWaitRequest request = new FsctlPipeWaitRequest(pipeName, timeout);
        byte[] nameBytes = pipeName.getBytes(StandardCharsets.UTF_16LE);
        byte[] buffer = new byte[200];
        int offset = 50;

        // Execute
        int bytesEncoded = request.encode(buffer, offset);

        // Verify
        assertEquals(14 + nameBytes.length, bytesEncoded);

        // Check timeout value at offset

from fastapi import FastAPI, Query

app = FastAPI()


@app.get("/items/")
async def read_items(
    q: str | None = Query(
        default=None, min_length=3, max_length=50, pattern="^fixedquery$"
    ),
):
    results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
    if q:
        results.update({"q": q})

    @Test
    public void test_toString() {
        final SearchResult result = SearchResult.create().allRecordCount(100).queryTime(50).build();

        final String str = result.toString();
        assertNotNull(str);
        assertTrue(str.contains("allRecordCount=100"));
        assertTrue(str.contains("queryTime=50"));
    }

    /**
     * Test SearchResult with all fields populated.
     */
    @Test

    factory.close()
    peer.close()
  }

  @Test fun connectionsEvictedWhenIdleLongEnough() {
    val pool = factory.newConnectionPool()
    val c1 = factory.newConnection(pool, routeA1, 50L)

    // Running at time 50, the pool returns that nothing can be evicted until time 150.
    assertThat(pool.closeConnections(50L)).isEqualTo(100L)
    assertThat(pool.connectionCount()).isEqualTo(1)
    assertThat(c1.socket().isClosed).isFalse()

If one or more drives are offline at the start of a PutObject or NewMultipartUpload operation the object will have additional data
protection bits added automatically to provide the regular safety for these objects up to 50% of the number of drives.
This will allow normal write operations to take place on systems that exceed the write tolerance.

        assertEquals(0, ndrBuffer.length);
        assertSame(ndrBuffer, ndrBuffer.deferred);
    }

    @Test
    void testGetAndSetIndex() {
        ndrBuffer.setIndex(50);
        assertEquals(50, ndrBuffer.getIndex());
    }

    @Test
    void testGetCapacity() {
        assertEquals(buffer.length, ndrBuffer.getCapacity());

        NdrBuffer offsetBuffer = new NdrBuffer(buffer, 100);

        // Setup configuration with minimal timeouts for fast testing
        when(mockConfig.getNetbiosSoTimeout()).thenReturn(100); // Very short timeout
        when(mockConfig.getNetbiosRetryTimeout()).thenReturn(50); // Very short retry
        when(mockConfig.getNetbiosRetryCount()).thenReturn(1); // Single retry only
        when(mockConfig.getNetbiosLocalPort()).thenReturn(0);

            alias="item-query",
            title="Query string",
            description="Query string for the items to search in the database that have a good match",
            min_length=3,
            max_length=50,
            pattern="^fixedquery$",
            deprecated=True,
        ),
    ] = None,
):
    results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
    if q:
        results.update({"q": q})

            int result2 = request.encode(buffer2, 50);

            // Both should succeed independently
            assertTrue(result1 > 0);
            assertTrue(result2 > 0);

            // Verify headers in both buffers
            for (int i = 0; i < 8; i++) {
                assertEquals((byte) 0xFF, buffer1[i]);
                assertEquals((byte) 0xFF, buffer2[50 + i]);
            }
        }
    }

        }

        @Test
        @DisplayName("Should decode data correctly")
        void testDecode() throws SMBProtocolDecodingException {
            int length = 50;
            int result = testResponse.decode(testBuffer, 10, length);

            assertEquals(length, result);
            assertEquals(1, testResponse.getDecodeCallCount());