assertEquals("1", "trim", StringUtil.ltrim("zzzytrim", "xyz"));
        assertEquals("2", "", StringUtil.ltrim("xyz", "xyz"));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testRtrim() throws Exception {
        assertEquals("trim", StringUtil.rtrim("trimxxxx", "x"));
        assertEquals("", StringUtil.rtrim("xyz", "xyz"));

     *
     * @param text
     *            The text to trim
     * @return The resulting string
     */
    public static final String rtrim(final String text) {
        return rtrim(text, null);
    }

    /**
     * Removes the specified characters from the right side of the string.
     *
     * @param text
     *            The text to trim
     * @param trimText
     *            The characters to remove

                    }
                    if (pair.length == 2) {
                        String sortValue = pair[1].trim();
                        if (StringUtil.isBlank(sortValue) || "score".equals(sortValue)) {
                            sortValue = "score.desc";
                        }
                        return new Pair<>(pair[0].trim(), sortValue);
                    }

        for (final String path : paths) {
            if (StringUtil.isNotBlank(path) && !path.trim().startsWith("#")) {
                boolean flag = false;
                for (final String protocol : protocols) {
                    if (path.trim().startsWith(protocol.trim())) {
                        flag = true;
                        break;
                    }
                }

            final String[] keyValue = StringUtils.split(values[1], ":", 2);
            if (keyValue.length == 2) {
                list.add(new Pair<>(keyValue[0].trim(), keyValue[1].trim()));
            } else if (keyValue.length == 1) {
                list.add(new Pair<>(keyValue[0].trim(), StringUtil.EMPTY));
            } else {
                logger.warn("Unexpected value: value={}", s);
            }
        }));

                // Field separator
                fields.add(unquoteField(currentField.toString().trim()));
                currentField.setLength(0);
            } else {
                currentField.append(c);
            }
        }

        // Add last field
        fields.add(unquoteField(currentField.toString().trim()));

        return fields.toArray(new String[0]);
    }

    /**

            final DuplicateHostHelper duplicateHostHelper = ComponentUtil.getDuplicateHostHelper();

            // set urls
            split(urlsStr, "[\r\n]").of(stream -> stream.filter(StringUtil::isNotBlank).map(String::trim).distinct().forEach(urlValue -> {
                if (!urlValue.startsWith("#") && protocolHelper.isValidWebProtocol(urlValue)) {
                    final String u = duplicateHostHelper.convert(urlValue);

                        updater.write("# " + line);
                    }
                    continue;
                }

                inputs = m.group(1).trim().split(",");
                output = m.group(2).trim();

                if (inputs == null || output == null || inputs.length == 0) {
                    logger.warn("Failed to parse mapping: line={}, path={}", line, path);

        }

        // Verify content is valid JSON
        assertTrue("Content should start with {", contentNew.trim().startsWith("{"));
        assertTrue("Content should end with }", contentNew.trim().endsWith("}"));
        assertTrue("Content should be substantial", contentNew.length() > 100);

        // Verify it contains expected mapping fields

                        updater.write("# " + line);
                    }
                    continue;
                }

                final String input = m.group(1).trim();
                final String output = m.group(2).trim();

                if (input == null || output == null) {
                    logger.warn("Failed to parse stemmer override: line={}, path={}", line, path);