/**
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include <stdint.h>
#include <string.h>
#include "hiveclient.h"

/* INSTRUCTIONS:
 *   This test suite should have been compiled when 'make' was executed from the
 *   base odbc directory as HiveClientTestC before running this test suite, make
 *   sure to copy the odbc/testdata/ directory to /tmp/ on the same machine as
 *   the Hive Server. To run this test suite, just run the executable: HiveClientTestC.
 */

#define MAX_QUERY_LEN 1024
#define MAX_FIELD_LEN 255

// Currently all Hive numeric types are signed (64-bit platform specific)
// but tests should also run in 32-bit mode
#define MIN_TINYINT -128
#define MIN_SMALLINT -32768
#define MIN_INT 0x80000000
#define MIN_BIGINT 0x8000000000000000
#define SMALLEST_POS_FLOAT 1.1754944E-38
#define SMALLEST_POS_DOUBLE 2.225073858507201E-308
#define MAX_TINYINT 127
#define MAX_SMALLINT 32767
#define MAX_INT 0x7FFFFFFF
#define MAX_BIGINT 0x7FFFFFFFFFFFFFFF
#define BIGGEST_POS_FLOAT 3.4028235E+38
#define BIGGEST_POS_DOUBLE 1.797693134862315E+308

// Convert a macro value to a string
#define STRINGIFY(x) XSTRINGIFY(x)
#define XSTRINGIFY(x) #x

// Path to test data (should be supplied at compile time)
#ifdef TEST_DATA_DIR
#define TEST_DATA_DIR_STR STRINGIFY(TEST_DATA_DIR)
#else
#define TEST_DATA_DIR_STR "/tmp/testdata" // Provide a default if not defined
#endif

/**
 * Checks an error condition, and if true:
 * 1. prints the error to stderr
 * 2. returns the specified ret_val
 */
#define RETURN_ON_ASSERT_ONE_ARG(condition, err_format, arg, ret_val) {                         \
  if (condition) {                                                                              \
    fprintf(stderr, "----LINE %i: ", __LINE__);                                                 \
    fprintf(stderr, err_format, arg);                                                           \
    return ret_val;                                                                             \
  }                                                                                             \
}

/**
 * Checks an error condition, and if true:
 * 1. prints the error to stderr
 * 2. closes the DB connection on db_conn
 * 3. returns the specified ret_val
 */
#define RETURN_ON_ASSERT_NO_ARG_CLOSE(condition, err_format, db_conn, ret_val) {                \
  if (condition) {                                                                              \
    char error_buffer_[MAX_HIVE_ERR_MSG_LEN];                                                   \
    fprintf(stderr, "----LINE %i: ", __LINE__);                                                 \
    fprintf(stderr, err_format);                                                                \
    DBCloseConnection(db_conn, error_buffer_, sizeof(error_buffer_));                           \
    return ret_val;                                                                             \
  }                                                                                             \
}
#define RETURN_ON_ASSERT_ONE_ARG_CLOSE(condition, err_format, arg, db_conn, ret_val) {          \
  if (condition) {                                                                              \
    char error_buffer_[MAX_HIVE_ERR_MSG_LEN];                                                   \
    fprintf(stderr, "----LINE %i: ", __LINE__);                                                 \
    fprintf(stderr, err_format, arg);                                                           \
    DBCloseConnection(db_conn, error_buffer_, sizeof(error_buffer_));                           \
    return ret_val;                                                                             \
  }                                                                                             \
}
#define RETURN_ON_ASSERT_TWO_ARG_CLOSE(condition, err_format, arg1, arg2, db_conn, ret_val) {   \
  if (condition) {                                                                              \
    char error_buffer_[MAX_HIVE_ERR_MSG_LEN];                                                   \
    fprintf(stderr, "----LINE %i: ", __LINE__);                                                 \
    fprintf(stderr, err_format, arg1, arg2);                                                    \
    DBCloseConnection(db_conn, error_buffer_, sizeof(error_buffer_));                           \
    return ret_val;                                                                             \
  }                                                                                             \
}

/**************************************************************************************************
 * HELPER FUNCTIONS
 **************************************************************************************************/

int dummyHiveTypeConverter(HiveType type) {
  return 1; // For testing purposes, just return an arbitrary value
}

HiveReturn dropTable(HiveConnection* connection, const char* table_name) {
  char err_buf[MAX_HIVE_ERR_MSG_LEN];
  HiveReturn retval;
  char query[MAX_QUERY_LEN];
  int has_results;
  HiveResultSet* resultset;

  sprintf(query, "DROP TABLE %s", table_name);
  retval = DBExecute(connection, query, &resultset, 10, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBExecute failed: %s\n",
      err_buf, connection, HIVE_ERROR);

  retval = DBHasResults(resultset, &has_results, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBHasResults failed: %s\n",
      err_buf, connection, HIVE_ERROR);
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(has_results,
      "Query '%s' generated results\n",
      query, connection, HIVE_ERROR);

  retval = DBCloseResultSet(resultset, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG(retval == HIVE_ERROR,
      "DBCloseResultSet failed: %s\n",
      err_buf, HIVE_ERROR)

  return HIVE_SUCCESS;
}

/**************************************************************************************************
 * TEST FUNCTIONS
 **************************************************************************************************/

int basic_connect_disconnect_test() {
  fprintf(stderr, "Running %s...\n", __FUNCTION__);
  char err_buf[MAX_HIVE_ERR_MSG_LEN];
  HiveReturn retval;
  HiveConnection* connection = DBOpenConnection(DEFAULT_DATABASE, DEFAULT_HOST, atoi(DEFAULT_PORT),
                                                atoi(DEFAULT_FRAMED), err_buf, sizeof(err_buf));
  if (connection == NULL) {
    /* If this fails, make sure that Hive server is running with the connect parameter arguments */
    fprintf(stderr, "Connect failed: %s\n", err_buf);
    fprintf(stderr, "\n\n\nMAKE SURE YOU HAVE THE STANDALONE HIVESERVER RUNNING!\n");
    fprintf(stderr, "Expected Connection Parameters:\n");
    fprintf(stderr, "HOST: %s\n", DEFAULT_HOST);
    fprintf(stderr, "PORT: %s\n", DEFAULT_PORT);
    fprintf(stderr, "DATABASE: %s\n\n\n", DEFAULT_DATABASE);
    assert(connection != NULL);
  }
  retval = DBCloseConnection(connection, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG(retval == HIVE_ERROR,
      "Disconnect failed: %s\n",
      err_buf, 0)
  return 1;
}

int basic_query_exec_test() {
  fprintf(stderr, "Running %s...\n", __FUNCTION__);
  char err_buf[MAX_HIVE_ERR_MSG_LEN];
  HiveResultSet* resultset;
  HiveReturn retval;

  HiveConnection* connection = DBOpenConnection(DEFAULT_DATABASE, DEFAULT_HOST, atoi(DEFAULT_PORT),
                                                atoi(DEFAULT_FRAMED), err_buf, sizeof(err_buf));
  /* If this fails, make sure that Hive server is running with the connect parameter arguments */
  assert(connection != NULL);

  retval = DBExecute(connection, "SHOW TABLES", &resultset, 10, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBExecute failed: %s\n",
      err_buf, connection, 0);

  retval = DBCloseResultSet(resultset, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBCloseResultSet failed: %s\n",
      err_buf, connection, 0);

  retval = DBCloseConnection(connection, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBDisconnect failed: %s\n",
      err_buf, connection, 0);
  return 1;
}

int basic_fetch_test() {
  fprintf(stderr, "Running %s...\n", __FUNCTION__);
  char err_buf[MAX_HIVE_ERR_MSG_LEN];
  int has_results;
  HiveResultSet* resultset;
  HiveReturn retval;

  HiveConnection* connection = DBOpenConnection(DEFAULT_DATABASE, DEFAULT_HOST, atoi(DEFAULT_PORT),
                                                atoi(DEFAULT_FRAMED), err_buf, sizeof(err_buf));
  /* If this fails, make sure that Hive server is running with the connect parameter arguments */
  assert(connection != NULL);

  retval = DBExecute(connection, "SHOW TABLES", &resultset, 10, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBExecute failed: %s\n",
      err_buf, connection, 0);

  retval = DBHasResults(resultset, &has_results, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBHasResults failed: %s\n",
      err_buf, connection, 0);

  retval = DBFetch(resultset, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBFetch failed: %s\n",
      err_buf, connection, 0);
  RETURN_ON_ASSERT_NO_ARG_CLOSE(retval == HIVE_SUCCESS && !has_results,
      "DBFetch failed: Row fetched but no results detected\n",
      connection, 0);
  RETURN_ON_ASSERT_NO_ARG_CLOSE(retval == HIVE_NO_MORE_DATA && has_results,
      "DBFetch failed: Results detected but no rows fetched\n",
      connection, 0)

  retval = DBCloseResultSet(resultset, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBCloseResultSet failed: %s\n",
      err_buf, connection, 0);

  retval = DBCloseConnection(connection, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBDisconnect failed: %s\n",
      err_buf, connection, 0);
  return 1;
}

int show_tables_test() {
  fprintf(stderr, "Running %s...\n", __FUNCTION__);
  char err_buf[MAX_HIVE_ERR_MSG_LEN];
  const char* table_name = "ehwang_tmp_test";
  HiveReturn retval;
  char query[MAX_QUERY_LEN];
  char field[MAX_FIELD_LEN];
  int has_results;
  size_t col_count;
  size_t col_len;
  size_t data_byte_size;
  int is_null_value;
  HiveResultSet* resultset;

  HiveConnection* connection = DBOpenConnection(DEFAULT_DATABASE, DEFAULT_HOST, atoi(DEFAULT_PORT),
                                                atoi(DEFAULT_FRAMED), err_buf, sizeof(err_buf));
  assert(connection != NULL); /* If this fails, make sure that Hive server is running with the connect parameter arguments */

  // Drop pre-existing tables of the same name
  if (dropTable(connection, table_name) == HIVE_ERROR) {
    DBCloseConnection(connection, err_buf, sizeof(err_buf));
    return 0;
  }

  // Create the table
  sprintf(query, "CREATE TABLE %s (key int, value string)", table_name);
  retval = DBExecute(connection, query, &resultset, 10, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBExecute failed: %s\n",
      err_buf, connection, 0);

  retval = DBHasResults(resultset, &has_results, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBHasResults failed: %s\n",
      err_buf, connection, 0);
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(has_results,
      "Query '%s' generated results\n",
      query, connection, 0);

  retval = DBCloseResultSet(resultset, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBCloseResultSet failed: %s\n",
      err_buf, connection, 0);

  // Test 'show tables' query
  sprintf(query, "SHOW TABLES '%s'", table_name);
  retval = DBExecute(connection, query, &resultset, 10, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBExecute failed: %s\n",
      err_buf, connection, 0);

  retval = DBHasResults(resultset, &has_results, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBHasResults failed: %s\n",
      err_buf, connection, 0);
  RETURN_ON_ASSERT_TWO_ARG_CLOSE(!has_results,
      "Query '%s'could not find table '%s'\n",
      query, table_name, connection, 0);

  retval = DBGetColumnCount(resultset, &col_count, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBGetColumnCount failed: '%s'\n",
      err_buf, connection, 0);
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(col_count != 1,
      "Column count not equal to one: %zu\n",
      col_count, connection, 0);

  // Fetch row
  retval = DBFetch(resultset, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBFetch failed: %s\n",
      err_buf, connection, 0);
  RETURN_ON_ASSERT_NO_ARG_CLOSE(retval == HIVE_NO_MORE_DATA,
      "DBFetch failed: Could not fetch the only row\n",
      connection, 0);

  // Check row data
  retval = DBGetFieldAsCString(resultset, 0, field, sizeof(field), &data_byte_size, &is_null_value,
                               err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBGetFieldAsCString failed: %s\n",
      err_buf, connection, 0);
  RETURN_ON_ASSERT_TWO_ARG_CLOSE(strcmp(field, table_name) != 0,
      "Tables do not have the same name: table_name:%s, field:%s\n",
      table_name, field, connection, 0);

  retval = DBGetFieldDataLen(resultset, 0, &col_len, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_NO_ARG_CLOSE(retval == HIVE_ERROR,
      "DBGetFieldDataLen failed: Could not get the strlen\n",
      connection, 0);
  RETURN_ON_ASSERT_TWO_ARG_CLOSE(col_len != strlen(field),
      "DBGetFieldDataLen failed: Returned length (%zu) was not the same as table_name (%zu)\n",
      col_len, strlen(field), connection, 0);

  // Fetch row (check that there is nothing else to fetch)
  retval = DBFetch(resultset, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBFetch failed: %s\n",
      err_buf, connection, 0);
  RETURN_ON_ASSERT_NO_ARG_CLOSE(retval != HIVE_NO_MORE_DATA,
      "DBFetch failed: Only one row, but fetched two\n",
      connection, 0);

  // Clean up table
  if (dropTable(connection, table_name) == HIVE_ERROR) {
    DBCloseConnection(connection, err_buf, sizeof(err_buf));
    return 0;
  }

  // Close the handles
  retval = DBCloseResultSet(resultset, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBCloseResultSet failed: %s\n",
      err_buf, connection, 0);
  retval = DBCloseConnection(connection, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG(retval == HIVE_ERROR,
      "Disconnect failed: %s\n",
      err_buf, 0)

  return 1;
}

int query_fetch_test() {
  fprintf(stderr, "Running %s...\n", __FUNCTION__);
  char err_buf[MAX_HIVE_ERR_MSG_LEN];
  const char* table_name = "ehwang_tmp_test";
  const char* test_data_path = TEST_DATA_DIR_STR "/dataset1.input";
  HiveReturn retval;
  char query[MAX_QUERY_LEN];
  char string_field[MAX_FIELD_LEN];
  int int_field;
  int has_results;
  size_t col_count;
  size_t col_len;
  size_t data_byte_size;
  int is_null_value;
  HiveResultSet* resultset;
  HiveColumnDesc* column_desc;
  HiveType hive_type;
  HiveType expected_hive_type;

  HiveConnection* connection = DBOpenConnection(DEFAULT_DATABASE, DEFAULT_HOST, atoi(DEFAULT_PORT),
                                                atoi(DEFAULT_FRAMED), err_buf, sizeof(err_buf));
  /* If this fails, make sure that Hive server is running with the connect parameter arguments */
  assert(connection != NULL);

  // Drop pre-existing tables of the same name
  if (dropTable(connection, table_name) == HIVE_ERROR) {
    DBCloseConnection(connection, err_buf, sizeof(err_buf));
    return 0;
  }

  // Create the table
  sprintf(query, "CREATE TABLE %s (key int, value string) STORED AS TEXTFILE", table_name);
  retval = DBExecute(connection, query, NULL, 0, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBExecute failed: %s\n",
      err_buf, connection, 0);

  // Load data into the table
  // NOTE: test_data_path has to be local to the hive server
  // NOTE: test_data_path is a ctrl-A separated file with two fields per line
  sprintf(query, "LOAD DATA LOCAL INPATH '%s' INTO TABLE %s", test_data_path, table_name);
  retval = DBExecute(connection, query, NULL, 0, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBExecute failed: %s\n",
      err_buf, connection, 0);

  // Run Select * query
  sprintf(query, "SELECT * FROM %s", table_name);
  // max_buf_len value of 1 to test client side result buffer fetching
  retval = DBExecute(connection, query, &resultset, 1, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBExecute failed: %s\n",
      err_buf, connection, 0);

  retval = DBHasResults(resultset, &has_results, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBHasResults failed: %s\n",
      err_buf, connection, 0);
  RETURN_ON_ASSERT_TWO_ARG_CLOSE(!has_results,
      "Query '%s'should have found results in table: '%s'\n",
      query, table_name, connection, 0);

  retval = DBGetColumnCount(resultset, &col_count, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBGetColumnCount failed: '%s'\n",
      err_buf, connection, 0);
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(col_count != 2,
      "Column count not equal to two: %zu\n",
      col_count, connection, 0);

  // Check HiveType of first column
  retval = DBCreateColumnDesc(resultset, 0, &column_desc, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBCreateColumnDesc failed: %s\n",
      err_buf, connection, 0);
  hive_type = DBGetHiveType(column_desc);
  expected_hive_type = HIVE_INT_TYPE;
  RETURN_ON_ASSERT_TWO_ARG_CLOSE(hive_type != expected_hive_type,
      "DBCreateColumnDesc failed: incorrect hive type: %i, expected: %i\n",
      hive_type, expected_hive_type, connection, 0);

  retval = DBCloseColumnDesc(column_desc, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBCloseColumnDesc failed: %s\n",
      err_buf, connection, 0);

  // Check HiveType of second column
  retval = DBCreateColumnDesc(resultset, 1, &column_desc, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBCreateColumnDesc failed: %s\n",
      err_buf, connection, 0);
  hive_type = DBGetHiveType(column_desc);
  expected_hive_type = HIVE_STRING_TYPE;
  RETURN_ON_ASSERT_TWO_ARG_CLOSE(hive_type != expected_hive_type,
      "DBCreateColumnDesc failed: incorrect hive type: %i, expected: %i\n",
      hive_type, expected_hive_type, connection, 0);

  retval = DBCloseColumnDesc(column_desc, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBCloseColumnDesc failed: %s\n",
      err_buf, connection, 0);

  // Fetch row
  retval = DBFetch(resultset, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBFetch failed: %s\n",
      err_buf, connection, 0);
  RETURN_ON_ASSERT_NO_ARG_CLOSE(retval == HIVE_NO_MORE_DATA,
      "DBFetch failed: Could not fetch the first row\n",
      connection, 0);

  // Check first row of data
  retval = DBGetFieldAsInt(resultset, 0, &int_field, &is_null_value, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBGetFieldAsInt failed: %s\n",
      err_buf, connection, 0);
  RETURN_ON_ASSERT_NO_ARG_CLOSE(is_null_value,
      "Int field for row 1 should not be NULL\n",
      connection, 0);
  RETURN_ON_ASSERT_TWO_ARG_CLOSE(int_field != 1,
      "Int field for row 1 does not match: expected=%i, recieved=%i\n",
      1, int_field, connection, 0);

  retval = DBGetFieldAsCString(resultset, 1, string_field, sizeof(string_field), &data_byte_size,
                               &is_null_value, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBGetFieldAsCString failed: %s\n",
      err_buf, connection, 0);
  RETURN_ON_ASSERT_NO_ARG_CLOSE(is_null_value,
      "String field for row 1 should not be NULL\n",
      connection, 0);
  RETURN_ON_ASSERT_TWO_ARG_CLOSE(strcmp(string_field, "foo") != 0,
      "String fields does not match: expected='%s', received='%s'\n",
      "foo", string_field, connection, 0);

  retval = DBGetFieldDataLen(resultset, 1, &col_len, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_NO_ARG_CLOSE(retval == HIVE_ERROR,
      "DBGetFieldDataLen failed: Could not get the strlen\n",
      connection, 0);
  RETURN_ON_ASSERT_TWO_ARG_CLOSE(col_len != strlen(string_field),
      "DBGetFieldDataLen failed: Returned length (%zu) was not the same as expected length (%zu)\n",
      col_len, strlen(string_field), connection, 0);
  RETURN_ON_ASSERT_TWO_ARG_CLOSE(data_byte_size != col_len,
      "DBGetFieldDataLen failed: Returned data_byte_length (%zu) was not the same as the amount written to buffer (%zu)\n",
      data_byte_size, strlen(string_field) + 1, connection, 0);

  // Fetch second row
  retval = DBFetch(resultset, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBFetch failed: %s\n",
      err_buf, connection, 0);
  RETURN_ON_ASSERT_NO_ARG_CLOSE(retval == HIVE_NO_MORE_DATA,
      "DBFetch failed: Could not fetch the second row\n",
      connection, 0);

  // Check second row of data
  retval = DBGetFieldAsInt(resultset, 0, &int_field, &is_null_value, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBGetFieldAsInt failed: %s\n",
      err_buf, connection, 0);
  RETURN_ON_ASSERT_NO_ARG_CLOSE(is_null_value,
      "Int field for row 1 should not be NULL\n",
      connection, 0);
  RETURN_ON_ASSERT_TWO_ARG_CLOSE(int_field != 2,
      "Int field for row 1 does not match: expected=%i, recieved=%i\n",
      1, int_field, connection, 0);

  retval = DBGetFieldAsCString(resultset, 1, string_field, sizeof(string_field), &data_byte_size,
                               &is_null_value, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBGetFieldAsCString failed: %s\n",
      err_buf, connection, 0);
  RETURN_ON_ASSERT_NO_ARG_CLOSE(is_null_value,
      "String field for row 2 should not be NULL\n",
      connection, 0);
  RETURN_ON_ASSERT_TWO_ARG_CLOSE(strcmp(string_field, "bar") != 0,
      "String fields does not match: expected='%s', received='%s'\n",
      "bar", string_field, connection, 0);

  retval = DBGetFieldDataLen(resultset, 1, &col_len, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_NO_ARG_CLOSE(retval == HIVE_ERROR,
      "DBGetFieldDataLen failed: Could not get the strlen\n",
      connection, 0);
  RETURN_ON_ASSERT_TWO_ARG_CLOSE(col_len != strlen(string_field),
      "DBGetFieldDataLen failed: Returned length (%zu) was not the same as expected length (%zu)\n",
      col_len, strlen(string_field), connection, 0);
  RETURN_ON_ASSERT_TWO_ARG_CLOSE(data_byte_size != col_len,
      "DBGetFieldDataLen failed: Returned data_byte_length (%zu) was not the same as the amount written to buffer (%zu)\n",
      data_byte_size, strlen(string_field) + 1, connection, 0);

  // Fetch non-existant row
  retval = DBFetch(resultset, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBFetch failed: %s\n",
      err_buf, connection, 0);
  RETURN_ON_ASSERT_NO_ARG_CLOSE(retval != HIVE_NO_MORE_DATA,
      "DBFetch failed: Only 2 rows, but was able to fetch a third...\n",
      connection, 0);

  // Clean up table
  if (dropTable(connection, table_name) == HIVE_ERROR) {
    DBCloseConnection(connection, err_buf, sizeof(err_buf));
    return 0;
  }

  // Close the handles
  retval = DBCloseResultSet(resultset, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBCloseResultSet failed: %s\n",
      err_buf, connection, 0);
  retval = DBCloseConnection(connection, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG(retval == HIVE_ERROR,
      "DBDisconnect failed: %s\n",
      err_buf, 0);

  return 1;
}

int numeric_range_test() {
  fprintf(stderr, "Running %s...\n", __FUNCTION__);
  char err_buf[MAX_HIVE_ERR_MSG_LEN];
  const char* table_name = "ehwang_tmp_test";
  const char* test_data_path = TEST_DATA_DIR_STR "/dataset_types.input";
  HiveReturn retval;
  char query[MAX_QUERY_LEN];
  int int_field;
  int64_t I64_field;
  double double_field;
  int is_null_value;
  HiveResultSet* resultset;

  HiveConnection* connection = DBOpenConnection(DEFAULT_DATABASE, DEFAULT_HOST, atoi(DEFAULT_PORT),
                                                atoi(DEFAULT_FRAMED), err_buf, sizeof(err_buf));
  /* If this fails, make sure that Hive server is running with the connect parameter arguments */
  assert(connection != NULL);

  // Drop pre-existing tables of the same name
  if (dropTable(connection, table_name) == HIVE_ERROR) {
    DBCloseConnection(connection, err_buf, sizeof(err_buf));
    return 0;
  }

  // Create the table
  sprintf(
          query,
          "CREATE TABLE %s (tinyint_type tinyint, smallint_type smallint, int_type int, bigint_type bigint, float_type float, double_type double, null_test int) STORED AS TEXTFILE",
          table_name);
  retval = DBExecute(connection, query, NULL, 0, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBExecute failed: %s\n",
      err_buf, connection, 0);

  // Load data into the table
  // NOTE: test_data_path has to be local to the hive server
  // NOTE: test_data_path is a ctrl-A separated file with seven fields per line
  sprintf(query, "LOAD DATA LOCAL INPATH '%s' INTO TABLE %s", test_data_path, table_name);
  retval = DBExecute(connection, query, NULL, 0, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBExecute failed: %s\n",
      err_buf, connection, 0);

  // Run Select * query
  sprintf(query, "SELECT * FROM %s", table_name);
  retval = DBExecute(connection, query, &resultset, 1, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBExecute failed: %s\n",
      err_buf, connection, 0);

  // Fetch row of minimum numeric values
  retval = DBFetch(resultset, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBFetch failed: %s\n",
      err_buf, connection, 0);
  RETURN_ON_ASSERT_NO_ARG_CLOSE(retval == HIVE_NO_MORE_DATA,
      "DBFetch failed: Could not fetch the first row\n",
      connection, 0);

  // Check first row of minimum numeric values

  // Min tinyint field
  retval = DBGetFieldAsInt(resultset, 0, &int_field, &is_null_value, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBGetFieldAsInt failed: %s\n",
      err_buf, connection, 0);
  RETURN_ON_ASSERT_NO_ARG_CLOSE(is_null_value,
      "TINYINT field for row 1 should not be NULL\n",
      connection, 0);
  RETURN_ON_ASSERT_TWO_ARG_CLOSE(int_field != MIN_TINYINT,
      "TINYINT field for row 1 does not match: expected=%i, received=%i\n",
      MIN_TINYINT, int_field, connection, 0);

  // Min smallint field
  retval = DBGetFieldAsInt(resultset, 1, &int_field, &is_null_value, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBGetFieldAsInt failed: %s\n",
      err_buf, connection, 0);
  RETURN_ON_ASSERT_NO_ARG_CLOSE(is_null_value,
      "SMALLINT field for row 1 should not be NULL\n",
      connection, 0);
  RETURN_ON_ASSERT_TWO_ARG_CLOSE(int_field != MIN_SMALLINT,
      "SMALLINT field for row 1 does not match: expected=%i, received=%i\n",
      MIN_SMALLINT, int_field, connection, 0);

  // Min int field
  retval = DBGetFieldAsInt(resultset, 2, &int_field, &is_null_value, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBGetFieldAsInt failed: %s\n",
      err_buf, connection, 0);
  RETURN_ON_ASSERT_NO_ARG_CLOSE(is_null_value,
      "INTEGER field for row 1 should not be NULL\n",
      connection, 0);
  RETURN_ON_ASSERT_TWO_ARG_CLOSE(int_field != MIN_INT,
      "INTEGER field for row 1 does not match: expected=%i, received=%i\n",
      MIN_INT, int_field, connection, 0);

  // Min bigint field
  retval = DBGetFieldAsI64(resultset, 3, &I64_field, &is_null_value, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBGetFieldAsI64 failed: %s\n",
      err_buf, connection, 0);
  RETURN_ON_ASSERT_NO_ARG_CLOSE(is_null_value,
      "BIGINT field for row 1 should not be NULL\n",
      connection, 0);
  RETURN_ON_ASSERT_TWO_ARG_CLOSE(I64_field != MIN_BIGINT,
      "BIGINT field for row 1 does not match: expected=%lld, received=%lld\n",
      (long long) MIN_BIGINT, (long long) I64_field, connection, 0);

  // Smallest positive float field
  retval
      = DBGetFieldAsDouble(resultset, 4, &double_field, &is_null_value, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBGetFieldAsDouble failed: %s\n",
      err_buf, connection, 0);
  RETURN_ON_ASSERT_NO_ARG_CLOSE(is_null_value,
      "FLOAT field for row 1 should not be NULL\n",
      connection, 0);
  RETURN_ON_ASSERT_TWO_ARG_CLOSE((float) double_field != (float) SMALLEST_POS_FLOAT,
      "FLOAT field for row 1 does not match: expected=%.17g, received=%.17g\n",
      (float) SMALLEST_POS_FLOAT, (float) double_field, connection, 0);

  // Smallest positive double field
  retval
      = DBGetFieldAsDouble(resultset, 5, &double_field, &is_null_value, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,"DBGetFieldAsDouble failed: %s\n", err_buf,
      connection, 0);
  RETURN_ON_ASSERT_NO_ARG_CLOSE(is_null_value,
      "DOUBLE field for row 1 should not be NULL\n", connection, 0);
  RETURN_ON_ASSERT_TWO_ARG_CLOSE((double) double_field != (double) SMALLEST_POS_DOUBLE,
      "DOUBLE field for row 1 does not match: expected=%.17g, received=%.17g\n",
      (double) SMALLEST_POS_DOUBLE, (double) double_field, connection, 0);

  // NULL field
  retval = DBGetFieldAsInt(resultset, 6, &int_field, &is_null_value, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR, "DBGetFieldAsInt failed: %s\n", err_buf,
      connection, 0);
  RETURN_ON_ASSERT_NO_ARG_CLOSE(!is_null_value,
      "Field should be NULL\n", connection, 0);

  // Fetch row of maximum numeric values
  retval = DBFetch(resultset, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR, "DBFetch failed: %s\n", err_buf,
      connection, 0);
  RETURN_ON_ASSERT_NO_ARG_CLOSE(retval == HIVE_NO_MORE_DATA, "DBFetch failed: Could not fetch the second row\n",
      connection, 0);

  // Check second row of maximum numeric values

  // Max tinyint field
  retval = DBGetFieldAsInt(resultset, 0, &int_field, &is_null_value, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR, "DBGetFieldAsInt failed: %s\n", err_buf,
      connection, 0);
  RETURN_ON_ASSERT_NO_ARG_CLOSE(is_null_value,
      "TINYINT field for row 2 should not be NULL\n", connection, 0);
  RETURN_ON_ASSERT_TWO_ARG_CLOSE(int_field != MAX_TINYINT,
      "TINYINT field for row 2 does not match: expected=%i, received=%i\n", MAX_TINYINT,
      int_field, connection, 0);

  // Max smallint field
  retval = DBGetFieldAsInt(resultset, 1, &int_field, &is_null_value, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR, "DBGetFieldAsInt failed: %s\n", err_buf,
      connection, 0);
  RETURN_ON_ASSERT_NO_ARG_CLOSE(is_null_value,
      "SMALLINT field for row 2 should not be NULL\n", connection, 0);
  RETURN_ON_ASSERT_TWO_ARG_CLOSE(int_field != MAX_SMALLINT,
      "SMALLINT field for row 2 does not match: expected=%i, received=%i\n",
      MAX_SMALLINT, int_field, connection, 0);

  // Max int field
  retval = DBGetFieldAsInt(resultset, 2, &int_field, &is_null_value, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR, "DBGetFieldAsInt failed: %s\n", err_buf,
      connection, 0);
  RETURN_ON_ASSERT_NO_ARG_CLOSE(is_null_value,
      "INTEGER field for row 2 should not be NULL\n", connection, 0);
  RETURN_ON_ASSERT_TWO_ARG_CLOSE(int_field != MAX_INT,
      "INTEGER field for row 2 does not match: expected=%i, received=%i\n",
      MAX_INT, int_field, connection, 0);

  // Max bigint field
  retval = DBGetFieldAsI64(resultset, 3, &I64_field, &is_null_value, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR, "DBGetFieldAsI64 failed: %s\n", err_buf,
      connection, 0);
  RETURN_ON_ASSERT_NO_ARG_CLOSE(is_null_value,
      "BIGINT field for row 2 should not be NULL\n", connection, 0);
  RETURN_ON_ASSERT_TWO_ARG_CLOSE(I64_field != MAX_BIGINT,
      "BIGINT field for row 2 does not match: expected=%lld, received=%lld\n",
      (long long) MAX_BIGINT, (long long) I64_field, connection, 0);

  // Biggest positive float field
  retval
      = DBGetFieldAsDouble(resultset, 4, &double_field, &is_null_value, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBGetFieldAsDouble failed: %s\n",
      err_buf, connection, 0);
  RETURN_ON_ASSERT_NO_ARG_CLOSE(is_null_value,
      "FLOAT field for row 2 should not be NULL\n",
      connection, 0);
  RETURN_ON_ASSERT_TWO_ARG_CLOSE((float) double_field != (float) BIGGEST_POS_FLOAT,
      "FLOAT field for row 2 does not match: expected=%.17g, received=%.17g\n",
      (float) BIGGEST_POS_FLOAT, (float) double_field, connection, 0);

  // Biggest positive double field
  retval
      = DBGetFieldAsDouble(resultset, 5, &double_field, &is_null_value, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBGetFieldAsDouble failed: %s\n",
      err_buf, connection, 0);
  RETURN_ON_ASSERT_NO_ARG_CLOSE(is_null_value,
      "DOUBLE field for row 2 should not be NULL\n",
      connection, 0);
  RETURN_ON_ASSERT_TWO_ARG_CLOSE((double) double_field != (double) BIGGEST_POS_DOUBLE,
      "DOUBLE field for row 2 does not match: expected=%.17g, received=%.17g\n",
      (double) BIGGEST_POS_DOUBLE, (double) double_field, connection, 0);

  // NULL field
  retval = DBGetFieldAsInt(resultset, 6, &int_field, &is_null_value, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBGetFieldAsInt failed: %s\n",
      err_buf, connection, 0);
  RETURN_ON_ASSERT_NO_ARG_CLOSE(!is_null_value,
      "Field should be NULL\n",
      connection, 0);

  // Clean up table
  if (dropTable(connection, table_name) == HIVE_ERROR) {
    DBCloseConnection(connection, err_buf, sizeof(err_buf));
    return 0;
  }

  // Close the handles
  retval = DBCloseResultSet(resultset, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBCloseResultSet failed: %s\n",
      err_buf, connection, 0);
  retval = DBCloseConnection(connection, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG(retval == HIVE_ERROR,
      "DBDisconnect failed: %s\n",
      err_buf, 0);

  return 1;
}

int field_multifetch_test() {
  fprintf(stderr, "Running %s...\n", __FUNCTION__);
  char err_buf[MAX_HIVE_ERR_MSG_LEN];
  const char* table_name = "ehwang_tmp_test";
  const char* test_data_path = TEST_DATA_DIR_STR "/dataset2.input";
  HiveReturn retval;
  char query[MAX_QUERY_LEN];
  char string_field[MAX_FIELD_LEN];
  size_t data_byte_size;
  int int_field;
  int is_null_value;
  HiveResultSet* resultset;

  HiveConnection* connection = DBOpenConnection(DEFAULT_DATABASE, DEFAULT_HOST, atoi(DEFAULT_PORT),
                                                atoi(DEFAULT_FRAMED), err_buf, sizeof(err_buf));
  /* If this fails, make sure that Hive server is running with the connect parameter arguments */
  assert(connection != NULL);

  // Drop pre-existing tables of the same name
  if (dropTable(connection, table_name) == HIVE_ERROR) {
    DBCloseConnection(connection, err_buf, sizeof(err_buf));
    return 0;
  }

  // Create the table
  sprintf(query, "CREATE TABLE %s (fixed_len_field int, var_len_field string) STORED AS TEXTFILE",
          table_name);
  retval = DBExecute(connection, query, NULL, 0, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBExecute failed: %s\n",
      err_buf, connection, 0);

  // Load data into the table
  // NOTE: test_data_path has to be local to the hive server
  // NOTE: test_data_path is a ctrl-A separated file with two fields per line
  sprintf(query, "LOAD DATA LOCAL INPATH '%s' INTO TABLE %s", test_data_path, table_name);
  retval = DBExecute(connection, query, NULL, 0, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBExecute failed: %s\n",
      err_buf, connection, 0);

  // Run Select * query
  sprintf(query, "SELECT * FROM %s", table_name);
  retval = DBExecute(connection, query, &resultset, 1, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBExecute failed: %s\n",
      err_buf, connection, 0);

  // Fetch row
  retval = DBFetch(resultset, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBFetch failed: %s\n",
      err_buf, connection, 0);
  RETURN_ON_ASSERT_NO_ARG_CLOSE(retval == HIVE_NO_MORE_DATA,
      "DBFetch failed: Could not fetch the first row\n",
      connection, 0);

  // Test multi-fetches on fixed length fields:
  // First fetch
  retval = DBGetFieldAsInt(resultset, 0, &int_field, &is_null_value, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBGetFieldAsInt failed: %s\n",
      err_buf, connection, 0);
  RETURN_ON_ASSERT_NO_ARG_CLOSE(retval != HIVE_SUCCESS,
      "First fetch of a fixed length field should be successful\n",
      connection, 0);

  // Second fetch
  retval = DBGetFieldAsInt(resultset, 0, &int_field, &is_null_value, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBGetFieldAsInt failed: %s\n",
      err_buf, connection, 0);
  RETURN_ON_ASSERT_NO_ARG_CLOSE(retval != HIVE_NO_MORE_DATA,
      "Second consecutive fetch of a fixed length field should return HIVE_NO_MORE_DATA\n",
      connection, 0);

  // Third fetch
  retval = DBGetFieldAsInt(resultset, 0, &int_field, &is_null_value, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBGetFieldAsInt failed: %s\n",
      err_buf, connection, 0);
  RETURN_ON_ASSERT_NO_ARG_CLOSE(retval != HIVE_NO_MORE_DATA,
      "Third consecutive fetch of a fixed length field should return HIVE_NO_MORE_DATA\n",
      connection, 0);

  // Test multi-fetches on var length fields:
  // First fetch with sufficient buffer space
  retval = DBGetFieldAsCString(resultset, 1, string_field, sizeof(string_field), &data_byte_size,
                               &is_null_value, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBGetFieldAsCString failed: %s\n",
      err_buf, connection, 0);
  /* Length of alphabet string in data */
  RETURN_ON_ASSERT_TWO_ARG_CLOSE(data_byte_size != 26,
      "DBGetFieldAsCString failed: incorrect data_byte_size: expected=%zu, received=%zu\n",
      (size_t) 26, data_byte_size, connection, 0);
  RETURN_ON_ASSERT_NO_ARG_CLOSE(retval != HIVE_SUCCESS,
      "First fetch of a variable length field with sufficient buffer space should be successful\n",
      connection, 0);

  // Second fetch with sufficient buffer space
  retval = DBGetFieldAsCString(resultset, 1, string_field, sizeof(string_field), &data_byte_size,
                               &is_null_value, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBGetFieldAsCString failed: %s\n",
      err_buf, connection, 0);
  RETURN_ON_ASSERT_NO_ARG_CLOSE(retval != HIVE_NO_MORE_DATA,
      "Second consecutive fetch of a completely fetched variable length field should return HIVE_NO_MORE_DATA\n",
      connection, 0);

  // Third fetch with sufficient buffer space
  retval = DBGetFieldAsCString(resultset, 1, string_field, sizeof(string_field), &data_byte_size,
                               &is_null_value, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBGetFieldAsCString failed: %s\n",
      err_buf, connection, 0);
  RETURN_ON_ASSERT_NO_ARG_CLOSE(retval != HIVE_NO_MORE_DATA,
      "Third consecutive fetch of a completely fetched variable length field should return HIVE_NO_MORE_DATA\n",
      connection, 0);

  // Test multi-fetches on fixed length fields after reset column reset:
  // First fetch
  retval = DBGetFieldAsInt(resultset, 0, &int_field, &is_null_value, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBGetFieldAsInt failed: %s\n",
      err_buf, connection, 0);
  RETURN_ON_ASSERT_NO_ARG_CLOSE(retval != HIVE_SUCCESS,
      "First fetch of a fixed length field after a column reset should be successful\n",
      connection, 0);
  // Second fetch
  retval = DBGetFieldAsInt(resultset, 0, &int_field, &is_null_value, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBGetFieldAsInt failed: %s\n",
      err_buf, connection, 0);
  RETURN_ON_ASSERT_NO_ARG_CLOSE(retval != HIVE_NO_MORE_DATA,
      "Second consecutive fetch of a fixed length field should always return HIVE_NO_MORE_DATA\n",
      connection, 0);

  // Test multi-fetches on var length fields after column reset with insufficient buffer space:
  // First fetch with insufficient buffer space after a column reset
  size_t reduced_buffer_size = 13; // For a source data size of 26 bytes
  retval = DBGetFieldAsCString(resultset, 1, string_field, reduced_buffer_size, &data_byte_size,
                               &is_null_value, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBGetFieldAsCString failed: %s\n",
      err_buf, connection, 0);
  /* Length of available alphabet string to return before truncation */
  RETURN_ON_ASSERT_TWO_ARG_CLOSE(data_byte_size != 26,
      "DBGetFieldAsCString failed: incorrect data_byte_size: expected=%zu, received=%zu\n",
      (size_t) 26, data_byte_size, connection, 0);
  RETURN_ON_ASSERT_NO_ARG_CLOSE(retval != HIVE_SUCCESS_WITH_MORE_DATA,
      "First fetch of a variable length field with insufficient buffer space should return HIVE_SUCCESS_WITH_MORE_DATA\n",
      connection, 0);
  RETURN_ON_ASSERT_TWO_ARG_CLOSE(strcmp(string_field, "abcdefghijkl") != 0,
      "Fetched string does not match: expected:%s, received:%s\n",
      "abcdefghijkl", string_field, connection, 0);

  // Second fetch with insufficient buffer space
  retval = DBGetFieldAsCString(resultset, 1, string_field, reduced_buffer_size, &data_byte_size,
                               &is_null_value, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBGetFieldAsCString failed: %s\n",
      err_buf, connection, 0);
  /* Length of remaining alphabet string to return before truncation */
  RETURN_ON_ASSERT_TWO_ARG_CLOSE(data_byte_size != 14,
      "DBGetFieldAsCString failed: incorrect data_byte_size: expected=%zu, received=%zu\n",
      (size_t) 14, data_byte_size, connection, 0);
  RETURN_ON_ASSERT_NO_ARG_CLOSE(retval != HIVE_SUCCESS_WITH_MORE_DATA,
      "Second consecutive fetch with still insufficient buffer space should return HIVE_SUCCESS_WITH_MORE_DATA\n",
      connection, 0);
  RETURN_ON_ASSERT_TWO_ARG_CLOSE(strcmp(string_field, "mnopqrstuvwx"),
      "Fetched string does not match: expected:%s, received:%s\n",
      "mnopqrstuvwx", string_field, connection, 0);

  // Third fetch to obtain the remainder of the buffer data
  retval = DBGetFieldAsCString(resultset, 1, string_field, reduced_buffer_size, &data_byte_size,
                               &is_null_value, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBGetFieldAsCString failed: %s\n",
      err_buf, connection, 0);
  /* Length of remaining alphabet string to return before truncation */
  RETURN_ON_ASSERT_TWO_ARG_CLOSE(data_byte_size != 2,
      "DBGetFieldAsCString failed: incorrect data_byte_size: expected=%zu, received=%zu\n",
      (size_t) 2, data_byte_size, connection, 0);
  RETURN_ON_ASSERT_NO_ARG_CLOSE(retval != HIVE_SUCCESS,
      "Fetch that returns all or the complete remainder of the data buffer should return HIVE_SUCCESS\n",
      connection, 0);
  RETURN_ON_ASSERT_TWO_ARG_CLOSE(strcmp(string_field, "yz") != 0,
      "Fetched string does not match: expected:%s, received:%s\n",
      "yz", string_field, connection, 0);

  // Fourth fetch after all data has already been obtained
  retval = DBGetFieldAsCString(resultset, 1, string_field, reduced_buffer_size, &data_byte_size,
                               &is_null_value, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBGetFieldAsCString failed: %s\n",
      err_buf, connection, 0);
  RETURN_ON_ASSERT_NO_ARG_CLOSE(retval != HIVE_NO_MORE_DATA,
      "Fourth consecutive fetch of a completely fetched variable length field should return HIVE_NO_MORE_DATA\n",
      connection, 0);

  // Clean up table
  if (dropTable(connection, table_name) == HIVE_ERROR) {
    DBCloseConnection(connection, err_buf, sizeof(err_buf));
    return 0;
  }

  // Close the handles
  retval = DBCloseResultSet(resultset, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBCloseResultSet failed: %s\n",
      err_buf, connection, 0);
  retval = DBCloseConnection(connection, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG(retval == HIVE_ERROR,
      "DBDisconnect failed: %s\n",
      err_buf, 0);

  return 1;
}

int meta_data_function_test() {
  fprintf(stderr, "Running %s...\n", __FUNCTION__);
  char err_buf[MAX_HIVE_ERR_MSG_LEN];
  const char* table_name = "ehwang_tmp_test";
  HiveReturn retval;
  char query[MAX_QUERY_LEN];
  char field[MAX_FIELD_LEN];
  int has_results;
  int int_buffer;
  size_t col_count;
  size_t col_len;
  size_t data_byte_size;
  int is_null_value;
  HiveResultSet* resultset;

  HiveConnection* connection = DBOpenConnection(DEFAULT_DATABASE, DEFAULT_HOST, atoi(DEFAULT_PORT),
                                                atoi(DEFAULT_FRAMED), err_buf, sizeof(err_buf));
  assert(connection != NULL); /* If this fails, make sure that Hive server is running with the connect parameter arguments */

  // Drop pre-existing tables of the same name
  if (dropTable(connection, table_name) == HIVE_ERROR) {
    DBCloseConnection(connection, err_buf, sizeof(err_buf));
    return 0;
  }

  // Create the table
  sprintf(query, "CREATE TABLE %s (key int, value string)", table_name);
  retval = DBExecute(connection, query, NULL, 10, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBExecute failed: %s\n",
      err_buf, connection, 0);

  // Test DBTables
  retval = DBTables(connection, table_name, &resultset, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBTables failed: %s\n",
      err_buf, connection, 0);
  retval = DBHasResults(resultset, &has_results, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBHasResults failed: %s\n",
      err_buf, connection, 0);
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(!has_results,
      "DBTables could not find table '%s'\n",
      table_name, connection, 0);

  retval = DBGetColumnCount(resultset, &col_count, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBGetColumnCount failed: '%s'\n",
      err_buf, connection, 0);
  /* The DBTables function should always return a result set with exactly 5 columns */
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(col_count != 5,
      "Column count not equal to five: %zu\n",
      col_count, connection, 0);

  // Fetch row
  retval = DBFetch(resultset, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBFetch failed: %s\n",
      err_buf, connection, 0);
  RETURN_ON_ASSERT_NO_ARG_CLOSE(retval == HIVE_NO_MORE_DATA,
      "DBFetch failed: Could not fetch the only row\n",
      connection, 0);

  // Check row data
  // Index 2 (a.k.a column 3) in a row will always contain the name of the table
  retval = DBGetFieldAsCString(resultset, 2, field, sizeof(field), &data_byte_size, &is_null_value,
                               err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBGetFieldAsCString failed: %s\n",
      err_buf, connection, 0);
  RETURN_ON_ASSERT_TWO_ARG_CLOSE(strcmp(field, table_name) != 0,
      "Tables do not have the same name: table_name:%s, field:%s\n",
      table_name, field, connection, 0);

  retval = DBGetFieldDataLen(resultset, 2, &col_len, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_NO_ARG_CLOSE(retval == HIVE_ERROR,
      "DBGetFieldDataLen failed: Could not get the strlen\n",
      connection, 0);
  RETURN_ON_ASSERT_TWO_ARG_CLOSE(col_len != strlen(field),
      "DBGetFieldDataLen failed: Returned length (%zu) was not the same as table_name (%zu)\n",
      col_len, strlen(field), connection, 0);

  // Fetch row (check that there is nothing else to fetch)
  retval = DBFetch(resultset, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBFetch failed: %s\n",
      err_buf, connection, 0);
  RETURN_ON_ASSERT_NO_ARG_CLOSE(retval != HIVE_NO_MORE_DATA,
      "DBFetch failed: Only one row, but fetched two\n",
      connection, 0);

  // Close the resultset
  retval = DBCloseResultSet(resultset, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBCloseResultSet failed: %s\n",
      err_buf, connection, 0);

  // Test DBColumns

  // Match all columns in created table
  retval = DBColumns(connection, &dummyHiveTypeConverter, table_name, "*", &resultset, err_buf,
                     sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBColumns failed: %s\n",
      err_buf, connection, 0);

  retval = DBHasResults(resultset, &has_results, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBHasResults failed: %s\n",
      err_buf, connection, 0);
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(!has_results,
      "DBColumns could not find columns for table '%s'\n",
      table_name, connection, 0);

  retval = DBGetColumnCount(resultset, &col_count, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBGetColumnCount failed: '%s'\n",
      err_buf, connection, 0);
  /* The DBColumns function should always return a result set with exactly 18 columns */
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(col_count != 18,
      "Column count not equal to 18: %zu\n",
      col_count, connection, 0);

  // Fetch first row
  retval = DBFetch(resultset, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBFetch failed: %s\n",
      err_buf, connection, 0);
  RETURN_ON_ASSERT_NO_ARG_CLOSE(retval == HIVE_NO_MORE_DATA,
      "DBFetch failed: Could not fetch the only row\n",
      connection, 0);

  // Check first row data
  // Index 2 (a.k.a column 3) in a row will always contain the name of the table
  retval = DBGetFieldAsCString(resultset, 2, field, sizeof(field), &data_byte_size, &is_null_value,
                               err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBGetFieldAsCString failed: %s\n",
      err_buf, connection, 0);
  RETURN_ON_ASSERT_TWO_ARG_CLOSE(strcmp(field, table_name) != 0,
      "Tables do not have the same name: table_name:%s, field:%s\n",
      table_name, field, connection, 0);

  retval = DBGetFieldDataLen(resultset, 2, &col_len, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_NO_ARG_CLOSE(retval == HIVE_ERROR,
      "DBGetFieldDataLen failed: Could not get the strlen\n",
      connection, 0);
  RETURN_ON_ASSERT_TWO_ARG_CLOSE(col_len != strlen(field),
      "DBGetFieldDataLen failed: Returned length (%zu) was not the same as table_name (%zu)\n",
      col_len, strlen(field), connection, 0);

  // Index 3 (a.k.a column 4) in a row will always contain the name of the column
  retval = DBGetFieldAsCString(resultset, 3, field, sizeof(field), &data_byte_size, &is_null_value,
                               err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBGetFieldAsCString failed: %s\n",
      err_buf, connection, 0);
  RETURN_ON_ASSERT_TWO_ARG_CLOSE(strcmp(field, "key") != 0,
      "Columns do not have the same name: column_name:%s, field:%s\n",
      "key", field, connection, 0);
  retval = DBGetFieldDataLen(resultset, 3, &col_len, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_NO_ARG_CLOSE(retval == HIVE_ERROR,
      "DBGetFieldDataLen failed: Could not get the strlen\n",
      connection, 0);
  RETURN_ON_ASSERT_TWO_ARG_CLOSE(col_len != strlen(field),
      "DBGetFieldDataLen failed: Returned length (%zu) was not the same as table_name (%zu)\n",
      col_len, strlen(field), connection, 0);

  // Index 4 (a.k.a column 5) in a row will always contain the SQL data type value
  retval = DBGetFieldAsInt(resultset, 4, &int_buffer, &is_null_value, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBGetFieldAsInt failed: %s\n",
      err_buf, connection, 0);
  RETURN_ON_ASSERT_TWO_ARG_CLOSE(int_buffer != 1,
      "Wrong converted SQL type: expected=%i, received=%i\n",
      1, int_buffer, connection, 0);

  // Index 13 (a.k.a column 14) in a row will also always contain the SQL data type value
  retval = DBGetFieldAsInt(resultset, 13, &int_buffer, &is_null_value, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBGetFieldAsInt failed: %s\n",
      err_buf, connection, 0);
  RETURN_ON_ASSERT_TWO_ARG_CLOSE(int_buffer != 1,
      "Wrong converted SQL data type: expected=%i, received=%i\n",
      1, int_buffer, connection, 0);

  // Index 16 (a.k.a column 17) in a row will always contain the column ordinal position
  retval = DBGetFieldAsInt(resultset, 16, &int_buffer, &is_null_value, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBGetFieldAsInt failed: %s\n",
      err_buf, connection, 0);
  RETURN_ON_ASSERT_TWO_ARG_CLOSE(int_buffer != 1,
      "Wrong ordinal position: expected=%i, received=%i\n",
      1, int_buffer, connection, 0);

  // Fetch second row
  retval = DBFetch(resultset, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBFetch failed: %s\n",
      err_buf, connection, 0);
  RETURN_ON_ASSERT_NO_ARG_CLOSE(retval == HIVE_NO_MORE_DATA,
      "DBFetch failed: Could not fetch the only row\n",
      connection, 0);

  // Check second row data
  // Index 2 (a.k.a column 3) in a row will always contain the name of the table
  retval = DBGetFieldAsCString(resultset, 2, field, sizeof(field), &data_byte_size, &is_null_value,
                               err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBGetFieldAsCString failed: %s\n",
      err_buf, connection, 0);
  RETURN_ON_ASSERT_TWO_ARG_CLOSE(strcmp(field, table_name) != 0,
      "Tables do not have the same name: table_name:%s, field:%s\n",
      table_name, field, connection, 0);

  retval = DBGetFieldDataLen(resultset, 2, &col_len, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_NO_ARG_CLOSE(retval == HIVE_ERROR,
      "DBGetFieldDataLen failed: Could not get the strlen\n",
      connection, 0);
  RETURN_ON_ASSERT_TWO_ARG_CLOSE(col_len != strlen(field),
      "DBGetFieldDataLen failed: Returned length (%zu) was not the same as table_name (%zu)\n",
      col_len, strlen(field), connection, 0);

  // Index 3 (a.k.a column 4) in a row will always contain the name of the column
  retval = DBGetFieldAsCString(resultset, 3, field, sizeof(field), &data_byte_size, &is_null_value,
                               err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBGetFieldAsCString failed: %s\n",
      err_buf, connection, 0);
  RETURN_ON_ASSERT_TWO_ARG_CLOSE(strcmp(field, "value") != 0,
      "Columns do not have the same name: column_name:%s, field:%s\n",
      "key", field, connection, 0);

  retval = DBGetFieldDataLen(resultset, 3, &col_len, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_NO_ARG_CLOSE(retval == HIVE_ERROR,
      "DBGetFieldDataLen failed: Could not get the strlen\n",
      connection, 0);
  RETURN_ON_ASSERT_TWO_ARG_CLOSE(col_len != strlen(field),
      "DBGetFieldDataLen failed: Returned length (%zu) was not the same as table_name (%zu)\n",
      col_len, strlen(field), connection, 0);

  // Index 4 (a.k.a column 5) in a row will always contain the SQL data type value
  retval = DBGetFieldAsInt(resultset, 4, &int_buffer, &is_null_value, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBGetFieldAsInt failed: %s\n",
      err_buf, connection, 0);
  RETURN_ON_ASSERT_TWO_ARG_CLOSE(int_buffer != 1,
      "Wrong converted SQL type: expected=%i, received=%i\n",
      1, int_buffer, connection, 0);

  // Index 13 (a.k.a column 14) in a row will also always contain the SQL data type value
  retval = DBGetFieldAsInt(resultset, 13, &int_buffer, &is_null_value, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBGetFieldAsInt failed: %s\n",
      err_buf, connection, 0);
  RETURN_ON_ASSERT_TWO_ARG_CLOSE(int_buffer != 1,
      "Wrong converted SQL data type: expected=%i, received=%i\n",
      1, int_buffer, connection, 0);

  // Index 16 (a.k.a column 17) in a row will always contain the column ordinal position
  retval = DBGetFieldAsInt(resultset, 16, &int_buffer, &is_null_value, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBGetFieldAsInt failed: %s\n",
      err_buf, connection, 0);
  RETURN_ON_ASSERT_TWO_ARG_CLOSE(int_buffer != 2,
      "Wrong ordinal position: expected=%i, received=%i\n",
      2, int_buffer, connection, 0);

  // Fetch row (check that there is nothing else to fetch)
  retval = DBFetch(resultset, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBFetch failed: %s\n",
      err_buf, connection, 0);
  RETURN_ON_ASSERT_NO_ARG_CLOSE(retval != HIVE_NO_MORE_DATA,
      "DBFetch failed: Only one row, but fetched two\n",
      connection, 0);

  // Close the resultset
  retval = DBCloseResultSet(resultset, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG_CLOSE(retval == HIVE_ERROR,
      "DBCloseResultSet failed: %s\n",
      err_buf, connection, 0);

  // Clean up table
  if (dropTable(connection, table_name) == HIVE_ERROR) {
    DBCloseConnection(connection, err_buf, sizeof(err_buf));
    return 0;
  }

  // Close the connection
  retval = DBCloseConnection(connection, err_buf, sizeof(err_buf));
  RETURN_ON_ASSERT_ONE_ARG(retval == HIVE_ERROR,
      "DBDisconnect failed: %s\n",
      err_buf, 0);
  return 1;
}

/**************************************************************************************************
 * MAIN FUNCTION
 **************************************************************************************************/

int main() {
  int failed = 0;
  fprintf(stderr, "\nStarting Hive Client C tests...\n\n");

  if (basic_connect_disconnect_test() == 0) {
    failed++;
    fprintf(stderr, "----FAILED basic_connect_disconnect_test!\n");
  }
  if (basic_query_exec_test() == 0) {
    failed++;
    fprintf(stderr, "----FAILED basic_query_exec_test!\n");
  }
  if (basic_fetch_test() == 0) {
    failed++;
    fprintf(stderr, "----FAILED basic_fetch_test!\n");
  }
  if (show_tables_test() == 0) {
    failed++;
    fprintf(stderr, "----FAILED show_tables_test!\n");
  }
  if (query_fetch_test() == 0) {
    failed++;
    fprintf(stderr, "----FAILED query_fetch_test!\n");
  }
  if (numeric_range_test() == 0) {
    failed++;
    fprintf(stderr, "----FAILED numeric_range_test!\n");
  }
  if (field_multifetch_test() == 0) {
    failed++;
    fprintf(stderr, "----FAILED field_multifetch_test!\n");
  }
  if (meta_data_function_test() == 0) {
    failed++;
    fprintf(stderr, "----FAILED meta_data_function_test!\n");
  }

  if (failed == 0) {
    fprintf(stderr, "\nALL HIVE CLIENT TESTS PASSED!\n\n");
    return 0;
  } else {
    fprintf(stderr, "\nHIVE CLIENT TEST FAILURE: %i test(s) failed.\n\n", failed);
    return 1;
  }
}