Hu Chunming / vpt_ascend_arm

/*
 * ***** BEGIN LICENSE BLOCK *****
 * Version: MIT
 *
 * Portions created by Alan Antonuk are Copyright (c) 2012-2013
 * Alan Antonuk. All Rights Reserved.
 *
 * Portions created by VMware are Copyright (c) 2007-2012 VMware, Inc.
 * All Rights Reserved.
 *
 * Portions created by Tony Garnock-Jones are Copyright (c) 2009-2010
 * VMware, Inc. and Tony Garnock-Jones. All Rights Reserved.
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
 * files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use, copy,
 * modify, merge, publish, distribute, sublicense, and/or sell copies
 * of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 * ***** END LICENSE BLOCK *****
 */

#ifdef _MSC_VER
#define _USE_MATH_DEFINES
#define _CRT_SECURE_NO_WARNINGS
#endif

#include <errno.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <inttypes.h>

#include <amqp.h>

#include <math.h>

void die(const char *fmt, ...) {
  va_list ap;
  va_start(ap, fmt);
  vfprintf(stderr, fmt, ap);
  va_end(ap);
  fprintf(stderr, "\n");
  abort();
}

static void dump_indent(int indent, FILE *out) {
  int i;

  for (i = 0; i < indent; i++) {
    fputc(' ', out);
  }
}

static void dump_value(int indent, amqp_field_value_t v, FILE *out) {
  int i;

  dump_indent(indent, out);
  fputc(v.kind, out);

  switch (v.kind) {
    case AMQP_FIELD_KIND_BOOLEAN:
      fputs(v.value.boolean ? " true\n" : " false\n", out);
      break;

    case AMQP_FIELD_KIND_I8:
      fprintf(out, " %" PRId8 "\n", v.value.i8);
      break;

    case AMQP_FIELD_KIND_U8:
      fprintf(out, " %" PRIu8 "\n", v.value.u8);
      break;

    case AMQP_FIELD_KIND_I16:
      fprintf(out, " %" PRId16 "\n", v.value.i16);
      break;

    case AMQP_FIELD_KIND_U16:
      fprintf(out, " %" PRIu16 "\n", v.value.u16);
      break;

    case AMQP_FIELD_KIND_I32:
      fprintf(out, " %" PRId32 "\n", v.value.i32);
      break;

    case AMQP_FIELD_KIND_U32:
      fprintf(out, " %" PRIu32 "\n", v.value.u32);
      break;

    case AMQP_FIELD_KIND_I64:
      fprintf(out, " %" PRId64 "\n", v.value.i64);
      break;

    case AMQP_FIELD_KIND_F32:
      fprintf(out, " %g\n", (double)v.value.f32);
      break;

    case AMQP_FIELD_KIND_F64:
      fprintf(out, " %g\n", v.value.f64);
      break;

    case AMQP_FIELD_KIND_DECIMAL:
      fprintf(out, " %u:::%u\n", v.value.decimal.decimals,
              v.value.decimal.value);
      break;

    case AMQP_FIELD_KIND_UTF8:
      fprintf(out, " %.*s\n", (int)v.value.bytes.len,
              (char *)v.value.bytes.bytes);
      break;

    case AMQP_FIELD_KIND_BYTES:
      fputc(' ', out);
      for (i = 0; i < (int)v.value.bytes.len; i++) {
        fprintf(out, "%02x", ((char *)v.value.bytes.bytes)[i]);
      }

      fputc('\n', out);
      break;

    case AMQP_FIELD_KIND_ARRAY:
      fputc('\n', out);
      for (i = 0; i < v.value.array.num_entries; i++) {
        dump_value(indent + 2, v.value.array.entries[i], out);
      }

      break;

    case AMQP_FIELD_KIND_TIMESTAMP:
      fprintf(out, " %" PRIu64 "\n", v.value.u64);
      break;

    case AMQP_FIELD_KIND_TABLE:
      fputc('\n', out);
      for (i = 0; i < v.value.table.num_entries; i++) {
        dump_indent(indent + 2, out);
        fprintf(out, "%.*s ->\n", (int)v.value.table.entries[i].key.len,
                (char *)v.value.table.entries[i].key.bytes);
        dump_value(indent + 4, v.value.table.entries[i].value, out);
      }

      break;

    case AMQP_FIELD_KIND_VOID:
      fputc('\n', out);
      break;

    default:
      fprintf(out, "???\n");
      break;
  }
}

static void test_dump_value(FILE *out) {
  amqp_table_entry_t entries[8];
  amqp_table_t table;
  amqp_field_value_t val;

  entries[0].key = amqp_cstring_bytes("zebra");
  entries[0].value.kind = AMQP_FIELD_KIND_UTF8;
  entries[0].value.value.bytes = amqp_cstring_bytes("last");

  entries[1].key = amqp_cstring_bytes("aardvark");
  entries[1].value.kind = AMQP_FIELD_KIND_UTF8;
  entries[1].value.value.bytes = amqp_cstring_bytes("first");

  entries[2].key = amqp_cstring_bytes("middle");
  entries[2].value.kind = AMQP_FIELD_KIND_UTF8;
  entries[2].value.value.bytes = amqp_cstring_bytes("third");

  entries[3].key = amqp_cstring_bytes("number");
  entries[3].value.kind = AMQP_FIELD_KIND_I32;
  entries[3].value.value.i32 = 1234;

  entries[4].key = amqp_cstring_bytes("decimal");
  entries[4].value.kind = AMQP_FIELD_KIND_DECIMAL;
  entries[4].value.value.decimal.decimals = 2;
  entries[4].value.value.decimal.value = 1234;

  entries[5].key = amqp_cstring_bytes("time");
  entries[5].value.kind = AMQP_FIELD_KIND_TIMESTAMP;
  entries[5].value.value.u64 = 1234123412341234;

  entries[6].key = amqp_cstring_bytes("beta");
  entries[6].value.kind = AMQP_FIELD_KIND_UTF8;
  entries[6].value.value.bytes = amqp_cstring_bytes("second");

  entries[7].key = amqp_cstring_bytes("wombat");
  entries[7].value.kind = AMQP_FIELD_KIND_UTF8;
  entries[7].value.value.bytes = amqp_cstring_bytes("fourth");

  table.num_entries = 8;
  table.entries = entries;

  qsort(table.entries, table.num_entries, sizeof(amqp_table_entry_t),
        &amqp_table_entry_cmp);

  val.kind = AMQP_FIELD_KIND_TABLE;
  val.value.table = table;

  dump_value(0, val, out);
}

static uint8_t pre_encoded_table[] = {
    0x00, 0x00, 0x00, 0xff, 0x07, 0x6c, 0x6f, 0x6e, 0x67, 0x73, 0x74, 0x72,
    0x53, 0x00, 0x00, 0x00, 0x15, 0x48, 0x65, 0x72, 0x65, 0x20, 0x69, 0x73,
    0x20, 0x61, 0x20, 0x6c, 0x6f, 0x6e, 0x67, 0x20, 0x73, 0x74, 0x72, 0x69,
    0x6e, 0x67, 0x09, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x69, 0x6e, 0x74,
    0x49, 0x00, 0x00, 0x30, 0x39, 0x07, 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61,
    0x6c, 0x44, 0x03, 0x00, 0x01, 0xe2, 0x40, 0x09, 0x74, 0x69, 0x6d, 0x65,
    0x73, 0x74, 0x61, 0x6d, 0x70, 0x54, 0x00, 0x00, 0x63, 0xee, 0xa0, 0x53,
    0xc1, 0x94, 0x05, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x46, 0x00, 0x00, 0x00,
    0x1f, 0x03, 0x6f, 0x6e, 0x65, 0x49, 0x00, 0x00, 0xd4, 0x31, 0x03, 0x74,
    0x77, 0x6f, 0x53, 0x00, 0x00, 0x00, 0x0d, 0x41, 0x20, 0x6c, 0x6f, 0x6e,
    0x67, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x04, 0x62, 0x79, 0x74,
    0x65, 0x62, 0xff, 0x04, 0x6c, 0x6f, 0x6e, 0x67, 0x6c, 0x00, 0x00, 0x00,
    0x00, 0x49, 0x96, 0x02, 0xd2, 0x05, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x73,
    0x02, 0x8f, 0x04, 0x62, 0x6f, 0x6f, 0x6c, 0x74, 0x01, 0x06, 0x62, 0x69,
    0x6e, 0x61, 0x72, 0x79, 0x78, 0x00, 0x00, 0x00, 0x0f, 0x61, 0x20, 0x62,
    0x69, 0x6e, 0x61, 0x72, 0x79, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67,
    0x04, 0x76, 0x6f, 0x69, 0x64, 0x56, 0x05, 0x61, 0x72, 0x72, 0x61, 0x79,
    0x41, 0x00, 0x00, 0x00, 0x17, 0x49, 0x00, 0x00, 0xd4, 0x31, 0x53, 0x00,
    0x00, 0x00, 0x0d, 0x41, 0x20, 0x6c, 0x6f, 0x6e, 0x67, 0x20, 0x73, 0x74,
    0x72, 0x69, 0x6e, 0x67, 0x05, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x66, 0x40,
    0x49, 0x0f, 0xdb, 0x06, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x64, 0x40,
    0x09, 0x21, 0xfb, 0x54, 0x44, 0x2d, 0x18};

static void test_table_codec(FILE *out) {
  amqp_pool_t pool;
  int result;

  amqp_table_entry_t inner_entries[2];
  amqp_table_t inner_table;

  amqp_field_value_t inner_values[2];
  amqp_array_t inner_array;

  amqp_table_entry_t entries[14];
  amqp_table_t table;

  inner_entries[0].key = amqp_cstring_bytes("one");
  inner_entries[0].value.kind = AMQP_FIELD_KIND_I32;
  inner_entries[0].value.value.i32 = 54321;

  inner_entries[1].key = amqp_cstring_bytes("two");
  inner_entries[1].value.kind = AMQP_FIELD_KIND_UTF8;
  inner_entries[1].value.value.bytes = amqp_cstring_bytes("A long string");

  inner_table.num_entries = 2;
  inner_table.entries = inner_entries;

  inner_values[0].kind = AMQP_FIELD_KIND_I32;
  inner_values[0].value.i32 = 54321;

  inner_values[1].kind = AMQP_FIELD_KIND_UTF8;
  inner_values[1].value.bytes = amqp_cstring_bytes("A long string");

  inner_array.num_entries = 2;
  inner_array.entries = inner_values;

  entries[0].key = amqp_cstring_bytes("longstr");
  entries[0].value.kind = AMQP_FIELD_KIND_UTF8;
  entries[0].value.value.bytes = amqp_cstring_bytes("Here is a long string");

  entries[1].key = amqp_cstring_bytes("signedint");
  entries[1].value.kind = AMQP_FIELD_KIND_I32;
  entries[1].value.value.i32 = 12345;

  entries[2].key = amqp_cstring_bytes("decimal");
  entries[2].value.kind = AMQP_FIELD_KIND_DECIMAL;
  entries[2].value.value.decimal.decimals = 3;
  entries[2].value.value.decimal.value = 123456;

  entries[3].key = amqp_cstring_bytes("timestamp");
  entries[3].value.kind = AMQP_FIELD_KIND_TIMESTAMP;
  entries[3].value.value.u64 = 109876543209876;

  entries[4].key = amqp_cstring_bytes("table");
  entries[4].value.kind = AMQP_FIELD_KIND_TABLE;
  entries[4].value.value.table = inner_table;

  entries[5].key = amqp_cstring_bytes("byte");
  entries[5].value.kind = AMQP_FIELD_KIND_I8;
  entries[5].value.value.i8 = (int8_t)-1;

  entries[6].key = amqp_cstring_bytes("long");
  entries[6].value.kind = AMQP_FIELD_KIND_I64;
  entries[6].value.value.i64 = 1234567890;

  entries[7].key = amqp_cstring_bytes("short");
  entries[7].value.kind = AMQP_FIELD_KIND_I16;
  entries[7].value.value.i16 = 655;

  entries[8].key = amqp_cstring_bytes("bool");
  entries[8].value.kind = AMQP_FIELD_KIND_BOOLEAN;
  entries[8].value.value.boolean = 1;

  entries[9].key = amqp_cstring_bytes("binary");
  entries[9].value.kind = AMQP_FIELD_KIND_BYTES;
  entries[9].value.value.bytes = amqp_cstring_bytes("a binary string");

  entries[10].key = amqp_cstring_bytes("void");
  entries[10].value.kind = AMQP_FIELD_KIND_VOID;

  entries[11].key = amqp_cstring_bytes("array");
  entries[11].value.kind = AMQP_FIELD_KIND_ARRAY;
  entries[11].value.value.array = inner_array;

  entries[12].key = amqp_cstring_bytes("float");
  entries[12].value.kind = AMQP_FIELD_KIND_F32;
  entries[12].value.value.f32 = (float)M_PI;

  entries[13].key = amqp_cstring_bytes("double");
  entries[13].value.kind = AMQP_FIELD_KIND_F64;
  entries[13].value.value.f64 = M_PI;

  table.num_entries = 14;
  table.entries = entries;

  fprintf(out, "AAAAAAAAAA\n");

  {
    amqp_field_value_t val;
    val.kind = AMQP_FIELD_KIND_TABLE;
    val.value.table = table;
    dump_value(0, val, out);
  }

  init_amqp_pool(&pool, 4096);

  {
    amqp_table_t decoded;
    size_t decoding_offset = 0;
    amqp_bytes_t decoding_bytes;
    decoding_bytes.len = sizeof(pre_encoded_table);
    decoding_bytes.bytes = pre_encoded_table;

    result =
        amqp_decode_table(decoding_bytes, &pool, &decoded, &decoding_offset);
    if (result < 0) {
      die("Table decoding failed: %s", amqp_error_string2(result));
    }

    fprintf(out, "BBBBBBBBBB\n");

    {
      amqp_field_value_t val;
      val.kind = AMQP_FIELD_KIND_TABLE;
      val.value.table = decoded;

      dump_value(0, val, out);
    }
  }

  {
    uint8_t encoding_buffer[4096];
    amqp_bytes_t encoding_result;
    size_t offset = 0;

    memset(&encoding_buffer[0], 0, sizeof(encoding_buffer));
    encoding_result.len = sizeof(encoding_buffer);
    encoding_result.bytes = &encoding_buffer[0];

    result = amqp_encode_table(encoding_result, &table, &offset);
    if (result < 0) {
      die("Table encoding failed: %s", amqp_error_string2(result));
    }

    if (offset != sizeof(pre_encoded_table))
      die("Offset should be %ld, was %ld", (long)sizeof(pre_encoded_table),
          (long)offset);

    result = memcmp(pre_encoded_table, encoding_buffer, offset);
    if (result != 0) {
      die("Table encoding differed", result);
    }
  }

  empty_amqp_pool(&pool);
}

#define CHUNK_SIZE 4096

static int compare_files(FILE *f1_in, FILE *f2_in) {
  char f1_buf[CHUNK_SIZE];
  char f2_buf[CHUNK_SIZE];
  int res;

  rewind(f1_in);
  rewind(f2_in);

  for (;;) {
    size_t f1_got = fread(f1_buf, 1, CHUNK_SIZE, f1_in);
    size_t f2_got = fread(f2_buf, 1, CHUNK_SIZE, f2_in);
    res = memcmp(f1_buf, f2_buf, f1_got < f2_got ? f1_got : f2_got);

    if (res) {
      break;
    }

    if (f1_got < CHUNK_SIZE || f2_got < CHUNK_SIZE) {
      if (f1_got != f2_got) {
        res = (f1_got < f2_got ? -1 : 1);
      }
      break;
    }
  }

  return res;
}

const char *expected_file_name = "tests/test_tables.expected";

int main(void) {
  char *srcdir = getenv("srcdir");
  FILE *out, *expected = NULL;
  char *expected_path;

  out = tmpfile();
  if (out == NULL) {
    die("failed to create temporary file: %s", strerror(errno));
  }

  test_table_codec(out);
  fprintf(out, "----------\n");
  test_dump_value(out);

  if (srcdir == NULL) {
    srcdir = ".";
  }

  expected_path = malloc(strlen(srcdir) + strlen(expected_file_name) + 2);
  if (!expected_path) {
    die("out of memory");
  }
  sprintf(expected_path, "%s/%s", srcdir, expected_file_name);
  expected = fopen(expected_path, "r");
  if (!expected) {
    die("failed to open %s: %s", expected_path, strerror(errno));
  }

  if (compare_files(expected, out)) {
    die("output file did not have expected contents");
  }

  fclose(expected);
  free(expected_path);
  fclose(out);

  return 0;
}