return rules.contains(rule);
        }

        public List<Rule> getRules() {
            return new ArrayList<>(rules);
        }

        public void clearRules() {
            rules.clear();
        }
    }

    /**
     * Test ResponseProcessor implementation
     */
    public static class TestResponseProcessor implements ResponseProcessor, Serializable {

   *
   * @throws UnsupportedOperationException always
   * @deprecated Unsupported operation.
   */
  @Deprecated
  @Override
  @DoNotCall("Always throws UnsupportedOperationException")
  public final void clear() {
    throw new UnsupportedOperationException();
  }

  /**
   * Guaranteed to throw an exception and leave the table unmodified.
   *
   * @throws UnsupportedOperationException always

     *
     * @param flag the flags to add
     */
    public final void addFlags(final int flag) {
        this.flags |= flag;
    }

    /**
     * Clears the specified flags from this message.
     *
     * @param flag the flags to clear
     */
    public final void clearFlags(final int flag) {
        this.flags &= ~flag;
    }

    /**
     * @return the mid
     */
    @Override

import org.codelibs.fess.unit.UnitFessTestCase;

public class ParameterUtilTest extends UnitFessTestCase {

    @Override
    public void setUp() throws Exception {
        super.setUp();
        FessProp.propMap.clear();
        FessConfig fessConfig = new FessConfig.SimpleImpl() {
            @Override
            public String getAppEncryptPropertyPattern() {
                return ".*password|.*key";
            }
        };

   *
   * @throws UnsupportedOperationException always
   * @deprecated Unsupported operation.
   */
  @Deprecated
  @Override
  @DoNotCall("Always throws UnsupportedOperationException")
  public final void clear() {
    throw new UnsupportedOperationException();
  }

  /**
   * Returns an {@code ImmutableList} containing the same elements, in the same order, as this
   * collection.
   *

             */

            if (this.socket != null) {
                this.socket.close();
                this.socket = null;
            }
            this.thread = null;
            this.responseTable.clear();
        }
    }

    @Override
    public void run() {
        try {
            while (this.thread == Thread.currentThread()) {

          ******@****.***ions = extensions
          if (!extensions.isValid()) {
            synchronized(this@RealWebSocket) {
              messageAndCloseQueue.clear() // Don't transmit any messages.
              close(1010, "unexpected Sec-WebSocket-Extensions in response header")
            }
          }

          // Process all web socket messages.

        String[] testOrigins = { "https://example.com", "https://test.example.com", "http://localhost:8080" };

        for (String origin : testOrigins) {
            processCalled = false;
            responseHeaders.clear();

            HttpServletRequest request = createMockRequest();
            HttpServletResponse response = createMockResponse();

            corsHandler.process(origin, request, response);

    multimap.put("a", 11);
    multimap.put("b", 2);
    multimap.put("c", 3);
    multimap.put("d", 4);
    multimap.put("e", 5);
    multimap.put("e", 55);

    multimap.keySet().tailSet("d").clear();
    assertEquals(ImmutableSet.of("a", "b", "c"), multimap.keySet());
    assertEquals(4, multimap.size());
    assertEquals(4, multimap.values().size());
    assertEquals(4, multimap.keys().size());
  }

        }

        return true;
    }

    /**
     * Deletes the scroll context associated with the given scroll ID.
     *
     * @param client the OpenSearch client used to clear the scroll context
     * @param scrollId the ID of the scroll context to be deleted; if null, no action is taken
     */
    public static void deleteScrollContext(final Client client, final String scrollId) {