/*
  Copyright 2011-2020 David Robillard <d@drobilla.net>

  Permission to use, copy, modify, and/or distribute this software for any
  purpose with or without fee is hereby granted, provided that the above
  copyright notice and this permission notice appear in all copies.

  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/

#undef NDEBUG

#include "serd/serd.h"

#include <assert.h>
#include <math.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define NS_XSD "http://www.w3.org/2001/XMLSchema#"
#define NS_RDF "http://www.w3.org/1999/02/22-rdf-syntax-ns#"

#if defined(__clang__)

#  define SERD_DISABLE_CONVERSION_WARNINGS                     \
    _Pragma("clang diagnostic push")                           \
    _Pragma("clang diagnostic ignored \"-Wconversion\"")       \
    _Pragma("clang diagnostic ignored \"-Wdouble-promotion\"") \
    _Pragma("clang diagnostic ignored \"-Wc11-extensions\"")

#  define SERD_RESTORE_WARNINGS _Pragma("clang diagnostic pop")

#elif defined(__GNUC__)

#  define SERD_DISABLE_CONVERSION_WARNINGS                   \
    _Pragma("GCC diagnostic push")                           \
    _Pragma("GCC diagnostic ignored \"-Wconversion\"")       \
    _Pragma("GCC diagnostic ignored \"-Wfloat-conversion\"") \
    _Pragma("GCC diagnostic ignored \"-Wdouble-promotion\"")

#  define SERD_RESTORE_WARNINGS _Pragma("GCC diagnostic pop")

#else

#  define SERD_DISABLE_CONVERSION_WARNINGS
#  define SERD_RESTORE_WARNINGS

#endif

static void
test_value(void)
{
  static const double double_one = 1.0;
  static const float  float_two  = 2.0f;

  SerdNode* const null_node   = serd_new_value(NULL, serd_nothing());
  SerdNode* const bool_node   = serd_new_value(NULL, serd_bool(false));
  SerdNode* const double_node = serd_new_value(NULL, serd_double(1.0));
  SerdNode* const float_node  = serd_new_value(NULL, serd_float(2.0f));
  SerdNode* const long_node   = serd_new_value(NULL, serd_long(3));
  SerdNode* const int_node    = serd_new_value(NULL, serd_int(4));
  SerdNode* const short_node  = serd_new_value(NULL, serd_short(5));
  SerdNode* const byte_node   = serd_new_value(NULL, serd_byte(6));
  SerdNode* const ulong_node  = serd_new_value(NULL, serd_ulong(7u));
  SerdNode* const uint_node   = serd_new_value(NULL, serd_uint(8u));
  SerdNode* const ushort_node = serd_new_value(NULL, serd_ushort(9u));
  SerdNode* const ubyte_node  = serd_new_value(NULL, serd_ubyte(10u));

  assert(!null_node);

  assert(!strcmp(serd_node_string(bool_node), "false"));
  assert(serd_get_value(bool_node).type == SERD_BOOL);
  assert(serd_get_value(bool_node).data.as_bool == false);

  assert(!strcmp(serd_node_string(double_node), "1.0E0"));
  assert(serd_get_value(double_node).type == SERD_DOUBLE);
  {
    const double double_value = serd_get_value(double_node).data.as_double;
    assert(!memcmp(&double_value, &double_one, sizeof(double)));
  }

  assert(!strcmp(serd_node_string(float_node), "2.0E0"));
  assert(serd_get_value(float_node).type == SERD_FLOAT);
  {
    const float float_value = serd_get_value(float_node).data.as_float;
    assert(!memcmp(&float_value, &float_two, sizeof(float)));
  }

  assert(!strcmp(serd_node_string(long_node), "3"));
  assert(serd_get_value(long_node).type == SERD_LONG);
  assert(serd_get_value(long_node).data.as_long == 3);

  assert(!strcmp(serd_node_string(int_node), "4"));
  assert(serd_get_value(int_node).type == SERD_INT);
  assert(serd_get_value(int_node).data.as_int == 4);

  assert(!strcmp(serd_node_string(short_node), "5"));
  assert(serd_get_value(short_node).type == SERD_SHORT);
  assert(serd_get_value(short_node).data.as_short == 5);

  assert(!strcmp(serd_node_string(byte_node), "6"));
  assert(serd_get_value(byte_node).type == SERD_BYTE);
  assert(serd_get_value(byte_node).data.as_byte == 6);

  assert(!strcmp(serd_node_string(ulong_node), "7"));
  assert(serd_get_value(ulong_node).type == SERD_ULONG);
  assert(serd_get_value(ulong_node).data.as_ulong == 7u);

  assert(!strcmp(serd_node_string(uint_node), "8"));
  assert(serd_get_value(uint_node).type == SERD_UINT);
  assert(serd_get_value(uint_node).data.as_uint == 8u);

  assert(!strcmp(serd_node_string(ushort_node), "9"));
  assert(serd_get_value(ushort_node).type == SERD_USHORT);
  assert(serd_get_value(ushort_node).data.as_ushort == 9u);

  assert(!strcmp(serd_node_string(ubyte_node), "10"));
  assert(serd_get_value(ubyte_node).type == SERD_UBYTE);
  assert(serd_get_value(ubyte_node).data.as_ubyte == 10u);

  serd_node_free(NULL, bool_node);
  serd_node_free(NULL, double_node);
  serd_node_free(NULL, float_node);
  serd_node_free(NULL, long_node);
  serd_node_free(NULL, int_node);
  serd_node_free(NULL, short_node);
  serd_node_free(NULL, byte_node);
  serd_node_free(NULL, ulong_node);
  serd_node_free(NULL, uint_node);
  serd_node_free(NULL, ushort_node);
  serd_node_free(NULL, ubyte_node);
}

static void
test_boolean(void)
{
  {
    SerdNode* const true_node = serd_new_value(NULL, serd_bool(true));
    assert(true_node);
    assert(!strcmp(serd_node_string(true_node), "true"));
    assert(serd_get_value(true_node).data.as_bool);

    const SerdNode* const true_datatype = serd_node_datatype(true_node);
    assert(true_datatype);
    assert(!strcmp(serd_node_string(true_datatype), NS_XSD "boolean"));
    serd_node_free(NULL, true_node);
  }
  {
    SerdNode* const false_node = serd_new_value(NULL, serd_bool(false));
    assert(false_node);
    assert(!strcmp(serd_node_string(false_node), "false"));
    assert(!serd_get_value(false_node).data.as_bool);

    const SerdNode* const false_datatype = serd_node_datatype(false_node);
    assert(false_datatype);
    assert(!strcmp(serd_node_string(false_datatype), NS_XSD "boolean"));
    serd_node_free(NULL, false_node);
  }
}

static void
check_get_bool(const char*         string,
               const char*         datatype_uri,
               const bool          lossy,
               const SerdValueType value_type,
               const bool          expected)
{
  SerdNode* const node = serd_new_literal(
    NULL, SERD_STRING(string), SERD_HAS_DATATYPE, SERD_STRING(datatype_uri));

  assert(node);

  const SerdValue value = serd_get_value_as(node, SERD_BOOL, lossy);

  assert(value.type == value_type);
  assert(value.data.as_bool == expected);

  serd_node_free(NULL, node);
}

static void
test_get_bool(void)
{
  check_get_bool("false", NS_XSD "boolean", false, SERD_BOOL, false);
  check_get_bool("true", NS_XSD "boolean", false, SERD_BOOL, true);
  check_get_bool("0", NS_XSD "boolean", false, SERD_BOOL, false);
  check_get_bool("1", NS_XSD "boolean", false, SERD_BOOL, true);
  check_get_bool("0", NS_XSD "integer", false, SERD_BOOL, false);
  check_get_bool("1", NS_XSD "integer", false, SERD_BOOL, true);
  check_get_bool("0.0", NS_XSD "double", false, SERD_BOOL, false);
  check_get_bool("1.0", NS_XSD "double", false, SERD_BOOL, true);

  check_get_bool("2", NS_XSD "integer", false, SERD_NOTHING, false);
  check_get_bool("1.5", NS_XSD "double", false, SERD_NOTHING, false);

  check_get_bool("2", NS_XSD "integer", true, SERD_BOOL, true);
  check_get_bool("1.5", NS_XSD "double", true, SERD_BOOL, true);

  check_get_bool("unknown", NS_XSD "string", true, SERD_NOTHING, false);
  check_get_bool("!invalid", NS_XSD "long", true, SERD_NOTHING, false);
}

static void
test_decimal(void)
{
  const double test_values[] = {
    0.0, 9.0, 10.0, .01, 2.05, -16.00001, 5.000000005, 0.0000000001};

  static const char* const test_strings[] = {"0.0",
                                             "9.0",
                                             "10.0",
                                             "0.01",
                                             "2.05",
                                             "-16.00001",
                                             "5.000000005",
                                             "0.0000000001"};

  for (size_t i = 0; i < sizeof(test_values) / sizeof(double); ++i) {
    SerdNode*   node     = serd_new_decimal(NULL, test_values[i]);
    const char* node_str = serd_node_string(node);
    assert(!strcmp(node_str, test_strings[i]));

    const size_t len = strlen(node_str);
    assert(serd_node_length(node) == len);

    const SerdNode* const datatype = serd_node_datatype(node);
    assert(datatype);
    assert(!strcmp(serd_node_string(datatype), NS_XSD "decimal"));

    const SerdValue value = serd_get_value(node);
    assert(!memcmp(&value.data.as_double, &test_values[i], sizeof(double)));
    serd_node_free(NULL, node);
  }
}

static void
test_double(void)
{
  const double test_values[]  = {0.0, -0.0, 1.2, -2.3, 4567890};
  const char*  test_strings[] = {
    "0.0E0", "-0.0E0", "1.2E0", "-2.3E0", "4.56789E6"};

  for (size_t i = 0; i < sizeof(test_values) / sizeof(double); ++i) {
    SerdNode*   node     = serd_new_value(NULL, serd_double(test_values[i]));
    const char* node_str = serd_node_string(node);
    assert(!strcmp(node_str, test_strings[i]));

    const size_t len = strlen(node_str);
    assert(serd_node_length(node) == len);

    const SerdNode* const datatype = serd_node_datatype(node);
    assert(datatype);
    assert(!strcmp(serd_node_string(datatype), NS_XSD "double"));

    const SerdValue value = serd_get_value(node);
    assert(!memcmp(&value.data.as_double, &test_values[i], sizeof(double)));
    serd_node_free(NULL, node);
  }
}

static void
check_get_double(const char*         string,
                 const char*         datatype_uri,
                 const bool          lossy,
                 const SerdValueType value_type,
                 const double        expected)
{
  SerdNode* const node = serd_new_literal(
    NULL, SERD_STRING(string), SERD_HAS_DATATYPE, SERD_STRING(datatype_uri));

  assert(node);

  const SerdValue value = serd_get_value_as(node, SERD_DOUBLE, lossy);

  assert(value.type == value_type);

  SERD_DISABLE_CONVERSION_WARNINGS

  assert(value_type == SERD_NOTHING ||
         ((isnan(value.data.as_double) && isnan(expected)) ||
          !memcmp(&value.data.as_double, &expected, sizeof(double))));

  SERD_RESTORE_WARNINGS

  serd_node_free(NULL, node);
}

static void
test_get_double(void)
{
  check_get_double("1.2", NS_XSD "double", false, SERD_DOUBLE, 1.2);
  check_get_double("-.5", NS_XSD "float", false, SERD_DOUBLE, -0.5);
  check_get_double("-67", NS_XSD "long", false, SERD_DOUBLE, -67.0);
  check_get_double("67", NS_XSD "unsignedLong", false, SERD_DOUBLE, 67.0);
  check_get_double("8.9", NS_XSD "decimal", false, SERD_DOUBLE, 8.9);
  check_get_double("false", NS_XSD "boolean", false, SERD_DOUBLE, 0.0);
  check_get_double("true", NS_XSD "boolean", false, SERD_DOUBLE, 1.0);

  SERD_DISABLE_CONVERSION_WARNINGS
  check_get_double("str", NS_XSD "string", true, SERD_NOTHING, NAN);
  check_get_double("!invalid", NS_XSD "long", true, SERD_NOTHING, NAN);
  check_get_double("D3AD", NS_XSD "hexBinary", true, SERD_NOTHING, NAN);
  check_get_double("Zm9v", NS_XSD "base64Binary", true, SERD_NOTHING, NAN);
  SERD_RESTORE_WARNINGS
}

static void
test_float(void)
{
  const float test_values[]  = {0.0f, -0.0f, 1.5f, -2.5f, 4567890.0f};
  const char* test_strings[] = {
    "0.0E0", "-0.0E0", "1.5E0", "-2.5E0", "4.56789E6"};

  for (size_t i = 0; i < sizeof(test_values) / sizeof(float); ++i) {
    SerdNode*   node     = serd_new_value(NULL, serd_float(test_values[i]));
    const char* node_str = serd_node_string(node);
    assert(!strcmp(node_str, test_strings[i]));

    const size_t len = strlen(node_str);
    assert(serd_node_length(node) == len);

    const SerdNode* const datatype = serd_node_datatype(node);
    assert(datatype);
    assert(!strcmp(serd_node_string(datatype), NS_XSD "float"));

    const SerdValue value = serd_get_value(node);
    assert(!memcmp(&value.data.as_float, &test_values[i], sizeof(float)));
    serd_node_free(NULL, node);
  }
}

static void
check_get_float(const char*         string,
                const char*         datatype_uri,
                const bool          lossy,
                const SerdValueType value_type,
                const float         expected)
{
  SerdNode* const node = serd_new_literal(
    NULL, SERD_STRING(string), SERD_HAS_DATATYPE, SERD_STRING(datatype_uri));

  assert(node);

  const SerdValue value = serd_get_value_as(node, SERD_FLOAT, lossy);

  assert(value.type == value_type);

  SERD_DISABLE_CONVERSION_WARNINGS

  assert(value_type == SERD_NOTHING ||
         ((isnan(value.data.as_float) && isnan(expected)) ||
          !memcmp(&value.data.as_float, &expected, sizeof(float))));

  SERD_RESTORE_WARNINGS

  serd_node_free(NULL, node);
}

static void
test_get_float(void)
{
  check_get_float("1.2", NS_XSD "float", false, SERD_FLOAT, 1.2f);
  check_get_float("-.5", NS_XSD "float", false, SERD_FLOAT, -0.5f);
  check_get_float("-67", NS_XSD "long", false, SERD_FLOAT, -67.0f);
  check_get_float("false", NS_XSD "boolean", false, SERD_FLOAT, 0.0f);
  check_get_float("true", NS_XSD "boolean", false, SERD_FLOAT, 1.0f);

  check_get_float("1.5", NS_XSD "decimal", true, SERD_FLOAT, 1.5f);

  SERD_DISABLE_CONVERSION_WARNINGS
  check_get_float("str", NS_XSD "string", true, SERD_NOTHING, NAN);
  check_get_float("!invalid", NS_XSD "long", true, SERD_NOTHING, NAN);
  check_get_float("D3AD", NS_XSD "hexBinary", true, SERD_NOTHING, NAN);
  check_get_float("Zm9v", NS_XSD "base64Binary", true, SERD_NOTHING, NAN);
  SERD_RESTORE_WARNINGS
}

static void
test_integer(void)
{
  const int64_t test_values[]  = {0, -0, -23, 23, -12340, 1000, -1000};
  const char*   test_strings[] = {
    "0", "0", "-23", "23", "-12340", "1000", "-1000"};

  for (size_t i = 0; i < sizeof(test_values) / sizeof(double); ++i) {
    SerdNode*   node     = serd_new_integer(NULL, test_values[i]);
    const char* node_str = serd_node_string(node);
    assert(!strcmp(node_str, test_strings[i]));
    const size_t len = strlen(node_str);
    assert(serd_node_length(node) == len);

    const SerdNode* const datatype = serd_node_datatype(node);
    assert(datatype);
    assert(!strcmp(serd_node_string(datatype), NS_XSD "integer"));

    assert(serd_get_value(node).data.as_long == test_values[i]);
    serd_node_free(NULL, node);
  }
}

static void
check_get_integer(const char*         string,
                  const char*         datatype_uri,
                  const bool          lossy,
                  const SerdValueType value_type,
                  const int64_t       expected)
{
  SerdNode* const node = serd_new_literal(
    NULL, SERD_STRING(string), SERD_HAS_DATATYPE, SERD_STRING(datatype_uri));

  assert(node);

  const SerdValue value = serd_get_value_as(node, SERD_LONG, lossy);

  assert(value.type == value_type);
  assert(value_type == SERD_NOTHING || value.data.as_long == expected);

  serd_node_free(NULL, node);
}

static void
test_get_integer(void)
{
  check_get_integer("12", NS_XSD "long", false, SERD_LONG, 12);
  check_get_integer("-34", NS_XSD "long", false, SERD_LONG, -34);
  check_get_integer("56", NS_XSD "integer", false, SERD_LONG, 56);
  check_get_integer("false", NS_XSD "boolean", false, SERD_LONG, 0);
  check_get_integer("true", NS_XSD "boolean", false, SERD_LONG, 1);
  check_get_integer("78.0", NS_XSD "decimal", false, SERD_LONG, 78);

  check_get_integer("0", NS_XSD "nonPositiveInteger", false, SERD_LONG, 0);
  check_get_integer("-1", NS_XSD "negativeInteger", false, SERD_LONG, -1);
  check_get_integer("2", NS_XSD "nonNegativeInteger", false, SERD_LONG, 2);
  check_get_integer("3", NS_XSD "positiveInteger", false, SERD_LONG, 3);

  check_get_integer("78.5", NS_XSD "decimal", false, SERD_NOTHING, 0);
  check_get_integer("78.5", NS_XSD "decimal", true, SERD_LONG, 78);

  check_get_integer("unknown", NS_XSD "string", true, SERD_NOTHING, 0);
  check_get_integer("!invalid", NS_XSD "long", true, SERD_NOTHING, 0);
}

static void
test_hex(void)
{
  assert(!serd_new_hex(NULL, &SERD_URI_NULL, 0));

  // Test valid hex blobs with a range of sizes
  for (size_t size = 1; size < 256; ++size) {
    uint8_t* const data = (uint8_t*)malloc(size);
    for (size_t i = 0; i < size; ++i) {
      data[i] = (uint8_t)((size + i) % 256);
    }

    SerdNode*    blob     = serd_new_hex(NULL, data, size);
    const char*  blob_str = serd_node_string(blob);
    const size_t max_size = serd_get_blob_size(blob);
    uint8_t*     out      = (uint8_t*)calloc(1, max_size);

    const SerdWriteResult r = serd_get_blob(blob, max_size, out);
    assert(r.status == SERD_SUCCESS);
    assert(r.count == size);
    assert(r.count <= max_size);
    assert(serd_node_length(blob) == strlen(blob_str));

    for (size_t i = 0; i < size; ++i) {
      assert(out[i] == data[i]);
    }

    const SerdNode* const datatype = serd_node_datatype(blob);
    assert(datatype);
    assert(!strcmp(serd_node_string(datatype), NS_XSD "hexBinary"));

    serd_node_free(NULL, blob);
    free(out);
    free(data);
  }
}

static void
test_base64(void)
{
  assert(!serd_new_base64(NULL, &SERD_URI_NULL, 0));

  // Test valid base64 blobs with a range of sizes
  for (size_t size = 1; size < 256; ++size) {
    uint8_t* const data = (uint8_t*)malloc(size);
    for (size_t i = 0; i < size; ++i) {
      data[i] = (uint8_t)((size + i) % 256);
    }

    SerdNode*    blob     = serd_new_base64(NULL, data, size);
    const char*  blob_str = serd_node_string(blob);
    const size_t max_size = serd_get_blob_size(blob);
    uint8_t*     out      = (uint8_t*)calloc(1, max_size);

    const SerdWriteResult r = serd_get_blob(blob, max_size, out);
    assert(r.status == SERD_SUCCESS);
    assert(r.count == size);
    assert(r.count <= max_size);
    assert(serd_node_length(blob) == strlen(blob_str));

    for (size_t i = 0; i < size; ++i) {
      assert(out[i] == data[i]);
    }

    const SerdNode* const datatype = serd_node_datatype(blob);
    assert(datatype);
    assert(!strcmp(serd_node_string(datatype), NS_XSD "base64Binary"));

    serd_node_free(NULL, blob);
    free(out);
    free(data);
  }
}

static void
check_get_blob(const char* string,
               const char* datatype_uri,
               const char* expected)
{
  SerdNode* const node = serd_new_literal(
    NULL, SERD_STRING(string), SERD_HAS_DATATYPE, SERD_STRING(datatype_uri));

  assert(node);

  const size_t max_size = serd_get_blob_size(node);
  char* const  decoded  = (char*)calloc(1, max_size + 1);

  const SerdWriteResult r = serd_get_blob(node, max_size, decoded);
  assert(!r.status);
  assert(r.count <= max_size);

  assert(!strcmp(decoded, expected));
  assert(strlen(decoded) <= max_size);

  free(decoded);
  serd_node_free(NULL, node);
}

static void
test_get_blob(void)
{
  check_get_blob("666F6F626172", NS_XSD "hexBinary", "foobar");
  check_get_blob("666F6F62", NS_XSD "hexBinary", "foob");

  check_get_blob("Zm9vYmFy", NS_XSD "base64Binary", "foobar");
  check_get_blob("Zm9vYg==", NS_XSD "base64Binary", "foob");
  check_get_blob(" \f\n\r\t\vZm9v \f\n\r\t\v", NS_XSD "base64Binary", "foo");

  char small[2] = {0};

  {
    SerdNode* const node = serd_new_literal(NULL,
                                            SERD_STRING("Zm9v"),
                                            SERD_HAS_DATATYPE,
                                            SERD_STRING(NS_XSD "base64Binary"));

    const SerdWriteResult r = serd_get_blob(node, sizeof(small), small);

    assert(r.status == SERD_OVERFLOW);
    serd_node_free(NULL, node);
  }
  {
    SerdNode* const string =
      serd_new_token(NULL, SERD_LITERAL, SERD_STRING("string"));

    assert(serd_get_blob_size(string) == 0u);

    const SerdWriteResult r = serd_get_blob(string, sizeof(small), small);

    assert(r.status == SERD_BAD_ARG);
    assert(r.count == 0u);
    serd_node_free(NULL, string);
  }
  {
    SerdNode* const unknown =
      serd_new_literal(NULL,
                       SERD_STRING("secret"),
                       SERD_HAS_DATATYPE,
                       SERD_STRING("http://example.org/Datatype"));

    assert(serd_get_blob_size(unknown) == 0u);

    const SerdWriteResult r = serd_get_blob(unknown, sizeof(small), small);

    assert(r.status == SERD_BAD_ARG);
    assert(r.count == 0u);
    serd_node_free(NULL, unknown);
  }
}

static void
test_node_equals(void)
{
  static const uint8_t replacement_char_str[] = {0xEF, 0xBF, 0xBD, 0};

  static const SerdStringView replacement_char = {
    (const char*)replacement_char_str, 3};

  SerdNode* lhs = serd_new_string(NULL, replacement_char);
  SerdNode* rhs = serd_new_string(NULL, SERD_STRING("123"));

  assert(serd_node_equals(lhs, lhs));
  assert(!serd_node_equals(lhs, rhs));

  assert(!serd_node_copy(NULL, NULL));

  serd_node_free(NULL, lhs);
  serd_node_free(NULL, rhs);
}

static void
test_node_from_syntax(void)
{
  SerdNode* const hello = serd_new_string(NULL, SERD_STRING("hello\""));
  assert(serd_node_length(hello) == 6);
  assert(!serd_node_flags(hello));
  assert(!strncmp(serd_node_string(hello), "hello\"", 6));
  serd_node_free(NULL, hello);
}

static void
test_node_from_substring(void)
{
  SerdNode* const a_b = serd_new_string(NULL, SERD_SUBSTRING("a\"bc", 3));
  assert(serd_node_length(a_b) == 3);
  assert(!serd_node_flags(a_b));
  assert(strlen(serd_node_string(a_b)) == 3);
  assert(!strncmp(serd_node_string(a_b), "a\"b", 3));
  serd_node_free(NULL, a_b);
}

static void
check_copy_equals(const SerdNode* const node)
{
  SerdNode* const copy = serd_node_copy(NULL, node);

  assert(serd_node_equals(node, copy));

  serd_node_free(NULL, copy);
}

static void
test_new(void)
{
  assert(!serd_node_new(NULL,
                        SERD_URI,
                        SERD_STRING("http://example.org/"),
                        SERD_HAS_DATATYPE,
                        SERD_STRING("http://example.org/uris/cant/have/me")));

  assert(!serd_node_new(NULL,
                        SERD_URI,
                        SERD_STRING("http://example.org/"),
                        SERD_HAS_LANGUAGE,
                        SERD_STRING("in-valid")));

  assert(!serd_node_new(NULL,
                        SERD_BLANK,
                        SERD_STRING("b0"),
                        SERD_HAS_DATATYPE,
                        SERD_STRING("http://example.org/uris/cant/have/me")));

  assert(!serd_node_new(NULL,
                        SERD_BLANK,
                        SERD_STRING("b0"),
                        SERD_HAS_LANGUAGE,
                        SERD_STRING("in-valid")));
}

static void
test_uri(void)
{
  static const SerdStringView base = SERD_STRING("http://example.org/base/");
  static const SerdStringView rel  = SERD_STRING("a/b");
  static const SerdStringView abs  = SERD_STRING("http://example.org/base/a/b");

  const SerdURIView base_uri = serd_parse_uri(base.buf);
  const SerdURIView rel_uri  = serd_parse_uri(rel.buf);
  const SerdURIView abs_uri  = serd_resolve_uri(rel_uri, base_uri);

  SerdNode* const from_string = serd_new_uri(NULL, abs);
  SerdNode* const from_uri    = serd_new_parsed_uri(NULL, abs_uri);

  assert(from_string);
  assert(from_uri);
  assert(!strcmp(serd_node_string(from_string), serd_node_string(from_uri)));

  serd_node_free(NULL, from_uri);
  serd_node_free(NULL, from_string);
}

static void
test_literal(void)
{
  static const SerdStringView hello_str = SERD_STRING("hello");
  static const SerdStringView empty_str = SERD_EMPTY_STRING();

  assert(!serd_new_literal(NULL,
                           hello_str,
                           SERD_HAS_DATATYPE | SERD_HAS_LANGUAGE,
                           SERD_STRING("whatever")));

  assert(!serd_new_literal(NULL, hello_str, SERD_HAS_DATATYPE, empty_str));
  assert(!serd_new_literal(NULL, hello_str, SERD_HAS_LANGUAGE, empty_str));

  assert(
    !serd_new_literal(NULL, hello_str, SERD_HAS_DATATYPE, SERD_STRING("Type")));
  assert(
    !serd_new_literal(NULL, hello_str, SERD_HAS_DATATYPE, SERD_STRING("de")));

  assert(
    !serd_new_literal(NULL, hello_str, SERD_HAS_LANGUAGE, SERD_STRING("3n")));
  assert(
    !serd_new_literal(NULL, hello_str, SERD_HAS_LANGUAGE, SERD_STRING("d3")));
  assert(
    !serd_new_literal(NULL, hello_str, SERD_HAS_LANGUAGE, SERD_STRING("d3")));
  assert(
    !serd_new_literal(NULL, hello_str, SERD_HAS_LANGUAGE, SERD_STRING("en-!")));

  SerdNode* hello2 = serd_new_string(NULL, SERD_STRING("hello\""));

  assert(serd_node_length(hello2) == 6 &&
         !strcmp(serd_node_string(hello2), "hello\""));

  check_copy_equals(hello2);

  assert(!serd_new_literal(NULL,
                           SERD_STRING("plain"),
                           SERD_HAS_DATATYPE,
                           SERD_STRING(NS_RDF "langString")));

  serd_node_free(NULL, hello2);

  const char* lang_lit_str = "\"Hello\"@en-ca";
  SerdNode*   sliced_lang_lit =
    serd_new_literal(NULL,
                     SERD_SUBSTRING(lang_lit_str + 1, 5),
                     SERD_HAS_LANGUAGE,
                     SERD_SUBSTRING(lang_lit_str + 8, 5));

  assert(!strcmp(serd_node_string(sliced_lang_lit), "Hello"));

  const SerdNode* const lang = serd_node_language(sliced_lang_lit);
  assert(lang);
  assert(!strcmp(serd_node_string(lang), "en-ca"));
  check_copy_equals(sliced_lang_lit);
  serd_node_free(NULL, sliced_lang_lit);

  const char* type_lit_str = "\"Hallo\"^^<http://example.org/Greeting>";
  SerdNode*   sliced_type_lit =
    serd_new_literal(NULL,
                     SERD_SUBSTRING(type_lit_str + 1, 5),
                     SERD_HAS_DATATYPE,
                     SERD_SUBSTRING(type_lit_str + 10, 27));

  assert(!strcmp(serd_node_string(sliced_type_lit), "Hallo"));

  const SerdNode* const datatype = serd_node_datatype(sliced_type_lit);
  assert(datatype);
  assert(!strcmp(serd_node_string(datatype), "http://example.org/Greeting"));
  serd_node_free(NULL, sliced_type_lit);
}

static void
test_blank(void)
{
  SerdNode* blank = serd_new_token(NULL, SERD_BLANK, SERD_STRING("b0"));
  assert(serd_node_length(blank) == 2);
  assert(serd_node_flags(blank) == 0);
  assert(!strcmp(serd_node_string(blank), "b0"));
  serd_node_free(NULL, blank);
}

static void
test_compare(void)
{
  SerdNode* xsd_short = serd_new_token(
    NULL, SERD_URI, SERD_STRING("http://www.w3.org/2001/XMLSchema#short"));

  SerdNode* angst = serd_new_string(NULL, SERD_STRING("angst"));

  SerdNode* angst_de = serd_new_literal(
    NULL, SERD_STRING("angst"), SERD_HAS_LANGUAGE, SERD_STRING("de"));

  SerdNode* angst_en = serd_new_literal(
    NULL, SERD_STRING("angst"), SERD_HAS_LANGUAGE, SERD_STRING("en"));

  SerdNode* hallo = serd_new_literal(
    NULL, SERD_STRING("Hallo"), SERD_HAS_LANGUAGE, SERD_STRING("de"));

  SerdNode* hello         = serd_new_string(NULL, SERD_STRING("Hello"));
  SerdNode* universe      = serd_new_string(NULL, SERD_STRING("Universe"));
  SerdNode* integer       = serd_new_integer(NULL, 4);
  SerdNode* short_integer = serd_new_value(NULL, serd_short(4));
  SerdNode* blank         = serd_new_token(NULL, SERD_BLANK, SERD_STRING("b1"));

  SerdNode* uri = serd_new_uri(NULL, SERD_STRING("http://example.org/"));

  SerdNode* aardvark =
    serd_new_literal(NULL,
                     SERD_STRING("alex"),
                     SERD_HAS_DATATYPE,
                     SERD_STRING("http://example.org/Aardvark"));

  SerdNode* badger = serd_new_literal(NULL,
                                      SERD_STRING("bobby"),
                                      SERD_HAS_DATATYPE,
                                      SERD_STRING("http://example.org/Badger"));

  // Types are ordered according to their SerdNodeType (more or less arbitrary)
  assert(serd_node_compare(hello, uri) < 0);
  assert(serd_node_compare(uri, blank) < 0);

  // If the types are the same, then strings are compared
  assert(serd_node_compare(hello, universe) < 0);

  // If literal strings are the same, languages or datatypes are compared
  assert(serd_node_compare(angst, angst_de) < 0);
  assert(serd_node_compare(angst_de, angst_en) < 0);
  assert(serd_node_compare(aardvark, badger) < 0);
  assert(serd_node_compare(integer, short_integer) < 0);

  serd_node_free(NULL, badger);
  serd_node_free(NULL, aardvark);
  serd_node_free(NULL, uri);
  serd_node_free(NULL, blank);
  serd_node_free(NULL, short_integer);
  serd_node_free(NULL, integer);
  serd_node_free(NULL, universe);
  serd_node_free(NULL, hello);
  serd_node_free(NULL, hallo);
  serd_node_free(NULL, angst_en);
  serd_node_free(NULL, angst_de);
  serd_node_free(NULL, angst);
  serd_node_free(NULL, xsd_short);
}

int
main(void)
{
  test_value();
  test_boolean();
  test_get_bool();
  test_decimal();
  test_double();
  test_get_double();
  test_float();
  test_get_float();
  test_integer();
  test_get_integer();
  test_hex();
  test_base64();
  test_get_blob();
  test_node_equals();
  test_node_from_syntax();
  test_node_from_substring();
  test_new();
  test_uri();
  test_literal();
  test_blank();
  test_compare();

  printf("Success\n");
  return 0;
}