return "u0020u3000";
            }
        };

        int[] chars = fessConfig.getCrawlerDocumentSpaceCharsAsArray();
        assertEquals(2, chars.length);
        assertEquals(32, chars[0]);
        assertEquals(12288, chars[1]);
    }

    public void test_getCrawlerDocumentFullstopCharsAsArray() {
        FessProp.propMap.clear();

      return insertionOrder;
    }
  }

  public static class SampleChars extends SampleElements<Character> {
    public SampleChars() {
      super((char) 0, (char) 1, (char) 2, (char) 3, (char) 4);
    }
  }

            throw new PACDecodingException("Malformed string in PAC");

        this.dis.skip(unusedChars * 2);
        char[] chars = new char[usedChars];
        for ( int l = 0; l < usedChars; l++ )
            chars[ l ] = (char) readShort();

        return new String(chars);
    }


    public SID readId () throws IOException, PACDecodingException {
        byte[] bytes = new byte[4];

        this.messageBuilderFactory = messageBuilderFactory;
        this.terminalWidth = terminalWidth;
    }

    private static String chars(char c, int count) {
        return String.valueOf(c).repeat(Math.max(0, count));
    }

    private void infoLine(char c) {
        infoMain(chars(c, lineLength));
    }

    private void infoMain(String msg) {
        logger.info(builder().strong(msg).toString());
    }

    Set<Character> positive = Sets.newHashSetWithExpectedSize(chars.length);
    for (char c : chars) {
      positive.add(c);
    }
    for (int c = 0; c <= Character.MAX_VALUE; c++) {
      assertFalse(positive.contains(Character.valueOf((char) c)) ^ m.matches((char) c));
    }
  }

  static char[] randomChars(Random rand, int size) {
    Set<Character> chars = new HashSet<>(size);

   * Reader#skip(long) skip} to the end of the stream, and return the total number of chars that
   * were skipped.
   *
   * <p>Note that for sources that implement {@link #lengthIfKnown} to provide a more efficient
   * implementation, it is <i>possible</i> that this method will return a different number of chars
   * than would be returned by reading all of the chars.
   *

      chars.add(randomAlpha());
    }
    for (int i = 0; i < nonAlpha; i++) {
      chars.add(randomNonAlpha());
    }
    Collections.shuffle(chars, random);
    char[] array = Chars.toArray(chars);
    this.testString = new String(array);
  }

  private char randomAlpha() {
    return ALPHA.charAt(random.nextInt(ALPHA.length()));
  }

  private char randomNonAlpha() {

    final String allMatchingChars = allMatchingChars(bitSet);
    final char[] result = new char[STRING_LENGTH];
    // Fill with matching chars.
    for (int i = 0; i < result.length; i++) {
      result[i] = allMatchingChars.charAt(random.nextInt(allMatchingChars.length()));
    }
    // Replace some of chars by non-matching.
    int remaining = (int) ((100 - percentMatching) * result.length / 100.0 + 0.5);

    final String allMatchingChars = allMatchingChars(bitSet);
    final char[] result = new char[STRING_LENGTH];
    // Fill with matching chars.
    for (int i = 0; i < result.length; i++) {
      result[i] = allMatchingChars.charAt(random.nextInt(allMatchingChars.length()));
    }
    // Replace some of chars by non-matching.
    int remaining = (int) ((100 - percentMatching) * result.length / 100.0 + 0.5);

// code points in chars. It returns -1 if chars is empty or if there is no code
// point in common.
func IndexAny(s []byte, chars string) int {
	if chars == "" {
		// Avoid scanning all of s.
		return -1
	}
	if len(s) == 1 {
		r := rune(s[0])
		if r >= utf8.RuneSelf {
			// search utf8.RuneError.
			for _, r = range chars {
				if r == utf8.RuneError {
					return 0
				}