krgamestudios/Toy
1
0
Fork 0
mirror of https://github.com/krgamestudios/Toy.git synced 2026-04-15 14:54:07 +10:00
Code Issues Packages Projects Releases Wiki Activity

Value test is passing

Browse Source
This commit is contained in:
Kayne Ruse
2026-04-07 19:44:28 +10:00
parent f4ce6ad9f1
commit 522fc3e64b
2 changed files with 619 additions and 19 deletions
Download Patch File Download Diff File Expand all files Collapse all files

37
source/toy_value.c
View File

@@ -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, "<null>");
return Toy_createStringLength(bucketHandle, "<null>", 6);
case TOY_VALUE_BOOLEAN:
return Toy_toString(bucketHandle, value.as.boolean ? "<true>" : "<false>");
if (value.as.boolean) {
return Toy_createStringLength(bucketHandle, "<true>", 6);
}
else {
return Toy_createStringLength(bucketHandle, "<false>", 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, "<fn>");
return Toy_createStringLength(bucketHandle, "<fn>", 4);
case TOY_VALUE_OPAQUE:
case TOY_VALUE_ANY:

601
tests/units/test_value.c
View File

@@ -1,9 +1,604 @@
#include "toy_value.h"
#include "toy_console_colors.h"
#include <stdio.h>
#include "toy_bucket.h"
#include "toy_string.h"
#include "toy_array.h"
int main(void) {
printf(TOY_CC_WARN "Test not yet implemented: %s\n" TOY_CC_RESET, __FILE__);
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//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, "<null>") != 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, "<true>") != 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, "<false>") != 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) {
//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;
}