static CharEscaper createSimpleCharEscaper(ImmutableMap<Character, char[]> replacementMap) {
    return new CharEscaper() {
      @Override
      protected char @Nullable [] escape(char c) {
        return replacementMap.get(c);
      }
    };
  }

  // A trivial non-optimized escaper for testing.
  static UnicodeEscaper createSimpleUnicodeEscaper(ImmutableMap<Integer, char[]> replacementMap) {
    return new UnicodeEscaper() {

            + "1234567890";
    assertThat(xmlEscaper.escape(s)).isEqualTo(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) {
          assertEscaping(xmlEscaper, "&#x" + Integer.toHexString(ch).toUpperCase() + ";", ch);

    while (lines.peek() == null) {
      Java8Compatibility.clear(cbuf);
      // The default implementation of Reader#read(CharBuffer) allocates a
      // temporary char[], so we call Reader#read(char[], int, int) instead.
      int read = (reader != null) ? reader.read(buf, 0, buf.length) : readable.read(cbuf);
      if (read == -1) {
        lineBuf.finish();
        break;
      }

import java.io.FilterWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.Writer;
import org.jspecify.annotations.NullUnmarked;

/**
 * A char sink for testing that has configurable behavior.
 *
 * @author Colin Decker
 */
@NullUnmarked
public class TestCharSink extends CharSink implements TestStreamSupplier {

  private final TestByteSink byteSink;

import java.io.FilterWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.Writer;
import org.jspecify.annotations.NullUnmarked;

/**
 * A char sink for testing that has configurable behavior.
 *
 * @author Colin Decker
 */
@NullUnmarked
public class TestCharSink extends CharSink implements TestStreamSupplier {

  private final TestByteSink byteSink;

   *
   * @since 20.0 (varargs overload since 2.0)
   */
  public static void checkArgument(
      boolean expression, String errorMessageTemplate, char p1, char p2) {
    if (!expression) {
      throw new IllegalArgumentException(lenientFormat(errorMessageTemplate, p1, p2));
    }
  }

  /**

    @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

    public void mark() {
        markPos = pos;
    }

    public void next() {
        next(1);
    }

    public void next(int n) {
        pos += n;
    }

    public boolean lookingAt(char c) {
        return input.charAt(pos) == c;
    }

    public boolean lookingAt(CharSequence prefix) {
        int i = 0;
        int cpos = pos;
        while (i < prefix.length() && cpos < input.length()) {

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

}

// Exercises tensorflow's C API.
int main(int argc, char** argv) {
  TF_InitMain(argv[0], &argc, &argv);

  struct TF_StringStream* s = TF_GetLocalTempDirectories();
  const char* path;

  if (!TF_StringStreamNext(s, &path)) {
    fprintf(stderr, "TF_GetLocalTempDirectories returned no results\n");
    return 1;
  }

  char file_name[100];
  time_t t = time(NULL);