}

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

  }

  /**
   * 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 {

   */
  AppendableWriter(Appendable target) {
    this.target = checkNotNull(target);
  }

  /*
   * Abstract methods from Writer
   */

  @Override
  public void write(char[] cbuf, int off, int len) throws IOException {
    checkNotClosed();
    // It turns out that creating a new String is usually as fast, or faster
    // than wrapping cbuf in a light-weight CharSequence.

   * @param hi the high surrogate pair character
   * @param lo the low surrogate pair character
   */
  public static void assertUnicodeEscaping(
      UnicodeEscaper escaper, String expected, char hi, char lo) {

    int cp = Character.toCodePoint(hi, lo);
    String escaped = computeReplacement(escaper, cp);
    Assert.assertNotNull(escaped);
    Assert.assertEquals(expected, escaped);
  }

   * @param hi the high surrogate pair character
   * @param lo the low surrogate pair character
   */
  public static void assertUnicodeEscaping(
      UnicodeEscaper escaper, String expected, char hi, char lo) {

    int cp = Character.toCodePoint(hi, lo);
    String escaped = computeReplacement(escaper, cp);
    Assert.assertNotNull(escaped);
    Assert.assertEquals(expected, escaped);
  }

        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;

     */
    public static char[] addAll(final char[] a, final char[] b) {
        if (a == null) {
            return b;
        }
        if (b == null) {
            return a;
        }
        if (a.length == 0) {
            return b;
        }
        if (b.length == 0) {
            return a;
        }
        final char[] array = (char[]) Array.newInstance(char.class, a.length + b.length);

    @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

    static final int EOF = -1;

    static final char PROPERTY_START = '.';

    static final char INDEXED_START = '[';

    static final char INDEXED_END = ']';

    static final char MAPPED_START = '(';

    static final char MAPPED_END = ')';

    static class Tokenizer {
        final String expression;

        int idx;

        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