final DecimalFormatSymbols symbols = DecimalFormatSymbolsUtil.getDecimalFormatSymbols(locale);
        final char decimalSep = symbols.getDecimalSeparator();
        final char groupingSep = symbols.getGroupingSeparator();
        final StringBuilder buf = new StringBuilder(20);
        for (int i = 0; i < s.length(); ++i) {
            char c = s.charAt(i);
            if (c == groupingSep) {
                continue;

            + "abcdefghijklmnopqrstuvwxyz"
            + "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
            + "1234567890";
    assertEquals(s, xmlEscaper.escape(s));

    // Test ASCII control characters.
    for (char ch = 0; ch < 0x20; ch++) {
      if (ch == '\t' || ch == '\n' || ch == '\r') {
        // Only these whitespace chars are permitted in XML,
        if (shouldEscapeWhitespaceChars) {

    public List<Character> create(Character[] elements) {
      char[] chars = Chars.toArray(asList(elements));
      return charactersOf(String.copyValueOf(chars));
    }
  }

  public static class CharactersOfCharSequenceGenerator extends TestCharacterListGenerator {
    @Override
    public List<Character> create(Character[] elements) {
      char[] chars = Chars.toArray(asList(elements));

    @Test
    public void testContains_character() throws Exception {
        assertThat(ArrayUtil.contains(new char[] { '1', '2' }, '1'), is(true));
        assertThat(ArrayUtil.contains(new char[] { '1' }, '2'), is(not(true)));
        assertThat(ArrayUtil.contains(new char[] { '2', '1' }, '1'), is(true));
        assertThat(ArrayUtil.contains((char[]) null, '1'), is(not(true)));
    }

    /**
     * @throws Exception
     */
    @Test

  }

  /**
   * Reads a char as specified by {@link DataInputStream#readChar()}, except using little-endian
   * byte order.
   *
   * @return the next two bytes of the input stream, interpreted as a {@code char} in little-endian
   *     byte order
   * @throws IOException if an I/O error occurs
   */
  @CanIgnoreReturnValue // to skip some bytes
  @Override
  public char readChar() throws IOException {

        assertEquals(testStringTrue.length() + 1, unicodeStringTrue.buffer.length, "Buffer length should include zterm");
        for (int i = 0; i < testStringTrue.length(); i++) {
            assertEquals(testStringTrue.charAt(i), (char) unicodeStringTrue.buffer[i], "Character mismatch");
        }
        assertEquals(0, unicodeStringTrue.buffer[testStringTrue.length()], "Last character should be zero");

        // Test with a non-empty string and zterm = false

            bufferSize = DEFAULT_BUF_SIZE;
        }
        char[] buf = new char[bufferSize];
        int size = 0;
        int len;
        try {
            while ((len = reader.read(buf, size, bufferSize - size)) != -1) {
                size += len;
                if (size == bufferSize) {
                    final char[] newBuf = new char[bufferSize + initialCapacity];

  ASSERT_EQ(TF_OK, TF_GetCode(s_)) << TF_Message(s_);
  EXPECT_TF_META("v", -1, TF_ATTR_STRING, 5);
  std::unique_ptr<char[]> value(new char[5]);

  TF_OperationGetAttrString(oper, "v", value.get(), 5, s_);
  EXPECT_EQ(TF_OK, TF_GetCode(s_)) << TF_Message(s_);
  EXPECT_EQ("bunny", string(static_cast<const char*>(value.get()), 5));
}

TEST_F(CApiAttributesTest, StringList) {

    /**
     * The prefix.
     */
    protected String prefix;

    /**
     * Delimiter for JavaBeans.
     */
    protected char beanDelimiter = '$';

    /**
     * Delimiter for Map.
     */
    protected char mapDelimiter = '.';

    /**
     * Converter associated with specific properties.
     */
    protected final Map<String, Converter> converterMap = newHashMap();

    this.source = factory.createSource(data);
  }

  public void testOpenStream() throws IOException {
    Reader reader = source.openStream();

    StringWriter writer = new StringWriter();
    char[] buf = new char[64];
    int read;
    while ((read = reader.read(buf)) != -1) {
      writer.write(buf, 0, read);
    }
    reader.close();
    writer.close();

    assertExpectedString(writer.toString());