diff --git a/source/toy_string.c b/source/toy_string.c index b8807c0..d64ad1e 100644 --- a/source/toy_string.c +++ b/source/toy_string.c @@ -79,7 +79,7 @@ Toy_String* Toy_deepCopyString(Toy_Bucket** bucketHandle, Toy_String* str) { return ret; } -Toy_String* Toy_concatString(Toy_Bucket** bucketHandle, Toy_String* left, Toy_String* right) { +Toy_String* Toy_concatStrings(Toy_Bucket** bucketHandle, Toy_String* left, Toy_String* right) { if (left->refCount == 0 || right->refCount == 0) { fprintf(stderr, TOY_CC_ERROR "ERROR: Can't concatenate a string with refcount of zero\n" TOY_CC_RESET); exit(-1); @@ -124,3 +124,89 @@ char* Toy_getStringRawBuffer(Toy_String* str) { return buffer; } + +static int deepCompareUtil(Toy_String* left, Toy_String* right, const char** leftHead, const char** rightHead) { + //WARNING: this function can't handle strings of zero length + int result = 0; + + //if it's the same object, of course they match + if (left == right) { + return result; + } + + //BUGFIX: if we're not currently iterating through the left leaf (and leftHead is not null), skip out + if (left->type == TOY_STRING_LEAF && (*leftHead) != NULL && (**leftHead) != '\0' && ((*leftHead) < left->as.leaf.data || (*leftHead) > (left->as.leaf.data + strlen(left->as.leaf.data))) ) { + return result; + } + + //BUGFIX: if we're not currently iterating through the right leaf (and rightHead is not null), skip out + if (right->type == TOY_STRING_LEAF && (*rightHead) != NULL && (**rightHead) != '\0' && ((*rightHead) < right->as.leaf.data || (*rightHead) > (right->as.leaf.data + strlen(right->as.leaf.data))) ) { + return result; + } + + //dig into left + if (left->type == TOY_STRING_NODE) { + if ((result = deepCompareUtil(left->as.node.left, right, leftHead, rightHead)) != 0) { + return result; + } + if ((result = deepCompareUtil(left->as.node.right, right, leftHead, rightHead)) != 0) { + return result; + } + + //return zero to keep going + return result; + } + + //dig into right + if (right->type == TOY_STRING_NODE) { + if ((result = deepCompareUtil(left, right->as.node.left, leftHead, rightHead)) != 0) { + return result; + } + + if ((result = deepCompareUtil(left, right->as.node.right, leftHead, rightHead)) != 0) { + return result; + } + + //return zero to keep going + return result; + } + + //keep comparing the leaves + if (left->type == TOY_STRING_LEAF && right->type == TOY_STRING_LEAF) { + //initial head states can be null, or null characters + if ((*leftHead) == NULL || (**leftHead) == '\0') { + (*leftHead) = left->as.leaf.data; + } + + if ((*rightHead) == NULL || (**rightHead) == '\0') { + (*rightHead) = right->as.leaf.data; + } + + //compare and increment + while (**leftHead && (**leftHead == **rightHead)) { + (*leftHead)++; + (*rightHead)++; + } + + //if both are not null, then it's a real result + if ( (**leftHead == '\0' || **rightHead == '\0') == false) { + result = *(const unsigned char*)(*leftHead) - *(const unsigned char*)(*rightHead); + } + } + + //if either are a null character, return 0 to check the next node + return result; +} + +int Toy_compareStrings(Toy_String* left, Toy_String* right) { + //BUGFIX: since deepCompareUtil() can't handle strings of length zero, insert a check here + if (left->length == 0 || right->length == 0) { + return left->length - right->length; + } + + //util pointers + const char* leftHead = NULL; + const char* rightHead = NULL; + + return deepCompareUtil(left, right, &leftHead, &rightHead); +} \ No newline at end of file diff --git a/source/toy_string.h b/source/toy_string.h index ab2edd4..ef1d83a 100644 --- a/source/toy_string.h +++ b/source/toy_string.h @@ -33,7 +33,7 @@ TOY_API Toy_String* Toy_createStringLength(Toy_Bucket** bucketHandle, const char TOY_API Toy_String* Toy_copyString(Toy_Bucket** bucketHandle, Toy_String* str); TOY_API Toy_String* Toy_deepCopyString(Toy_Bucket** bucketHandle, Toy_String* str); -TOY_API Toy_String* Toy_concatString(Toy_Bucket** bucketHandle, Toy_String* left, Toy_String* right); +TOY_API Toy_String* Toy_concatStrings(Toy_Bucket** bucketHandle, Toy_String* left, Toy_String* right); TOY_API void Toy_freeString(Toy_String* str); @@ -42,4 +42,4 @@ TOY_API int Toy_getStringRefCount(Toy_String* str); TOY_API char* Toy_getStringRawBuffer(Toy_String* str); //allocates the buffer on the heap, needs to be freed -//TODO: compare +TOY_API int Toy_compareStrings(Toy_String* left, Toy_String* right); //return value mimics strcmp() diff --git a/tests/cases/test_string.c b/tests/cases/test_string.c index c9d40c2..cea11e5 100644 --- a/tests/cases/test_string.c +++ b/tests/cases/test_string.c @@ -140,7 +140,7 @@ int test_string_concatenation() { Toy_String* second = Toy_createString(&bucket, "world"); //concatenate - Toy_String* result = Toy_concatString(&bucket, first, second); + Toy_String* result = Toy_concatStrings(&bucket, first, second); //check the refcounts if (first->refCount != 2 || @@ -179,7 +179,7 @@ int test_string_concatenation() { Toy_String* second = Toy_createString(&bucket, "world"); //concatenate - Toy_String* result = Toy_concatString(&bucket, first, second); + Toy_String* result = Toy_concatStrings(&bucket, first, second); char* buffer = Toy_getStringRawBuffer(result); @@ -227,7 +227,7 @@ int test_string_with_stressed_bucket() { Toy_String* str = Toy_createString(&bucket, testData[0]); Toy_String* ptr = str; for (int i = 1; testData[i]; i++) { - str = Toy_concatString(&bucket, str, Toy_createString(&bucket, testData[i])); + str = Toy_concatStrings(&bucket, str, Toy_createString(&bucket, testData[i])); } //check @@ -268,6 +268,455 @@ int test_string_with_stressed_bucket() { return 0; } +int test_string_equality() { + //simple string equality (no concats) + { + //setup + Toy_Bucket* bucket = Toy_allocateBucket(1024); + Toy_String* helloWorldOne = Toy_createString(&bucket, "Hello world"); + Toy_String* helloWorldTwo = Toy_createString(&bucket, "Hello world"); + Toy_String* helloEveryone = Toy_createString(&bucket, "Hello everyone"); + + int result = 0; //for print the errors + + //check match + if ((result = Toy_compareStrings(helloWorldOne, helloWorldTwo)) != 0) + { + char* leftBuffer = Toy_getStringRawBuffer(helloWorldOne); + char* rightBuffer = Toy_getStringRawBuffer(helloWorldTwo); + fprintf(stderr, TOY_CC_ERROR "ERROR: String equality '%s' == '%s' is incorrect, found %s\n" TOY_CC_RESET, leftBuffer, rightBuffer, result < 0 ? "<" : result == 0 ? "==" : ">"); + free(leftBuffer); + free(rightBuffer); + Toy_freeBucket(&bucket); + return -1; + } + + //check mismatch + if ((result = Toy_compareStrings(helloWorldOne, helloEveryone)) == 0) + { + char* leftBuffer = Toy_getStringRawBuffer(helloWorldOne); + char* rightBuffer = Toy_getStringRawBuffer(helloEveryone); + fprintf(stderr, TOY_CC_ERROR "ERROR: String equality '%s' != '%s' is incorrect, found %s\n" TOY_CC_RESET, leftBuffer, rightBuffer, result < 0 ? "<" : result == 0 ? "==" : ">"); + free(leftBuffer); + free(rightBuffer); + Toy_freeBucket(&bucket); + return -1; + } + + //check match (same object) + if ((result = Toy_compareStrings(helloWorldOne, helloWorldOne)) != 0) + { + char* leftBuffer = Toy_getStringRawBuffer(helloWorldOne); + char* rightBuffer = Toy_getStringRawBuffer(helloWorldOne); + fprintf(stderr, TOY_CC_ERROR "ERROR: String equality '%s' == '%s' is incorrect, found %s (these are the same object)\n" TOY_CC_RESET, leftBuffer, rightBuffer, result < 0 ? "<" : result == 0 ? "==" : ">"); + free(leftBuffer); + free(rightBuffer); + Toy_freeBucket(&bucket); + return -1; + } + + //cleanup + Toy_freeBucket(&bucket); + } + + //string equality (with concat left) + { + //setup + Toy_Bucket* bucket = Toy_allocateBucket(1024); + Toy_String* helloWorldOne = Toy_concatStrings(&bucket, Toy_createString(&bucket, "Hello "), Toy_createString(&bucket, "world")); + Toy_String* helloWorldTwo = Toy_createString(&bucket, "Hello world"); + Toy_String* helloEveryone = Toy_createString(&bucket, "Hello everyone"); + + int result = 0; //for print the errors + + //check match + if ((result = Toy_compareStrings(helloWorldOne, helloWorldTwo)) != 0) + { + char* leftBuffer = Toy_getStringRawBuffer(helloWorldOne); + char* rightBuffer = Toy_getStringRawBuffer(helloWorldTwo); + fprintf(stderr, TOY_CC_ERROR "ERROR: String concat left equality '%s' == '%s' is incorrect, found %s\n" TOY_CC_RESET, leftBuffer, rightBuffer, result < 0 ? "<" : result == 0 ? "==" : ">"); + free(leftBuffer); + free(rightBuffer); + Toy_freeBucket(&bucket); + return -1; + } + + //check mismatch + if ((result = Toy_compareStrings(helloWorldOne, helloEveryone)) == 0) + { + char* leftBuffer = Toy_getStringRawBuffer(helloWorldOne); + char* rightBuffer = Toy_getStringRawBuffer(helloEveryone); + fprintf(stderr, TOY_CC_ERROR "ERROR: String concat left equality '%s' != '%s' is incorrect, found %s\n" TOY_CC_RESET, leftBuffer, rightBuffer, result < 0 ? "<" : result == 0 ? "==" : ">"); + free(leftBuffer); + free(rightBuffer); + Toy_freeBucket(&bucket); + return -1; + } + + //check match (same object) + if ((result = Toy_compareStrings(helloWorldOne, helloWorldOne)) != 0) + { + char* leftBuffer = Toy_getStringRawBuffer(helloWorldOne); + char* rightBuffer = Toy_getStringRawBuffer(helloWorldOne); + fprintf(stderr, TOY_CC_ERROR "ERROR: String concat left equality '%s' == '%s' is incorrect, found %s (these are the same object)\n" TOY_CC_RESET, leftBuffer, rightBuffer, result < 0 ? "<" : result == 0 ? "==" : ">"); + free(leftBuffer); + free(rightBuffer); + Toy_freeBucket(&bucket); + return -1; + } + + //cleanup + Toy_freeBucket(&bucket); + } + + //string equality (with concat right) + { + //setup + Toy_Bucket* bucket = Toy_allocateBucket(1024); + Toy_String* helloWorldOne = Toy_createString(&bucket, "Hello world"); + Toy_String* helloWorldTwo = Toy_concatStrings(&bucket, Toy_createString(&bucket, "Hello "), Toy_createString(&bucket, "world")); + Toy_String* helloEveryone = Toy_createString(&bucket, "Hello everyone"); + + int result = 0; //for print the errors + + //check match + if ((result = Toy_compareStrings(helloWorldOne, helloWorldTwo)) != 0) + { + char* leftBuffer = Toy_getStringRawBuffer(helloWorldOne); + char* rightBuffer = Toy_getStringRawBuffer(helloWorldTwo); + fprintf(stderr, TOY_CC_ERROR "ERROR: String concat right equality '%s' == '%s' is incorrect, found %s\n" TOY_CC_RESET, leftBuffer, rightBuffer, result < 0 ? "<" : result == 0 ? "==" : ">"); + free(leftBuffer); + free(rightBuffer); + Toy_freeBucket(&bucket); + return -1; + } + + //cleanup + Toy_freeBucket(&bucket); + } + + //string equality (with concat both) + { + //setup - these concat points are deliberately different + Toy_Bucket* bucket = Toy_allocateBucket(1024); + Toy_String* helloWorldOne = Toy_concatStrings(&bucket, Toy_createString(&bucket, "Hello "), Toy_createString(&bucket, "world")); + Toy_String* helloWorldTwo = Toy_concatStrings(&bucket, Toy_createString(&bucket, "Hello"), Toy_createString(&bucket, " world")); + Toy_String* helloEveryone = Toy_concatStrings(&bucket, Toy_createString(&bucket, "Hell"), Toy_createString(&bucket, "world")); + + int result = 0; //for print the errors + + //check match + if ((result = Toy_compareStrings(helloWorldOne, helloWorldTwo)) != 0) + { + char* leftBuffer = Toy_getStringRawBuffer(helloWorldOne); + char* rightBuffer = Toy_getStringRawBuffer(helloWorldTwo); + fprintf(stderr, TOY_CC_ERROR "ERROR: String concat both equality '%s' == '%s' is incorrect, found %s\n" TOY_CC_RESET, leftBuffer, rightBuffer, result < 0 ? "<" : result == 0 ? "==" : ">"); + free(leftBuffer); + free(rightBuffer); + Toy_freeBucket(&bucket); + return -1; + } + + //check mismatch + if ((result = Toy_compareStrings(helloWorldOne, helloEveryone)) == 0) + { + char* leftBuffer = Toy_getStringRawBuffer(helloWorldOne); + char* rightBuffer = Toy_getStringRawBuffer(helloEveryone); + fprintf(stderr, TOY_CC_ERROR "ERROR: String concat both equality '%s' != '%s' is incorrect, found %s\n" TOY_CC_RESET, leftBuffer, rightBuffer, result < 0 ? "<" : result == 0 ? "==" : ">"); + free(leftBuffer); + free(rightBuffer); + Toy_freeBucket(&bucket); + return -1; + } + + //cleanup + Toy_freeBucket(&bucket); + } + + //string equality (with concat arbitrary) + { + //setup - The quick brown fox jumps over the lazy dog. + Toy_Bucket* bucket = Toy_allocateBucket(1024); + Toy_String* helloWorldOne = Toy_concatStrings(&bucket, + Toy_createString(&bucket, "The quick brown "), + Toy_concatStrings(&bucket, + Toy_createString(&bucket, "fox jumps o"), + Toy_createString(&bucket, "ver the lazy dog.") + ) + ); + + Toy_String* helloWorldTwo = Toy_concatStrings(&bucket, + Toy_concatStrings(&bucket, + Toy_createString(&bucket, "The quick brown fox"), + Toy_concatStrings(&bucket, + Toy_createString(&bucket, " jumps ove"), + Toy_createString(&bucket, "r th") + ) + ), + Toy_concatStrings(&bucket, + Toy_createString(&bucket, "e lazy dog"), + Toy_createString(&bucket, ".") + ) + ); + + Toy_String* helloEveryone = Toy_concatStrings(&bucket, + Toy_createString(&bucket, "The quick brown fox jumps over "), + Toy_concatStrings(&bucket, + Toy_createString(&bucket, "the lazy "), + Toy_createString(&bucket, "reddit mod.") + ) + ); + + int result = 0; //for print the errors + + //check match + if ((result = Toy_compareStrings(helloWorldOne, helloWorldTwo)) != 0) + { + char* leftBuffer = Toy_getStringRawBuffer(helloWorldOne); + char* rightBuffer = Toy_getStringRawBuffer(helloWorldTwo); + fprintf(stderr, TOY_CC_ERROR "ERROR: String concat arbitrary equality '%s' == '%s' is incorrect, found %s\n" TOY_CC_RESET, leftBuffer, rightBuffer, result < 0 ? "<" : result == 0 ? "==" : ">"); + free(leftBuffer); + free(rightBuffer); + Toy_freeBucket(&bucket); + return -1; + } + + //check mismatch + if ((result = Toy_compareStrings(helloWorldOne, helloEveryone)) == 0) + { + char* leftBuffer = Toy_getStringRawBuffer(helloWorldOne); + char* rightBuffer = Toy_getStringRawBuffer(helloEveryone); + fprintf(stderr, TOY_CC_ERROR "ERROR: String concat arbitrary equality '%s' != '%s' is incorrect, found %s\n" TOY_CC_RESET, leftBuffer, rightBuffer, result < 0 ? "<" : result == 0 ? "==" : ">"); + free(leftBuffer); + free(rightBuffer); + Toy_freeBucket(&bucket); + return -1; + } + + //cleanup + Toy_freeBucket(&bucket); + } + + //string equality (empty strings, no concats) + { + //setup + Toy_Bucket* bucket = Toy_allocateBucket(1024); + Toy_String* helloWorldOne = Toy_createString(&bucket, ""); + Toy_String* helloWorldTwo = Toy_createString(&bucket, ""); + Toy_String* helloEveryone = Toy_createString(&bucket, "Hello everyone"); + + int result = 0; //for print the errors + + //check match + if ((result = Toy_compareStrings(helloWorldOne, helloWorldTwo)) != 0) + { + char* leftBuffer = Toy_getStringRawBuffer(helloWorldOne); + char* rightBuffer = Toy_getStringRawBuffer(helloWorldTwo); + fprintf(stderr, TOY_CC_ERROR "ERROR: String equality empty '%s' == '%s' is incorrect, found %s\n" TOY_CC_RESET, leftBuffer, rightBuffer, result < 0 ? "<" : result == 0 ? "==" : ">"); + free(leftBuffer); + free(rightBuffer); + Toy_freeBucket(&bucket); + return -1; + } + + //check mismatch + if ((result = Toy_compareStrings(helloWorldOne, helloEveryone)) == 0) + { + char* leftBuffer = Toy_getStringRawBuffer(helloWorldOne); + char* rightBuffer = Toy_getStringRawBuffer(helloEveryone); + fprintf(stderr, TOY_CC_ERROR "ERROR: String equality empty '%s' != '%s' is incorrect, found %s\n" TOY_CC_RESET, leftBuffer, rightBuffer, result < 0 ? "<" : result == 0 ? "==" : ">"); + free(leftBuffer); + free(rightBuffer); + Toy_freeBucket(&bucket); + return -1; + } + + //check mismatch (same object) + if ((result = Toy_compareStrings(helloWorldOne, helloWorldOne)) != 0) + { + char* leftBuffer = Toy_getStringRawBuffer(helloWorldOne); + char* rightBuffer = Toy_getStringRawBuffer(helloWorldOne); + fprintf(stderr, TOY_CC_ERROR "ERROR: String equality empty '%s' == '%s' is incorrect, found %s (these are the same object)\n" TOY_CC_RESET, leftBuffer, rightBuffer, result < 0 ? "<" : result == 0 ? "==" : ">"); + free(leftBuffer); + free(rightBuffer); + Toy_freeBucket(&bucket); + return -1; + } + + //cleanup + Toy_freeBucket(&bucket); + } + + //string equality (empty strings, deep concats) + { + //setup + Toy_Bucket* bucket = Toy_allocateBucket(1024); + Toy_String* helloWorldOne = Toy_concatStrings(&bucket, + Toy_createString(&bucket, ""), + Toy_concatStrings(&bucket, + Toy_createString(&bucket, ""), + Toy_createString(&bucket, "") + ) + ); + + Toy_String* helloWorldTwo = Toy_concatStrings(&bucket, + Toy_concatStrings(&bucket, + Toy_createString(&bucket, ""), + Toy_concatStrings(&bucket, + Toy_createString(&bucket, ""), + Toy_createString(&bucket, "") + ) + ), + Toy_concatStrings(&bucket, + Toy_createString(&bucket, ""), + Toy_createString(&bucket, "") + ) + ); + + Toy_String* helloEveryone = Toy_concatStrings(&bucket, + Toy_createString(&bucket, "The quick brown fox jumps over "), + Toy_concatStrings(&bucket, + Toy_createString(&bucket, "the lazy "), + Toy_createString(&bucket, "reddit mod.") + ) + ); + + int result = 0; //for print the errors + + //check match + if ((result = Toy_compareStrings(helloWorldOne, helloWorldTwo)) != 0) + { + char* leftBuffer = Toy_getStringRawBuffer(helloWorldOne); + char* rightBuffer = Toy_getStringRawBuffer(helloWorldTwo); + fprintf(stderr, TOY_CC_ERROR "ERROR: String equality empty with concats '%s' == '%s' is incorrect, found %s\n" TOY_CC_RESET, leftBuffer, rightBuffer, result < 0 ? "<" : result == 0 ? "==" : ">"); + free(leftBuffer); + free(rightBuffer); + Toy_freeBucket(&bucket); + return -1; + } + + //check mismatch + if ((result = Toy_compareStrings(helloWorldOne, helloEveryone)) == 0) + { + char* leftBuffer = Toy_getStringRawBuffer(helloWorldOne); + char* rightBuffer = Toy_getStringRawBuffer(helloEveryone); + fprintf(stderr, TOY_CC_ERROR "ERROR: String equality empty with concats '%s' != '%s' is incorrect, found %s\n" TOY_CC_RESET, leftBuffer, rightBuffer, result < 0 ? "<" : result == 0 ? "==" : ">"); + free(leftBuffer); + free(rightBuffer); + Toy_freeBucket(&bucket); + return -1; + } + + //check match (same object) + if ((result = Toy_compareStrings(helloWorldOne, helloWorldOne)) != 0) + { + char* leftBuffer = Toy_getStringRawBuffer(helloWorldOne); + char* rightBuffer = Toy_getStringRawBuffer(helloWorldOne); + fprintf(stderr, TOY_CC_ERROR "ERROR: String equality empty with concats '%s' == '%s' is incorrect, found %s (these are the same object)\n" TOY_CC_RESET, leftBuffer, rightBuffer, result < 0 ? "<" : result == 0 ? "==" : ">"); + free(leftBuffer); + free(rightBuffer); + Toy_freeBucket(&bucket); + return -1; + } + + //cleanup + Toy_freeBucket(&bucket); + } + + return 0; +} + +int test_string_diffs() { + //simple string diffs (no concats) + { + //setup + Toy_Bucket* bucket = Toy_allocateBucket(1024); + Toy_String* helloEveryone = Toy_createString(&bucket, "Hello everyone"); + Toy_String* helloUniverse = Toy_createString(&bucket, "Hello universe"); + + int result = 0; //for print the errors + + //check diff + if (((result = Toy_compareStrings(helloEveryone, helloUniverse)) < 0) == false) + { + char* leftBuffer = Toy_getStringRawBuffer(helloEveryone); + char* rightBuffer = Toy_getStringRawBuffer(helloUniverse); + fprintf(stderr, TOY_CC_ERROR "ERROR: String diff '%s' == '%s' is incorrect, found %s\n" TOY_CC_RESET, leftBuffer, rightBuffer, result < 0 ? "<" : result == 0 ? "==" : ">"); + free(leftBuffer); + free(rightBuffer); + Toy_freeBucket(&bucket); + return -1; + } + + //check diff (reversed) + if (((result = Toy_compareStrings(helloUniverse, helloEveryone)) > 0) == false) + { + char* leftBuffer = Toy_getStringRawBuffer(helloUniverse); + char* rightBuffer = Toy_getStringRawBuffer(helloEveryone); + fprintf(stderr, TOY_CC_ERROR "ERROR: String diff '%s' == '%s' is incorrect, found %s\n" TOY_CC_RESET, leftBuffer, rightBuffer, result < 0 ? "<" : result == 0 ? "==" : ">"); + free(leftBuffer); + free(rightBuffer); + Toy_freeBucket(&bucket); + return -1; + } + + //cleanup + Toy_freeBucket(&bucket); + } + + //string diffs (with concat arbitrary) + { + //setup - The quick brown fox jumps over the lazy dog. + Toy_Bucket* bucket = Toy_allocateBucket(1024); + Toy_String* pangram = Toy_concatStrings(&bucket, + Toy_createString(&bucket, "The quick brown "), + Toy_concatStrings(&bucket, + Toy_createString(&bucket, "fox jumps o"), + Toy_createString(&bucket, "ver the lazy dog.") + ) + ); + + Toy_String* neckbeard = Toy_concatStrings(&bucket, + Toy_createString(&bucket, "The quick brown fox jumps over "), + Toy_concatStrings(&bucket, + Toy_createString(&bucket, "the lazy "), + Toy_createString(&bucket, "reddit mod.") + ) + ); + + int result = 0; //for print the errors + + //check diff + if (((result = Toy_compareStrings(pangram, neckbeard)) < 0) == false) + { + char* leftBuffer = Toy_getStringRawBuffer(pangram); + char* rightBuffer = Toy_getStringRawBuffer(neckbeard); + fprintf(stderr, TOY_CC_ERROR "ERROR: String diff '%s' == '%s' is incorrect, found %s\n" TOY_CC_RESET, leftBuffer, rightBuffer, result < 0 ? "<" : result == 0 ? "==" : ">"); + free(leftBuffer); + free(rightBuffer); + Toy_freeBucket(&bucket); + return -1; + } + + //check diff (reversed) + if (((result = Toy_compareStrings(neckbeard, pangram)) > 0) == false) + { + char* leftBuffer = Toy_getStringRawBuffer(neckbeard); + char* rightBuffer = Toy_getStringRawBuffer(pangram); + fprintf(stderr, TOY_CC_ERROR "ERROR: String diff '%s' == '%s' is incorrect, found %s\n" TOY_CC_RESET, leftBuffer, rightBuffer, result < 0 ? "<" : result == 0 ? "==" : ">"); + free(leftBuffer); + free(rightBuffer); + Toy_freeBucket(&bucket); + return -1; + } + + //cleanup + Toy_freeBucket(&bucket); + } + + return 0; +} + int main() { //run each test set, returning the total errors given int total = 0, res = 0; @@ -308,5 +757,21 @@ int main() { total += res; } + { + res = test_string_equality(); + if (res == 0) { + printf(TOY_CC_NOTICE "All good\n" TOY_CC_RESET); + } + total += res; + } + + { + res = test_string_diffs(); + if (res == 0) { + printf(TOY_CC_NOTICE "All good\n" TOY_CC_RESET); + } + total += res; + } + return total; }