def test_read_items_non_int_item_id(client: TestClient):
    response = client.get("/items/invalid_id?q=somequery")
    assert response.status_code == 422, response.text
    assert response.json() == {
        "detail": [
            {
                "loc": ["path", "item_id"],
                "input": "invalid_id",
                "msg": "Input should be a valid integer, unable to parse string as an integer",

        void testIsValidTid() {
            // Given
            when(mockResponse.isValidTid()).thenReturn(true);

            // When
            boolean isValid = mockResponse.isValidTid();

            // Then
            assertTrue(isValid, "Should indicate valid TID");
            verify(mockResponse).isValidTid();
        }
    }

    /**
     * Tests for SMB2 implementation of TreeConnectResponse

        void testConstructorWithStringInvalidCharacter() {
            // Arrange
            String invalidUuid = "00112233-4455-6677-8899-AABBCCDDEXX"; // 'X' is invalid

            // Act & Assert
            assertThrows(IllegalArgumentException.class, () -> new UUID(invalidUuid),
                    "Should throw IllegalArgumentException for invalid character in UUID string");
        }

        @Test

        when(config.getPid()).thenReturn(1234);

        SmbComTreeConnectAndXResponse response = mock(SmbComTreeConnectAndXResponse.class);
        when(response.getService()).thenReturn("A:");
        when(response.isValidTid()).thenReturn(true);
        when(response.getTid()).thenReturn(1);
        when(session.send(any(), any())).thenReturn(response);
        when(config.isIpcSigningEnforced()).thenReturn(false);

    @Override
    public final boolean isShareDfs() {
        return this.shareIsInDfs;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.TreeConnectResponse#isValidTid()
     */
    @Override
    public boolean isValidTid() {
        return getTid() != 0xFFFF;
    }

    @Override
    protected int writeParameterWordsWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

        setTreeIdMethod.invoke(response, -1);
        assertFalse(response.isValidTid());

        // Test valid TID
        setTreeIdMethod.invoke(response, 100);
        assertTrue(response.isValidTid());

        // Test zero TID (valid)
        setTreeIdMethod.invoke(response, 0);
        assertTrue(response.isValidTid());
    }

    @Test
    @DisplayName("Should return null for getService")

     *
     * @see jcifs.internal.TreeConnectResponse#getTid()
     */
    @Override
    public final int getTid() {
        return getTreeId();
    }

    @Override
    public boolean isValidTid() {
        return getTreeId() != -1;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.TreeConnectResponse#getService()
     */
    @Override

     * @throws IOException
     */
    private void treeConnected(final SmbTransportImpl transport, final SmbSessionImpl sess, final TreeConnectResponse response)
            throws CIFSException {
        if (!response.isValidTid()) {
            throw new SmbException("TreeID is invalid");
        }
        this.tid = response.getTid();
        final String rsvc = response.getService();
        if (rsvc == null && !transport.isSMB2()) {

            return true;
        }
        if (!validateStringNotEmpty(prefix, fieldName, problems, severity, version, id, sourceHint, tracker)) {
            return false;
        } else {
            if (!isValidId(id)) {
                addViolation(
                        problems,
                        severity,
                        version,
                        prefix + fieldName,