}
        assertTrue(caught);
    }

    @Test
    public void test_nestedCause() {
        final IllegalArgumentException rootCause = new IllegalArgumentException("Invalid argument");
        final RuntimeException middleCause = new RuntimeException("Middle error", rootCause);
        final LlmException exception = new LlmException("Top level error", middleCause);

            if (logger.isDebugEnabled()) {
                logger.debug("Invalid query: {}", body.q, e);
            }
            throwValidationErrorApi(e.getMessageCode());
        } catch (final ResultOffsetExceededException e) {
            if (logger.isDebugEnabled()) {
                logger.debug("Invalid offset: {}", body.offset, e);
            }

    /**
     * Reads a 32-bit RID and constructs a SID from it.
     * @return the constructed SID object
     * @throws IOException if an I/O error occurs
     * @throws PACDecodingException if the SID data is invalid
     */
    public SID readId() throws IOException, PACDecodingException {
        final byte[] bytes = new byte[4];
        readFully(bytes);

        final byte[] sidBytes = new byte[8 + bytes.length];

        verify(signingDigest, times(1)).verify(testData, offset, length, extraPad, message);
    }

    @Test
    @DisplayName("Test verify method returns false for invalid signature")
    void testVerifyReturnsFalse() {
        // Arrange
        int offset = 0;
        int length = testData.length;
        int extraPad = 0;

        if (value != null) {
            try {
                boost = Float.parseFloat(value);
            } catch (final Exception e) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Invalid boost value, keeping current: value={}, error={}", value, e.getMessage());
                }
            }
        }
    }

    @Override
    public String getIndexingTarget(final String input) {

				Type:  clause.InnerJoin,
				Table: clause.Table{Name: "user"},
				Using: []string{"id"},
			},
			sql: "INNER JOIN `user` USING (`id`)",
		},
		{
			name: "Expression",
			join: clause.Join{
				// Invalid
				Type:  clause.LeftJoin,
				Table: clause.Table{Name: "user"},
				ON: clause.Where{
					Exprs: []clause.Expression{clause.Eq{clause.Column{Table: "user_info", Name: "user_id"}, clause.PrimaryColumn}},
				},

        assertEquals("(deny){group}group123", permissionHelper.decode("D2group123"));
    }

    @Test
    public void test_decode_withInvalidPrefixes() {
        assertEquals("invalid", permissionHelper.decode("invalid"));
        assertEquals("3guest", permissionHelper.decode("3guest"));
        assertEquals("Xguest", permissionHelper.decode("Xguest"));
        assertEquals("guest", permissionHelper.decode("guest"));

		}
		return true, nil
	case staticKeyPresent:
		if isPresent(EnvKMSSecretKey) && isPresent(EnvKMSSecretKeyFile) {
			return false, fmt.Errorf("kms: invalid configuration for static KMS key: '%s' and '%s' are present", EnvKMSSecretKey, EnvKMSSecretKeyFile)
		}
		return true, nil
	case kesPresent:
		if !isPresent(EnvKESEndpoint) {

                } else {
                    // This should not happen.
                    error("Invalid projects count: $seenProjectsCount != $enabledCount + $toEnableCount + $uncheckedCount")
                }
            }
        }
    }

    private fun projectS(num: Int) = if (num == 1) "project" else "projects"

    }

    @Override
    public int decode(byte[] buffer, int bufferIndex, int len) throws SMBProtocolDecodingException {
        if (len != 8) {
            throw new SMBProtocolDecodingException("Invalid durable handle V2 response length: " + len);
        }

        this.timeout100Ns = SMBUtil.readInt4(buffer, bufferIndex) & 0xFFFFFFFFL; // Timeout (4 bytes, 100-ns intervals, unsigned)