bus = new AsyncEventBus(executor);
  }

  public void testBasicDistribution() {
    StringCatcher catcher = new StringCatcher();
    bus.register(catcher);

    // We post the event, but our Executor will not deliver it until instructed.
    bus.post(EVENT);

    List<String> events = catcher.getEvents();
    assertTrue("No events should be delivered synchronously.", events.isEmpty());

        assertTrue(pattern.matcher("application/x-lha").matches());
        assertTrue(pattern.matcher("application/x-lha-compressed").matches());
    }

    @Test
    public void test_fsFileRulePattern_xmlTypes() {
        Pattern pattern = Pattern.compile(FS_FILE_RULE_PATTERN);
        assertTrue(pattern.matcher("application/xml").matches());

            final Matcher matcher = pattern.matcher(v.trim());
            if (matcher.matches()) {
                final PrunedTag tag = new PrunedTag(matcher.group(1));
                if (matcher.group(2) != null) {
                    final String attrPair = matcher.group(2).substring(1, matcher.group(2).length() - 1);

  }

  private static final class JdkMatcher extends CommonMatcher {
    final Matcher matcher;

    JdkMatcher(Matcher matcher) {
      this.matcher = Preconditions.checkNotNull(matcher);
    }

    @Override
    public boolean matches() {
      return matcher.matches();
    }

    @Override
    public boolean find() {
      return matcher.find();
    }

    @Override
    public boolean find(int index) {

        Matcher matcher = LINK_PATTERN.matcher(link);
        if (!matcher.matches()) {
            return null;
        }

        String className = null;
        if (matcher.group(1).length() > 0) {
            className = typeNameResolver.resolve(matcher.group(1), classMetaData);
            if (className == null) {
                return null;

    }

    /**
     * Creates a path matcher function for path mapping.
     *
     * @param matcher the regex matcher
     * @param replacement the replacement string
     * @return the path matcher function
     */
    public BiFunction<String, Matcher, String> createPathMatcher(final Matcher matcher, final String replacement) { // for PathMapping

            throw new IllegalStateException("Malformed distributionUrl line: " + distributionUrl);
        }
        String url = distributionUrl.substring(idx + 1).trim();

        Matcher m = WRAPPER_VERSION_EXTRACT.matcher(url);
        if (!m.matches()) {
            throw new IllegalStateException("Could not extract wrapper version from distributionUrl: " + url);
        }
        return m.group(1);
    }

        return Arrays.stream(values).map(s -> {
            final Matcher matcher = VERSION_PREFIX_PATTERN.matcher(s);
            if (!matcher.matches()) {
                return s;
            }
            final int v = Integer.parseInt(matcher.group(1));
            if ("-".equals(matcher.group(2))) {
                if (version >= v) {
                    return matcher.group(3);
                }
            } else if (v == version) {

    bitSet.clear(0);
    bitSet.clear(1);
    matcher = useNew ? CharMatcher.whitespace() : OLD_WHITESPACE;
    teststring = newTestString(new Random(1), bitSet, percentMatching);
  }

  @Benchmark
  public int countIn(int reps) {
    int result = 0;
    CharMatcher matcher = this.matcher;
    String teststring = this.teststring;
    for (int i = 0; i < reps; i++) {
      result += matcher.countIn(teststring);
    }
    return result;

    bitSet.clear(0);
    bitSet.clear(1);
    matcher = useNew ? CharMatcher.whitespace() : OLD_WHITESPACE;
    teststring = newTestString(new Random(1), bitSet, percentMatching);
  }

  @Benchmark
  public int countIn(int reps) {
    int result = 0;
    CharMatcher matcher = this.matcher;
    String teststring = this.teststring;
    for (int i = 0; i < reps; i++) {
      result += matcher.countIn(teststring);
    }
    return result;