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));

        scanner.next();
    }

    private void parseHtmlEncodedChar(StringBuilder buffer) {
        scanner.next(2);
        scanner.mark();
        scanner.find(';');
        String value = new String(new char[]{(char) Integer.parseInt(scanner.region())});
        buffer.append(value);
        scanner.next();
    }

    private void parseJavadocTag(TokenVisitor visitor) {
        // start of tag marker

    BufferedReader reader = source.openBufferedStream();
    assertTrue(source.wasStreamOpened());
    assertFalse(source.wasStreamClosed());

    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();

    assertTrue(source.wasStreamClosed());

  TF_DeletePluggableDeviceLibraryHandle(lib);
#endif  // !defined(TENSORFLOW_NO_SHARED_OBJECTS)
#endif  // !defined(PLATFORM_WINDOWS)
}

void DefineFunction(const char* name, TF_Function** func,
                    const char* description = nullptr,
                    bool append_hash = false) {
  std::unique_ptr<TF_Graph, decltype(&TF_DeleteGraph)> func_graph(
      TF_NewGraph(), TF_DeleteGraph);

    public void testNewStringUnsafe() {
        assertNull(StringUtil.newStringUnsafe(null));
        char[] chars = new char[0];
        assertThat(StringUtil.newStringUnsafe(chars), is(""));
        chars = new char[] { 'a', 'b', 'c' };
        assertThat(StringUtil.newStringUnsafe(chars), is("abc"));
        chars = new char[] { 'a', 'b', 'c', ' ' };
        assertThat(StringUtil.newStringUnsafe(chars), is("abc "));
    }

     */
    public static String dec_utf8(final byte[] src, int si, final int slim) throws IOException {
        final char[] uni = new char[slim - si];
        int ui, ch;

        for (ui = 0; si < slim && (ch = src[si++] & 0xFF) != 0; ui++) {
            if (ch < 0x80) {
                uni[ui] = (char) ch;
            } else if ((ch & 0xE0) == 0xC0) {
                if (slim - si < 2) {
                    break;

     * @param beanDelimiter
     *            The delimiter for JavaBeans.
     * @return A {@link CopyOptions} with the specified delimiter for JavaBeans.
     * @see CopyOptions#beanDelimiter(char)
     */
    public static CopyOptions beanDelimiter(final char beanDelimiter) {
        return new CopyOptions().beanDelimiter(beanDelimiter);
    }

    /**
     * Returns a {@link CopyOptions} with the specified delimiter for {@literal Map}.

                }
            } else if (Character.isDigit(line.charAt(0))) {
                final char[] data = line.toCharArray();
                int ip, i, j;
                Name name;
                NbtAddress addr;
                char c = '.';

                ip = i = 0;
                for (; i < data.length && c == '.'; i++) {
                    int b = 0x00;

import java.io.FilterOutputStream;
import java.io.IOException;
import java.io.OutputStream;

/**
 * An implementation of {@link DataOutput} that uses little-endian byte ordering for writing {@code
 * char}, {@code short}, {@code int}, {@code float}, {@code double}, and {@code long} values.
 *
 * <p><b>Note:</b> This class intentionally violates the specification of its supertype {@code

    /**
     * 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();