*
   * @throws IllegalArgumentException if subtype is invalid
   */
  static MediaType createApplicationType(String subtype) {
    return create(APPLICATION_TYPE, subtype);
  }

  /**
   * Creates a media type with the "audio" type and the given subtype.
   *
   * @throws IllegalArgumentException if subtype is invalid
   */
  static MediaType createAudioType(String subtype) {

    public void test_constructorWithMessageAndCause() {
        // Test constructor with message and cause
        String message = "Query parsing failed";
        Exception cause = new IllegalArgumentException("Invalid query syntax");

        SearchQueryException exception = new SearchQueryException(message, cause);

        assertEquals(message, exception.getMessage());
        assertEquals(cause, exception.getCause());

    public void test_process_withInvalidExpires() throws Exception {
        // Test that invalid expires value is handled
        Crawler.Options options = new Crawler.Options();
        options.sessionId = "test-session";
        options.expires = "invalid";

        // Verify the expires value is set even if invalid
        assertEquals("invalid", options.expires);
    }

    public void test_process_withName() throws Exception {

        CurlRequest request = new CurlRequest(Method.GET, "https://example.com");
        request.encoding("INVALID-ENCODING");

        try {
            request.param("key", "value");
            fail("Expected CurlException for invalid encoding");
        } catch (CurlException e) {
            assertTrue(e.getMessage().contains("Invalid encoding"));
        }
    }

    @Test
    public void testFluentChaining() {

     * @return an array containing [hour, minute]
     * @throws FessSystemException if the time format is invalid
     */
    protected static int[] parseTime(final String time) {
        final String[] froms = time.split(":");
        if (froms.length != 2) {
            throw new FessSystemException("Invalid format: " + time);
        }
        final int[] values = new int[2];
        values[0] = Integer.parseInt(froms[0]);

        // Create a path that's guaranteed to be invalid
        final File invalidParent = System.getProperty("os.name", "linux").toLowerCase().startsWith("windows")
                ? new File("Q:\\invalid\\path\\that\\does\\not\\exist")
                : new File("/invalid/path/that/does/not/exist");
        final File outputFile = new File(invalidParent, "output.txt");

      "SETTINGS",
      "PUSH_PROMISE",
      "PING",
      "GOAWAY",
      "WINDOW_UPDATE",
      "CONTINUATION",
    )

  /**
   * Lookup table for valid flags for DATA, HEADERS, CONTINUATION. Invalid combinations are
   * represented in binary.
   */
  private val FLAGS = arrayOfNulls<String>(0x40) // Highest bit flag is 0x20.
  private val BINARY =
    Array(256) {

            assertTrue(true);
        }
    }

    public void test_install_withInvalidZip() throws IOException {
        // Create an invalid zip file
        Path jarPath = tempDir.resolve("invalid.jar");
        Files.write(jarPath, "not a zip file".getBytes());

        ThemeHelper mockThemeHelper = new ThemeHelper() {
            @Override

    assertThat(wrappedSet).isEqualTo(copyOfWrappedSet);

    // test that setToTest is still valid
    assertThat(setToTest).isEqualTo(wrappedSet);
    assertThat(setToTest).isEqualTo(copyOfWrappedSet);

    // invalidate setToTest
    wrappedSet.remove(1);
    // sanity check on update of wrappedSet
    assertThat(wrappedSet).isNotEqualTo(copyOfWrappedSet);

  <jsp-config>
    <jsp-property-group>
      <url-pattern>*.jsp</url-pattern>
      <el-ignored>false</el-ignored>
      <page-encoding>UTF-8</page-encoding>
      <scripting-invalid>false</scripting-invalid>
      <include-prelude>/WEB-INF/view/common/common.jsp</include-prelude>
    </jsp-property-group>
  </jsp-config>