queryCommand.execute(queryContext, termQuery, 1.0f);
            fail("Should throw InvalidQueryException");
        } catch (InvalidQueryException e) {
            // Expected exception
            assertTrue(e.getMessage().contains("Unknown q:"));
        }
    }

    public void test_toLowercaseWildcard_enabled() {
        queryCommand.setLowercaseWildcard(true);

                throw e;
            } catch (final Exception e) {
                throw new SsoMessageException(
                        messages -> messages.addErrorsFailedToProcessSsoRequest(UserMessages.GLOBAL_PROPERTY_KEY, e.getMessage()),
                        "Failed to process metadata.", e);
            }
        })
                .orElseThrow(() -> new SsoMessageException(

    /**
     * Returns the message.
     *
     * @param messageCode
     *            Message code
     * @param args
     *            Arguments
     * @return Message
     */
    public static String getMessage(final String messageCode, final Object... args) {
        return getFormattedMessage(messageCode == null ? "" : messageCode, getSimpleMessage(messageCode, args));
    }

    /**

        if (statement == null) {
            return;
        }
        try {
            statement.close();
        } catch (final SQLException e) {
            logger.log(format("ECL0017", e.getMessage()), e);
        }
    }

    /**
     * Returns the result set.
     *
     * @param statement
     *            {@link Statement}. Must not be {@literal null}.
     * @return The result set.

 *       }
 *     });
 *   }
 *
 *   public void test() {
 *     SomeClass.foo();
 *     LogRecord firstRecord = handler.getStoredLogRecords().get(0);
 *     assertEquals("some message", firstRecord.getMessage());
 *   }
 * </pre>
 *
 * @author Kevin Bourrillion
 * @since 10.0
 */
@GwtCompatible
@NullMarked
public class TestLogHandler extends Handler {
  private final Object lock = new Object();

        if (resultSet == null) {
            return;
        }
        try {
            resultSet.close();
        } catch (final SQLException e) {
            logger.log(format("ECL0017", e.getMessage()), e);
        }
    }

    /**
     * Moves the result set to the next position.
     *
     * @param resultSet
     *            The result set. Must not be {@literal null}.

        try {
            SsoResponseType.valueOf("INVALID");
            fail("Expected IllegalArgumentException");
        } catch (IllegalArgumentException e) {
            // Expected exception
            assertTrue(e.getMessage().contains("INVALID"));
        }
    }

    public void test_valueOf_null() {
        // Test valueOf with null throws exception
        try {
            SsoResponseType.valueOf(null);

  <function>
    <description>Get a message from properties files.</description>
    <name>message</name>
    <function-class>org.codelibs.fess.taglib.FessFunctions</function-class>
    <function-signature>java.lang.String getMessage(java.lang.String, java.lang.String)</function-signature>
    <example>${fe:message("labels.foobar", "default value")}</example>
  </function>

  <function>
    <description>Check if user has a permission.</description>

            fail("Should throw IllegalArgumentException");
        } catch (IllegalArgumentException e) {
            assertEquals("The argument 'property' for message should not be null.", e.getMessage());
        }
    }

    /**
     * Test that assertPropertyNotNull does not throw exception for non-null input
     */
    public void test_assertPropertyNotNull_withNonNull() {

            if (logger.isDebugEnabled()) {
                logger.debug(e.getMessage(), e);
            }
            throwValidationErrorApi(e.getMessageCode());
        } catch (final ResultOffsetExceededException e) {
            if (logger.isDebugEnabled()) {
                logger.debug(e.getMessage(), e);
            }