public HashCode hashUnencodedChars(CharSequence input) {
    int len = input.length();
    ByteBuffer buffer = ByteBuffer.allocate(len * 2).order(ByteOrder.LITTLE_ENDIAN);
    for (int i = 0; i < len; i++) {
      buffer.putChar(input.charAt(i));
    }
    return hashBytes(buffer.array());
  }

  @Override
  public HashCode hashString(CharSequence input, Charset charset) {
    return hashBytes(input.toString().getBytes(charset));
  }

    @CanIgnoreReturnValue
    String consumeTokenIfPresent(CharMatcher matcher) {
      checkState(hasMore());
      int startPosition = position;
      position = matcher.negate().indexIn(input, startPosition);
      return hasMore() ? input.substring(startPosition, position) : input.substring(startPosition);
    }

    String consumeToken(CharMatcher matcher) {
      int startPosition = position;

  /** Puts a boolean into this sink. */
  @CanIgnoreReturnValue
  PrimitiveSink putBoolean(boolean b);

  /** Puts a character into this sink. */
  @CanIgnoreReturnValue
  PrimitiveSink putChar(char c);

  /**
   * Puts each 16-bit code unit from the {@link CharSequence} into this sink.
   *
   * <p><b>Warning:</b> This method will produce different output than most other languages do when

        // assertFalse(indexUpdater.isAlive());
    }

    // Test updateDocument with boost matcher
    public void test_updateDocument_withBoostMatcher() {
        final Map<String, Object> doc = new HashMap<>();
        doc.put("url", "http://example.com");

        final DocBoostMatcher matcher = new DocBoostMatcher() {
            @Override
            public boolean match(Map<String, Object> map) {

     *
     * @param path the file path to check
     * @return true if the path matches the pattern, false otherwise
     */
    protected boolean isTarget(final String path) {
        return pattern.matcher(path).find();
    }

    /**
     * Creates a new dictionary file instance for the given parameters.
     *
     * @param id the encoded identifier for the dictionary file

   * Returns a predicate that evaluates to {@code true} if the {@code CharSequence} being tested
   * contains any match for the given regular expression pattern. The test used is equivalent to
   * {@code Pattern.compile(pattern).matcher(arg).find()}
   *
   * @throws IllegalArgumentException if the pattern is invalid
   * @since 3.0
   */
  @GwtIncompatible // Only used by other GWT-incompatible code.

  /** Equivalent to {@code putByte(b ? (byte) 1 : (byte) 0)}. */
  @CanIgnoreReturnValue
  @Override
  Hasher putBoolean(boolean b);

  @CanIgnoreReturnValue
  @Override
  Hasher putChar(char c);

  /**
   * Equivalent to processing each {@code char} value in the {@code CharSequence}, in order. In
   * other words, no character encoding is performed; the low byte and high byte of each {@code

    This PR fixes a security issue where an IAM user based
    on his policy is granted more privileges than restricted
    by the users IAM policy.

    This is due to an issue of prefix based Matcher() function
    which was incorrectly matching prefix based on resource
    prefixes instead of exact match.
```

import java.util.Map;

import org.codelibs.fess.Constants;
import org.codelibs.fess.opensearch.config.exentity.BoostDocumentRule;
import org.codelibs.fess.util.ComponentUtil;

/**
 * A matcher class for applying document boost values based on configurable expressions.
 * This class evaluates match and boost expressions against document data to determine

        KerberosAuthData mockAuthData2 = mock(KerberosAuthData.class);

        // Mock the parse method to return two different objects based on input
        // Must use matchers for all arguments when using any matcher
        mockedStaticAuthData.when(() -> KerberosAuthData.parse(eq(1), eq(new byte[] { 0x01 }), any(Map.class)))
                .thenReturn(Collections.singletonList(mockAuthData1));