runner.c

#include <assert.h>
#include <float.h>
#include <limits.h>
#include <math.h>
#include <stdalign.h>
#include <stdlib.h>
#include <string.h>

#include "runner.h"

void exports_runner_run() {
  {
    uint8_t list[] = {};
    runner_list_u8_t a;
    a.ptr = list;
    a.len = 0;
    test_lists_to_test_empty_list_param(&a);
  }

  {
    runner_string_t a;
    runner_string_set(&a, "");
    test_lists_to_test_empty_string_param(&a);
  }

  {
    runner_list_u8_t a;
    test_lists_to_test_empty_list_result(&a);
    assert(a.len == 0);
  }

  {
    runner_string_t a;
    test_lists_to_test_empty_string_result(&a);
    assert(a.len == 0);
  }

  {
    uint8_t list[] = {1, 2, 3, 4};
    runner_list_u8_t a;
    a.ptr = list;
    a.len = 4;
    test_lists_to_test_list_param(&a);
  }

  {
    runner_string_t a;
    runner_string_set(&a, "foo");
    test_lists_to_test_list_param2(&a);
  }

  {
    runner_string_t list[3];
    runner_string_set(&list[0], "foo");
    runner_string_set(&list[1], "bar");
    runner_string_set(&list[2], "baz");
    runner_list_string_t a;
    a.ptr = list;
    a.len = 3;
    test_lists_to_test_list_param3(&a);
  }

  {
    runner_string_t list1[2];
    runner_string_t list2[1];
    runner_string_set(&list1[0], "foo");
    runner_string_set(&list1[1], "bar");
    runner_string_set(&list2[0], "baz");
    runner_list_list_string_t a;
    a.ptr[0].len = 2;
    a.ptr[0].ptr = list1;
    a.ptr[1].len = 1;
    a.ptr[1].ptr = list2;
    a.len = 2;
    test_lists_to_test_list_param4(&a);
  }

  {
    runner_tuple3_u8_u32_u8_t data[2];
    data[0].f0 = 1;
    data[0].f1 = 2;
    data[0].f2 = 3;
    data[1].f0 = 4;
    data[1].f1 = 5;
    data[1].f2 = 6;
    runner_list_tuple3_u8_u32_u8_t a;
    a.len = 2;
    a.ptr = data;
    test_lists_to_test_list_param5(&a);
  }

  {
    runner_list_u8_t a;
    test_lists_to_test_list_result(&a);
    assert(a.len == 5);
    assert(memcmp(a.ptr, "\x01\x02\x03\x04\x05", 5) == 0);
    runner_list_u8_free(&a);
  }

  {
    runner_string_t a;
    test_lists_to_test_list_result2(&a);
    assert(a.len == 6);
    assert(memcmp(a.ptr, "hello!", 6) == 0);
    runner_string_free(&a);
  }

  {
    runner_list_string_t a;
    test_lists_to_test_list_result3(&a);
    assert(a.len == 2);
    assert(a.ptr[0].len == 6);
    assert(a.ptr[1].len == 6);
    assert(memcmp(a.ptr[0].ptr, "hello,", 6) == 0);
    assert(memcmp(a.ptr[1].ptr, "world!", 6) == 0);
    runner_list_string_free(&a);
  }

  {
    runner_list_u8_t a, b;
    a.len = 0;
    a.ptr = (unsigned char*) "";
    test_lists_to_test_list_roundtrip(&a, &b);
    assert(b.len == a.len);
    assert(memcmp(b.ptr, a.ptr, a.len) == 0);
    runner_list_u8_free(&b);

    a.len = 1;
    a.ptr = (unsigned char*) "x";
    test_lists_to_test_list_roundtrip(&a, &b);
    assert(b.len == a.len);
    assert(memcmp(b.ptr, a.ptr, a.len) == 0);
    runner_list_u8_free(&b);

    a.len = 5;
    a.ptr = (unsigned char*) "hello";
    test_lists_to_test_list_roundtrip(&a, &b);
    assert(b.len == a.len);
    assert(memcmp(b.ptr, a.ptr, a.len) == 0);
    runner_list_u8_free(&b);
  }

  {
    runner_string_t a, b;
    runner_string_set(&a, "x");
    test_lists_to_test_string_roundtrip(&a, &b);
    assert(b.len == a.len);
    assert(memcmp(b.ptr, a.ptr, a.len) == 0);
    runner_string_free(&b);

    runner_string_set(&a, "");
    test_lists_to_test_string_roundtrip(&a, &b);
    assert(b.len == a.len);
    runner_string_free(&b);

    runner_string_set(&a, "hello");
    test_lists_to_test_string_roundtrip(&a, &b);
    assert(b.len == a.len);
    assert(memcmp(b.ptr, a.ptr, a.len) == 0);
    runner_string_free(&b);

    runner_string_set(&a, "hello ⚑ world");
    test_lists_to_test_string_roundtrip(&a, &b);
    assert(b.len == a.len);
    assert(memcmp(b.ptr, a.ptr, a.len) == 0);
    runner_string_free(&b);
  }

  {
    uint8_t u8[2] = {0, UCHAR_MAX};
    int8_t s8[2] = {SCHAR_MIN, SCHAR_MAX};
    runner_list_u8_t list_u8 = { u8, 2 };
    runner_list_s8_t list_s8 = { s8, 2 };
    runner_tuple2_list_u8_list_s8_t ret;
    test_lists_to_test_list_minmax8(&list_u8, &list_s8, &ret);
    assert(ret.f0.len == 2 && ret.f0.ptr[0] == 0 && ret.f0.ptr[1] == UCHAR_MAX);
    assert(ret.f1.len == 2 && ret.f1.ptr[0] == SCHAR_MIN && ret.f1.ptr[1] == SCHAR_MAX);
    runner_list_u8_free(&ret.f0);
    runner_list_s8_free(&ret.f1);
  }

  {
    uint16_t u16[2] = {0, USHRT_MAX};
    int16_t s16[2] = {SHRT_MIN, SHRT_MAX};
    runner_list_u16_t list_u16 = { u16, 2 };
    runner_list_s16_t list_s16 = { s16, 2 };
    runner_tuple2_list_u16_list_s16_t ret;
    test_lists_to_test_list_minmax16(&list_u16, &list_s16, &ret);
    assert(ret.f0.len == 2 && ret.f0.ptr[0] == 0 && ret.f0.ptr[1] == USHRT_MAX);
    assert(ret.f1.len == 2 && ret.f1.ptr[0] == SHRT_MIN && ret.f1.ptr[1] == SHRT_MAX);
    runner_list_u16_free(&ret.f0);
    runner_list_s16_free(&ret.f1);
  }

  {
    uint32_t u32[2] = {0, UINT_MAX};
    int32_t s32[2] = {INT_MIN, INT_MAX};
    runner_list_u32_t list_u32 = { u32, 2 };
    runner_list_s32_t list_s32 = { s32, 2 };
    runner_tuple2_list_u32_list_s32_t ret;
    test_lists_to_test_list_minmax32(&list_u32, &list_s32, &ret);
    assert(ret.f0.len == 2 && ret.f0.ptr[0] == 0 && ret.f0.ptr[1] == UINT_MAX);
    assert(ret.f1.len == 2 && ret.f1.ptr[0] == INT_MIN && ret.f1.ptr[1] == INT_MAX);
    runner_list_u32_free(&ret.f0);
    runner_list_s32_free(&ret.f1);
  }

  {
    uint64_t u64[2] = {0, ULLONG_MAX};
    int64_t s64[2] = {LLONG_MIN, LLONG_MAX};
    runner_list_u64_t list_u64 = { u64, 2 };
    runner_list_s64_t list_s64 = { s64, 2 };
    runner_tuple2_list_u64_list_s64_t ret;
    test_lists_to_test_list_minmax64(&list_u64, &list_s64, &ret);
    assert(ret.f0.len == 2 && ret.f0.ptr[0] == 0 && ret.f0.ptr[1] == ULLONG_MAX);
    assert(ret.f1.len == 2 && ret.f1.ptr[0] == LLONG_MIN && ret.f1.ptr[1] == LLONG_MAX);
    runner_list_u64_free(&ret.f0);
    runner_list_s64_free(&ret.f1);
  }

  {
    float f32[4] = {-FLT_MAX, FLT_MAX, -INFINITY, INFINITY};
    double f64[4] = {-DBL_MAX, DBL_MAX, -INFINITY, INFINITY};
    runner_list_f32_t list_f32 = { f32, 4 };
    runner_list_f64_t list_f64 = { f64, 4 };
    runner_tuple2_list_f32_list_f64_t ret;
    test_lists_to_test_list_minmax_float(&list_f32, &list_f64, &ret);
    assert(ret.f0.len == 4 && ret.f0.ptr[0] == -FLT_MAX && ret.f0.ptr[1] == FLT_MAX);
    assert(ret.f0.ptr[2] == -INFINITY && ret.f0.ptr[3] == INFINITY);
    assert(ret.f1.len == 4 && ret.f1.ptr[0] == -DBL_MAX && ret.f1.ptr[1] == DBL_MAX);
    assert(ret.f1.ptr[2] == -INFINITY && ret.f1.ptr[3] == INFINITY);
    runner_list_f32_free(&ret.f0);
    runner_list_f64_free(&ret.f1);
  }

  {
    runner_tuple2_string_list_u8_t headers_data[2];
    runner_string_set(&headers_data[0].f0, "Content-Type");
    uint8_t val0[] = "text/plain";
    headers_data[0].f1.ptr = val0;
    headers_data[0].f1.len = 10;

    runner_string_set(&headers_data[1].f0, "Content-Length");
    uint8_t val1[] = "9";
    headers_data[1].f1.ptr = val1;
    headers_data[1].f1.len = 1;

    runner_list_tuple2_string_list_u8_t headers = { headers_data, 2 };
    runner_list_tuple2_string_list_u8_t result;
    test_lists_to_test_wasi_http_headers_roundtrip(&headers, &result);

    assert(result.len == 2);
    assert(result.ptr[0].f0.len == 12);
    assert(memcmp(result.ptr[0].f0.ptr, "Content-Type", 12) == 0);
    assert(result.ptr[0].f1.len == 10);
    assert(memcmp(result.ptr[0].f1.ptr, "text/plain", 10) == 0);
    assert(result.ptr[1].f0.len == 14);
    assert(memcmp(result.ptr[1].f0.ptr, "Content-Length", 14) == 0);
    assert(result.ptr[1].f1.len == 1);
    assert(result.ptr[1].f1.ptr[0] == '9');

    runner_list_tuple2_string_list_u8_free(&result);
  }
}