*
 * @author Adomas Paltanavicius
 */
@NullUnmarked
public class JoinerBenchmark {

  private static final String DELIMITER_STRING = ",";
  private static final char DELIMITER_CHARACTER = ',';

  private static final Joiner JOINER_ON_STRING = Joiner.on(DELIMITER_STRING);
  private static final Joiner JOINER_ON_CHARACTER = Joiner.on(DELIMITER_CHARACTER);

  @Param({"3", "30", "300"})

    Map<Class<?>, Class<?>> wrapToPrim = new LinkedHashMap<>(16);

    add(primToWrap, wrapToPrim, boolean.class, Boolean.class);
    add(primToWrap, wrapToPrim, byte.class, Byte.class);
    add(primToWrap, wrapToPrim, char.class, Character.class);
    add(primToWrap, wrapToPrim, double.class, Double.class);
    add(primToWrap, wrapToPrim, float.class, Float.class);
    add(primToWrap, wrapToPrim, int.class, Integer.class);

	switch t {
	case scanner.EOF:
		return "EOF"
	case scanner.Ident:
		return "identifier"
	case scanner.Int:
		return "integer constant"
	case scanner.Float:
		return "float constant"
	case scanner.Char:
		return "rune constant"
	case scanner.String:
		return "string constant"
	case scanner.RawString:
		return "raw string constant"
	case scanner.Comment:
		return "comment"
	default:

        this.metaDataRepository = metaDataRepository;
        primitiveTypes.add("boolean");
        primitiveTypes.add("byte");
        primitiveTypes.add("char");
        primitiveTypes.add("short");
        primitiveTypes.add("int");
        primitiveTypes.add("long");
        primitiveTypes.add("float");
        primitiveTypes.add("double");
        primitiveTypes.add("void");

        radix);
    if (x == 0) {
      // Simply return "0"
      return "0";
    } else if (x > 0) {
      return Long.toString(x, radix);
    } else {
      char[] buf = new char[64];
      int i = buf.length;
      if ((radix & (radix - 1)) == 0) {
        // Radix is a power of two so we can avoid division.
        int shift = Integer.numberOfTrailingZeros(radix);

        // Test all valid URL characters in a comprehensive way
        String validChars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.-*_:/+%=&?#[]@~!$'(),;";
        for (char c : validChars.toCharArray()) {
            assertTrue("Character '" + c + "' should be a valid URL character", CharUtil.isUrlChar(c));
        }
    }

    public void test_isUrlChar_boundaryChars() {

            if (targetUrl.indexOf('#') == -1) {
                final StringBuilder buf = new StringBuilder(value.length() + 100);
                for (final char c : value.toCharArray()) {
                    if (CharUtil.isUrlChar(c) || c == ' ') {
                        buf.append(c);
                    } else {
                        try {

                    list.add(sb.toString());
                    sb = new StringBuilder();
                }
                pos += separator.length();
                continue;
            }

            char ch = s.charAt(pos);
            pos++;
            if (ch == '\\') {
                sb.append(ch);
                if (pos >= end) {
                    break; // ERROR, or let it go?
                }

    /** Logger instance for this class */
    private static final Logger logger = LogManager.getLogger(PopularWordHelper.class);

    /** Character used to separate cache key components */
    protected static final char CACHE_KEY_SPLITTER = '\n';

    /** Cache for storing popular word lists */
    protected Cache<String, List<String>> cache;

    /** Fess configuration instance */
    protected FessConfig fessConfig;

    /**

     * @return whether this is an IP address
     */
    public static boolean isDotQuadIP(final String hostname) {
        if (Character.isDigit(hostname.charAt(0))) {
            int i, len, dots;
            char[] data;

            i = dots = 0; /* quick IP address validation */
            len = hostname.length();
            data = hostname.toCharArray();
            while (i < len && Character.isDigit(data[i++])) {