From 522fc3e64b75c4198658d392c5bf61845be99c80 Mon Sep 17 00:00:00 2001 From: Kayne Ruse Date: Tue, 7 Apr 2026 19:44:28 +1000 Subject: [PATCH] Value test is passing --- source/toy_value.c | 37 +-- tests/units/test_value.c | 601 ++++++++++++++++++++++++++++++++++++++- 2 files changed, 619 insertions(+), 19 deletions(-) diff --git a/source/toy_value.c b/source/toy_value.c index c6404a3..4fdd5b2 100644 --- a/source/toy_value.c +++ b/source/toy_value.c @@ -432,15 +432,20 @@ Toy_String* Toy_stringifyValue(Toy_Bucket** bucketHandle, Toy_Value value) { switch(value.type) { case TOY_VALUE_NULL: - return Toy_toString(bucketHandle, ""); + return Toy_createStringLength(bucketHandle, "", 6); case TOY_VALUE_BOOLEAN: - return Toy_toString(bucketHandle, value.as.boolean ? "" : ""); + if (value.as.boolean) { + return Toy_createStringLength(bucketHandle, "", 6); + } + else { + return Toy_createStringLength(bucketHandle, "", 7); + } case TOY_VALUE_INTEGER: { char buffer[16]; sprintf(buffer, "%d", value.as.integer); - return Toy_toString(bucketHandle, buffer); + return Toy_createStringLength(bucketHandle, buffer, strlen(buffer)); } case TOY_VALUE_FLOAT: { @@ -461,7 +466,7 @@ Toy_String* Toy_stringifyValue(Toy_Bucket** bucketHandle, Toy_Value value) { //wipe the trailing zeros while(decimal != length && buffer[length-1] == '0') buffer[--length] = '\0'; - return Toy_toStringLength(bucketHandle, buffer, length); + return Toy_createStringLength(bucketHandle, buffer, length); } case TOY_VALUE_STRING: @@ -473,14 +478,14 @@ Toy_String* Toy_stringifyValue(Toy_Bucket** bucketHandle, Toy_Value value) { //if array is empty, skip below if (ptr->count == 0) { - Toy_String* empty = Toy_toString(bucketHandle, "[]"); + Toy_String* empty = Toy_createStringLength(bucketHandle, "[]", 2); return empty; } - Toy_String* open = Toy_toStringLength(bucketHandle, "[", 1); - Toy_String* close = Toy_toStringLength(bucketHandle, "]", 1); - Toy_String* comma = Toy_toStringLength(bucketHandle, ",", 1); //reusable - Toy_String* quote = Toy_toStringLength(bucketHandle, "\"", 1); //reusable + Toy_String* open = Toy_createStringLength(bucketHandle, "[", 1); + Toy_String* close = Toy_createStringLength(bucketHandle, "]", 1); + Toy_String* comma = Toy_createStringLength(bucketHandle, ",", 1); //reusable + Toy_String* quote = Toy_createStringLength(bucketHandle, "\"", 1); //reusable bool needsComma = false; Toy_String* string = open; @@ -536,15 +541,15 @@ Toy_String* Toy_stringifyValue(Toy_Bucket** bucketHandle, Toy_Value value) { //if table is empty, skip below if (ptr->count == 0) { - Toy_String* empty = Toy_toString(bucketHandle, "[:]"); + Toy_String* empty = Toy_createStringLength(bucketHandle, "[:]", 3); return empty; } - Toy_String* open = Toy_toStringLength(bucketHandle, "[", 1); - Toy_String* close = Toy_toStringLength(bucketHandle, "]", 1); - Toy_String* colon = Toy_toStringLength(bucketHandle, ":", 1); //reusable - Toy_String* comma = Toy_toStringLength(bucketHandle, ",", 1); //reusable - Toy_String* quote = Toy_toStringLength(bucketHandle, "\"", 1); //reusable + Toy_String* open = Toy_createStringLength(bucketHandle, "[", 1); + Toy_String* close = Toy_createStringLength(bucketHandle, "]", 1); + Toy_String* colon = Toy_createStringLength(bucketHandle, ":", 1); //reusable + Toy_String* comma = Toy_createStringLength(bucketHandle, ",", 1); //reusable + Toy_String* quote = Toy_createStringLength(bucketHandle, "\"", 1); //reusable bool needsComma = false; Toy_String* string = open; @@ -624,7 +629,7 @@ Toy_String* Toy_stringifyValue(Toy_Bucket** bucketHandle, Toy_Value value) { case TOY_VALUE_FUNCTION: //dummy - return Toy_toString(bucketHandle, ""); + return Toy_createStringLength(bucketHandle, "", 4); case TOY_VALUE_OPAQUE: case TOY_VALUE_ANY: diff --git a/tests/units/test_value.c b/tests/units/test_value.c index f08245f..6731384 100644 --- a/tests/units/test_value.c +++ b/tests/units/test_value.c @@ -1,9 +1,604 @@ #include "toy_value.h" #include "toy_console_colors.h" +#include "toy_bucket.h" +#include "toy_string.h" +#include "toy_array.h" + #include +#include +#include + +//util macros +#define TOY_ARRAY_EXPAND(array) (array = (array != NULL && (array)->count + 1 > (array)->capacity ? Toy_resizeArray(array, (array)->capacity * TOY_ARRAY_EXPANSION_RATE) : array)) +#define TOY_ARRAY_PUSHBACK(array, value) (TOY_ARRAY_EXPAND(array), (array)->data[(array)->count++] = (value)) + +int test_value_creation(void) { + //test for the correct size + { +#if TOY_BITNESS == 64 + if (sizeof(Toy_Value) != 16) +#else + if (sizeof(Toy_Value) != 8) +#endif + { + fprintf(stderr, TOY_CC_ERROR "ERROR: 'Toy_Value' is an unexpected size in memory, expected %d found %d\n" TOY_CC_RESET, TOY_BITNESS, (int)sizeof(Toy_Value)); + return -1; + } + } + + //test creating a null + { + Toy_Value v = TOY_VALUE_FROM_NULL(); + + if (!TOY_VALUE_IS_NULL(v)) { + fprintf(stderr, TOY_CC_ERROR "ERROR: creating a 'null' value failed\n" TOY_CC_RESET); + return -1; + } + } + + //test creating booleans + { + Toy_Value t = TOY_VALUE_FROM_BOOLEAN(true); + Toy_Value f = TOY_VALUE_FROM_BOOLEAN(false); + + if (!Toy_checkValueIsTruthy(t) || Toy_checkValueIsTruthy(f)) { + fprintf(stderr, TOY_CC_ERROR "ERROR: 'boolean' value failed\n" TOY_CC_RESET); + return -1; + } + } + + //test creating strings + { + //setup + Toy_Bucket* bucket = Toy_allocateBucket(TOY_BUCKET_IDEAL); + + Toy_Value greeting = TOY_VALUE_FROM_STRING(Toy_createStringLength(&bucket, "Hello world!", 12)); + + if (TOY_VALUE_IS_STRING(greeting) == false || + TOY_VALUE_AS_STRING(greeting)->info.type != TOY_STRING_LEAF || + strcmp(TOY_VALUE_AS_STRING(greeting)->leaf.data, "Hello world!") != 0 + ) + { + fprintf(stderr, TOY_CC_ERROR "ERROR: 'string' value failed\n" TOY_CC_RESET); + Toy_freeBucket(&bucket); + return -1; + } + + //cleanup + Toy_freeBucket(&bucket); + } + + //test creating arrays + { + //setup + Toy_Array* array = Toy_resizeArray(NULL, TOY_ARRAY_INITIAL_CAPACITY); + TOY_ARRAY_PUSHBACK(array, TOY_VALUE_FROM_INTEGER(42)); + TOY_ARRAY_PUSHBACK(array, TOY_VALUE_FROM_INTEGER(69)); + TOY_ARRAY_PUSHBACK(array, TOY_VALUE_FROM_INTEGER(8891)); + + Toy_Value v = TOY_VALUE_FROM_ARRAY(array); + + if (TOY_VALUE_AS_ARRAY(v) == false || + TOY_VALUE_AS_ARRAY(v)->capacity != 8 || + TOY_VALUE_AS_ARRAY(v)->count != 3 || + TOY_VALUE_IS_INTEGER(TOY_VALUE_AS_ARRAY(v)->data[0]) != true || TOY_VALUE_AS_INTEGER(TOY_VALUE_AS_ARRAY(v)->data[0]) != 42 || + TOY_VALUE_IS_INTEGER(TOY_VALUE_AS_ARRAY(v)->data[1]) != true || TOY_VALUE_AS_INTEGER(TOY_VALUE_AS_ARRAY(v)->data[1]) != 69 || + TOY_VALUE_IS_INTEGER(TOY_VALUE_AS_ARRAY(v)->data[2]) != true || TOY_VALUE_AS_INTEGER(TOY_VALUE_AS_ARRAY(v)->data[2]) != 8891 + ) + { + fprintf(stderr, TOY_CC_ERROR "ERROR: 'array' value failed\n" TOY_CC_RESET); + Toy_resizeArray(array, 0); + return -1; + } + + //cleanup + Toy_resizeArray(array, 0); + } + + return 0; +} + +int test_value_copying(void) { + //test simple integer copy + { + Toy_Value original = TOY_VALUE_FROM_INTEGER(42); + Toy_Value result = Toy_copyValue(original); + + if (!TOY_VALUE_IS_INTEGER(result) || + TOY_VALUE_AS_INTEGER(result) != 42 + ) { + fprintf(stderr, TOY_CC_ERROR "ERROR: copy an integer value failed\n" TOY_CC_RESET); + return -1; + } + } + + //test string copy + { + //setup + Toy_Bucket* bucket = Toy_allocateBucket(TOY_BUCKET_IDEAL); + + Toy_Value original = TOY_VALUE_FROM_STRING(Toy_createStringLength(&bucket, "Hello world!", 12)); + Toy_Value result = Toy_copyValue(original); + + if (TOY_VALUE_IS_STRING(result) == false || + TOY_VALUE_AS_STRING(result)->info.type != TOY_STRING_LEAF || + strcmp(TOY_VALUE_AS_STRING(result)->leaf.data, "Hello world!") != 0 || + TOY_VALUE_AS_STRING(result)->info.refCount != 2 + ) + { + fprintf(stderr, TOY_CC_ERROR "ERROR: copy a string value failed\n" TOY_CC_RESET); + Toy_freeValue(original); + Toy_freeValue(result); + Toy_freeBucket(&bucket); + return -1; + } + + //cleanup + Toy_freeValue(original); + Toy_freeValue(result); + Toy_freeBucket(&bucket); + } + + //test copy arrays + { + //setup + Toy_Array* array = Toy_resizeArray(NULL, TOY_ARRAY_INITIAL_CAPACITY); + TOY_ARRAY_PUSHBACK(array, TOY_VALUE_FROM_INTEGER(42)); + TOY_ARRAY_PUSHBACK(array, TOY_VALUE_FROM_INTEGER(69)); + TOY_ARRAY_PUSHBACK(array, TOY_VALUE_FROM_INTEGER(8891)); + + Toy_Value original = TOY_VALUE_FROM_ARRAY(array); + + Toy_Value result = Toy_copyValue(original); + + if (TOY_VALUE_AS_ARRAY(result) == false || + TOY_VALUE_AS_ARRAY(result)->capacity != 8 || + TOY_VALUE_AS_ARRAY(result)->count != 3 || + TOY_VALUE_IS_INTEGER(TOY_VALUE_AS_ARRAY(result)->data[0]) != true || TOY_VALUE_AS_INTEGER(TOY_VALUE_AS_ARRAY(result)->data[0]) != 42 || + TOY_VALUE_IS_INTEGER(TOY_VALUE_AS_ARRAY(result)->data[1]) != true || TOY_VALUE_AS_INTEGER(TOY_VALUE_AS_ARRAY(result)->data[1]) != 69 || + TOY_VALUE_IS_INTEGER(TOY_VALUE_AS_ARRAY(result)->data[2]) != true || TOY_VALUE_AS_INTEGER(TOY_VALUE_AS_ARRAY(result)->data[2]) != 8891 + ) + { + fprintf(stderr, TOY_CC_ERROR "ERROR: copy an array value failed\n" TOY_CC_RESET); + Toy_freeValue(original); + Toy_freeValue(result); + return -1; + } + + //cleanup + Toy_freeValue(original); + Toy_freeValue(result); + } + + //arrays can't be compared + + return 0; +} + +int test_value_hashing(void) { + //test value hashing + { + //setup + Toy_Bucket* bucket = Toy_allocateBucket(TOY_BUCKET_IDEAL); + + //values + Toy_Value n = TOY_VALUE_FROM_NULL(); + Toy_Value t = TOY_VALUE_FROM_BOOLEAN(true); + Toy_Value f = TOY_VALUE_FROM_BOOLEAN(false); + Toy_Value i = TOY_VALUE_FROM_INTEGER(42); + //skip float + Toy_Value s = TOY_VALUE_FROM_STRING(Toy_createStringLength(&bucket, "Hello world", 11)); + + Toy_Array* array = Toy_resizeArray(NULL, TOY_ARRAY_INITIAL_CAPACITY); + TOY_ARRAY_PUSHBACK(array, TOY_VALUE_FROM_INTEGER(42)); + TOY_ARRAY_PUSHBACK(array, TOY_VALUE_FROM_INTEGER(69)); + TOY_ARRAY_PUSHBACK(array, TOY_VALUE_FROM_INTEGER(8891)); + Toy_Value a = TOY_VALUE_FROM_ARRAY(array); + + if (Toy_hashValue(n) != 0 || + Toy_hashValue(t) != 1 || + Toy_hashValue(f) != 0 || + Toy_hashValue(i) != 4147366645 || + Toy_hashValue(s) != 994097935 || + TOY_VALUE_AS_STRING(s)->info.cachedHash == 0 || //TODO: check this + Toy_hashValue(a) != 2544446955 + ) + { + fprintf(stderr, TOY_CC_ERROR "ERROR: Unexpected hash of a value\n" TOY_CC_RESET); + Toy_resizeArray(array, 0); + Toy_freeBucket(&bucket); + return -1; + } + + //cleanup + Toy_resizeArray(array, 0); + Toy_freeBucket(&bucket); + } + + return 0; +} + +int test_value_equality(void) { + //test value equality + { + Toy_Value answer = TOY_VALUE_FROM_INTEGER(42); + Toy_Value question = TOY_VALUE_FROM_INTEGER(42); + Toy_Value nice = TOY_VALUE_FROM_INTEGER(69); + + if (Toy_checkValuesAreEqual(answer, question) != true) { + fprintf(stderr, TOY_CC_ERROR "ERROR: value equality check failed, expected true\n" TOY_CC_RESET); + return -1; + } + + if (Toy_checkValuesAreEqual(answer, nice) != false) { + fprintf(stderr, TOY_CC_ERROR "ERROR: value equality check failed, expected false\n" TOY_CC_RESET); + return -1; + } + } + + //again with strings + { + //setup + Toy_Bucket* bucket = Toy_allocateBucket(TOY_BUCKET_IDEAL); + + Toy_Value answer = TOY_VALUE_FROM_STRING(Toy_createStringLength(&bucket, "poe wrote on both", 17)); + Toy_Value question = TOY_VALUE_FROM_STRING(Toy_createStringLength(&bucket, "why is a raven like a writing desk?", 35)); + Toy_Value duplicate = TOY_VALUE_FROM_STRING(Toy_createStringLength(&bucket, "poe wrote on both", 17)); + + if (Toy_checkValuesAreEqual(answer, duplicate) != true) { + fprintf(stderr, TOY_CC_ERROR "ERROR: string value equality check failed, expected true\n" TOY_CC_RESET); + return -1; + } + + if (Toy_checkValuesAreEqual(answer, question) != false) { + fprintf(stderr, TOY_CC_ERROR "ERROR: string value equality check failed, expected false\n" TOY_CC_RESET); + return -1; + } + + //cleanup + Toy_freeBucket(&bucket); + } + + //again with arrays + { + //setup + Toy_Array* array1 = Toy_resizeArray(NULL, TOY_ARRAY_INITIAL_CAPACITY); + TOY_ARRAY_PUSHBACK(array1, TOY_VALUE_FROM_INTEGER(42)); + TOY_ARRAY_PUSHBACK(array1, TOY_VALUE_FROM_INTEGER(69)); + TOY_ARRAY_PUSHBACK(array1, TOY_VALUE_FROM_INTEGER(8891)); + + Toy_Value value1 = TOY_VALUE_FROM_ARRAY(array1); + + Toy_Array* array2 = Toy_resizeArray(NULL, TOY_ARRAY_INITIAL_CAPACITY); + TOY_ARRAY_PUSHBACK(array2, TOY_VALUE_FROM_INTEGER(42)); + TOY_ARRAY_PUSHBACK(array2, TOY_VALUE_FROM_INTEGER(69)); + TOY_ARRAY_PUSHBACK(array2, TOY_VALUE_FROM_INTEGER(8891)); + + Toy_Value value2 = TOY_VALUE_FROM_ARRAY(array2); + + + if (Toy_checkValuesAreEqual(value1, value2) != true) + { + fprintf(stderr, TOY_CC_ERROR "ERROR: array values are not equal\n" TOY_CC_RESET); + Toy_freeValue(value1); + Toy_freeValue(value2); + return -1; + } + + //cleanup + Toy_freeValue(value1); + Toy_freeValue(value2); + } + + return 0; +} + +int test_value_comparison(void) { + //test value comparable + { + Toy_Value answer = TOY_VALUE_FROM_INTEGER(42); + Toy_Value question = TOY_VALUE_FROM_INTEGER(42); + Toy_Value nope = TOY_VALUE_FROM_NULL(); + + if (Toy_checkValuesAreComparable(answer, question) != true) { + fprintf(stderr, TOY_CC_ERROR "ERROR: value comparison check failed, expected true\n" TOY_CC_RESET); + return -1; + } + + if (Toy_checkValuesAreComparable(answer, nope) != false) { + fprintf(stderr, TOY_CC_ERROR "ERROR: value comparison check failed, expected false\n" TOY_CC_RESET); + return -1; + } + } + + //test comparison + { + Toy_Value answer = TOY_VALUE_FROM_INTEGER(42); + Toy_Value question = TOY_VALUE_FROM_INTEGER(42); + Toy_Value nice = TOY_VALUE_FROM_INTEGER(69); + + if (Toy_compareValues(answer, question) != 0) { + fprintf(stderr, TOY_CC_ERROR "ERROR: value comparison failed, expected 0\n" TOY_CC_RESET); + return -1; + } + + if (Toy_compareValues(answer, nice) == 0) { + fprintf(stderr, TOY_CC_ERROR "ERROR: value comparison failed, expected not 0\n" TOY_CC_RESET); + return -1; + } + } + + //again with strings + { + //setup + Toy_Bucket* bucket = Toy_allocateBucket(TOY_BUCKET_IDEAL); + + Toy_Value answer = TOY_VALUE_FROM_STRING(Toy_createStringLength(&bucket, "poe wrote on both", 17)); + Toy_Value question = TOY_VALUE_FROM_STRING(Toy_createStringLength(&bucket, "why is a raven like a writing desk?", 35)); + Toy_Value duplicate = TOY_VALUE_FROM_STRING(Toy_createStringLength(&bucket, "poe wrote on both", 17)); + + if (Toy_compareValues(answer, duplicate) != 0) { + fprintf(stderr, TOY_CC_ERROR "ERROR: string value comparison failed, expected 0\n" TOY_CC_RESET); + return -1; + } + + if (Toy_compareValues(answer, question) == 0) { + fprintf(stderr, TOY_CC_ERROR "ERROR: string value comparison failed, expected not 0\n" TOY_CC_RESET); + return -1; + } + + //cleanup + Toy_freeBucket(&bucket); + } + + //arrays can't be compared + + return 0; +} + +int test_value_stringify(void) { + //stringify null + { + //setup + Toy_Bucket* bucket = Toy_allocateBucket(TOY_BUCKET_IDEAL); + Toy_Value value = TOY_VALUE_FROM_NULL(); + + //run + Toy_String* string = Toy_stringifyValue(&bucket, value); + + //check + if (string->info.type != TOY_STRING_LEAF || + strcmp(string->leaf.data, "") != 0) + { + fprintf(stderr, TOY_CC_ERROR "ERROR: stringify 'null' failed\n" TOY_CC_RESET); + Toy_freeString(string); + Toy_freeValue(value); + Toy_freeBucket(&bucket); + return -1; + } + + //cleanup + Toy_freeString(string); + Toy_freeValue(value); + Toy_freeBucket(&bucket); + } + + //stringify boolean (true) + { + //setup + Toy_Bucket* bucket = Toy_allocateBucket(TOY_BUCKET_IDEAL); + Toy_Value value = TOY_VALUE_FROM_BOOLEAN(true); + + //run + Toy_String* string = Toy_stringifyValue(&bucket, value); + + //check + if (string->info.type != TOY_STRING_LEAF || + strcmp(string->leaf.data, "") != 0) + { + fprintf(stderr, TOY_CC_ERROR "ERROR: stringify boolean 'true' failed\n" TOY_CC_RESET); + Toy_freeString(string); + Toy_freeValue(value); + Toy_freeBucket(&bucket); + return -1; + } + + //cleanup + Toy_freeString(string); + Toy_freeValue(value); + Toy_freeBucket(&bucket); + } + + //stringify boolean (false) + { + //setup + Toy_Bucket* bucket = Toy_allocateBucket(TOY_BUCKET_IDEAL); + Toy_Value value = TOY_VALUE_FROM_BOOLEAN(false); + + //run + Toy_String* string = Toy_stringifyValue(&bucket, value); + + //check + if (string->info.type != TOY_STRING_LEAF || + strcmp(string->leaf.data, "") != 0) + { + fprintf(stderr, TOY_CC_ERROR "ERROR: stringify boolean 'false' failed\n" TOY_CC_RESET); + Toy_freeString(string); + Toy_freeValue(value); + Toy_freeBucket(&bucket); + return -1; + } + + //cleanup + Toy_freeString(string); + Toy_freeValue(value); + Toy_freeBucket(&bucket); + } + + //stringify integer + { + //setup + Toy_Bucket* bucket = Toy_allocateBucket(TOY_BUCKET_IDEAL); + Toy_Value value = TOY_VALUE_FROM_INTEGER(42); + + //run + Toy_String* string = Toy_stringifyValue(&bucket, value); + + //check + if (string->info.type != TOY_STRING_LEAF || + strcmp(string->leaf.data, "42") != 0) + { + fprintf(stderr, TOY_CC_ERROR "ERROR: stringify integer '42' failed\n" TOY_CC_RESET); + Toy_freeString(string); + Toy_freeValue(value); + Toy_freeBucket(&bucket); + return -1; + } + + //cleanup + Toy_freeString(string); + Toy_freeValue(value); + Toy_freeBucket(&bucket); + } + + //stringify float + { + //setup + Toy_Bucket* bucket = Toy_allocateBucket(TOY_BUCKET_IDEAL); + Toy_Value value = TOY_VALUE_FROM_FLOAT(3.1415f); + + //run + Toy_String* string = Toy_stringifyValue(&bucket, value); + + //check + if (string->info.type != TOY_STRING_LEAF || + strcmp(string->leaf.data, "3.1415") != 0) + { + fprintf(stderr, TOY_CC_ERROR "ERROR: stringify float '3.1415' failed\n" TOY_CC_RESET); + Toy_freeString(string); + Toy_freeValue(value); + Toy_freeBucket(&bucket); + return -1; + } + + //cleanup + Toy_freeString(string); + Toy_freeValue(value); + Toy_freeBucket(&bucket); + } + + //stringify strings + { + //setup + Toy_Bucket* bucket = Toy_allocateBucket(TOY_BUCKET_IDEAL); + + Toy_Value value = TOY_VALUE_FROM_STRING(Toy_createStringLength(&bucket, "Hello world!", 12)); + Toy_String* string = Toy_stringifyValue(&bucket, value); + char* buffer = Toy_getStringRaw(string); + + if (buffer == NULL || strcmp(buffer, "Hello world!") != 0) + { + fprintf(stderr, TOY_CC_ERROR "ERROR: stringify string 'Hello world!' failed\n" TOY_CC_RESET); + free(buffer); + Toy_freeBucket(&bucket); + return -1; + } + + //cleanup + free(buffer); + Toy_freeBucket(&bucket); + } + + //stringify array + { + //setup + Toy_Bucket* bucket = Toy_allocateBucket(TOY_BUCKET_IDEAL); + + //setup + Toy_Array* array = Toy_resizeArray(NULL, TOY_ARRAY_INITIAL_CAPACITY); + TOY_ARRAY_PUSHBACK(array, TOY_VALUE_FROM_INTEGER(42)); + TOY_ARRAY_PUSHBACK(array, TOY_VALUE_FROM_INTEGER(69)); + TOY_ARRAY_PUSHBACK(array, TOY_VALUE_FROM_INTEGER(8891)); + + Toy_Value value = TOY_VALUE_FROM_ARRAY(array); + Toy_String* string = Toy_stringifyValue(&bucket, value); + char* buffer = Toy_getStringRaw(string); + + if (buffer == NULL || strcmp(buffer, "[42,69,8891]") != 0) + { + fprintf(stderr, TOY_CC_ERROR "ERROR: stringify array '[42,69,8891]' failed\n" TOY_CC_RESET); + free(buffer); + array = Toy_resizeArray(array, 0); + Toy_freeBucket(&bucket); + return -1; + } + + //NOTE: Test 'Stringify Dictionary as Value' not implemented, as the order is impossible to know + printf(TOY_CC_WARN "Test 'Stringify Dictionary as Value' not implemented\n" TOY_CC_RESET); + + //cleanup + free(buffer); + Toy_resizeArray(array, 0); + Toy_freeBucket(&bucket); + } + + return 0; +} int main(void) { - printf(TOY_CC_WARN "Test not yet implemented: %s\n" TOY_CC_RESET, __FILE__); - return -1; -} + //run each test set, returning the total errors given + int total = 0, res = 0; + + { + res = test_value_creation(); + if (res == 0) { + printf(TOY_CC_NOTICE "All good\n" TOY_CC_RESET); + } + total += res; + } + + { + res = test_value_copying(); + if (res == 0) { + printf(TOY_CC_NOTICE "All good\n" TOY_CC_RESET); + } + total += res; + } + + { + res = test_value_hashing(); + if (res == 0) { + printf(TOY_CC_NOTICE "All good\n" TOY_CC_RESET); + } + total += res; + } + + { + res = test_value_equality(); + if (res == 0) { + printf(TOY_CC_NOTICE "All good\n" TOY_CC_RESET); + } + total += res; + } + + { + res = test_value_comparison(); + if (res == 0) { + printf(TOY_CC_NOTICE "All good\n" TOY_CC_RESET); + } + total += res; + } + + { + res = test_value_stringify(); + if (res == 0) { + printf(TOY_CC_NOTICE "All good\n" TOY_CC_RESET); + } + total += res; + } + + //TODO: references + + return total; +} \ No newline at end of file