if (url == null) {
            return null;
        }
        String convertedUrl = url;
        for (final Map.Entry<String, String> entry : convertMap.entrySet()) {
            convertedUrl = convertedUrl.replaceAll(entry.getKey(), entry.getValue());
        }
        return convertedUrl;
    }

    public void add(final String target, final String replacement) {
        if (target == null || replacement == null) {

     */
    @Override
    public void processUrl(final String url) {
        if (includeFilteringPattern != null) {
            addInclude(url.replaceAll(urlPattern, includeFilteringPattern));
        }
        if (excludeFilteringPattern != null) {
            addExclude(url.replaceAll(urlPattern, excludeFilteringPattern));
        }
    }

    public String getUrlPattern() {
        return urlPattern;
    }

        assertEquals(1, sortBuilders.size());
        logger.info("{} => {}", text, sortBuilders.get(0).toString());
        assertEquals(expect, sortBuilders.get(0).toString().replaceAll("[\s\n]", ""));
    }

    private QueryContext assertQueryBuilder(final Class<?> expectedClass, final String expectedQuery, final String text) throws Exception {

@GwtCompatible
@ElementTypesAreNonnullByDefault
abstract class CommonMatcher {
  public abstract boolean matches();

  public abstract boolean find();

  public abstract boolean find(int index);

  public abstract String replaceAll(String replacement);

  public abstract int end();

  public abstract int start();

  public void testGetKeyMatchesString() {
    for (StandardSystemProperty property : StandardSystemProperty.values()) {
      String fieldName = property.name();
      String expected = Ascii.toLowerCase(fieldName).replaceAll("_", ".");
      assertEquals(expected, property.key());
    }
  }

  public void testGetValue() {
    for (StandardSystemProperty property : StandardSystemProperty.values()) {

			prefix += "*"
		}

		pattern = prefix
	}

	if suffix != "" {
		if !strings.HasPrefix(suffix, "*") {
			suffix = "*" + suffix
		}

		pattern += suffix
	}

	pattern = strings.ReplaceAll(pattern, "**", "*")

	return pattern
}

// Rules - event rules
type Rules map[string]TargetIDSet

// Add - adds pattern and target ID.
func (rules Rules) Add(pattern string, targetID TargetID) {

    // GET /api/admin/log/file/{id}
    @Execute
    public StreamResponse get$file(final String id) {
        final String filename = new String(Base64.getDecoder().decode(id), StandardCharsets.UTF_8).replace("..", "").replaceAll("\\s", "");
        final String logFilePath = systemHelper.getLogFilePath();
        if (StringUtil.isNotBlank(logFilePath) && isLogFilename(filename)) {
            final Path path = Paths.get(logFilePath, filename);

        } else {
            value = escaped;
        }
        return value.replaceAll(escapedHighlightPre, highlightTagPre).replaceAll(escapedHighlightPost, highlightTagPost);
    }

    protected String removeHighlightTag(final String str) {
        return str.replaceAll(originalHighlightTagPre, StringUtil.EMPTY).replaceAll(originalHighlightTagPost, StringUtil.EMPTY);
    }

            QueryContext context) {
        assertEquals(query, context.getQueryBuilder().toString().replaceAll("\\s", ""));
        assertFieldLogs(fieldLogMap);
        assertHighlightedQueries(highlightedQuerySet);
        if (sorts != null) {
            assertEquals(sorts, context.sortBuilders().stream().map(s -> s.toString().replaceAll("\\s", "")).collect(Collectors.joining()));
        }
    }

                extention = strings[strings.length - 1];
            } else {
                filePrefix = name;
                extention = "";
            }
            filePrefix = filePrefix.replaceAll("\\p{Zs}", "_");
        } else {
            filePrefix = "none";
            extention = "";
        }
        File inputFile = null;
        File outputFile = null;
        try {