StringBuffer 功能完善
This commit is contained in:
+345
-115
@@ -8,126 +8,356 @@
|
||||
if (condition) { \
|
||||
printf("\033[32mPASSED\033[0m\n"); \
|
||||
} else { \
|
||||
printf("\033[31mFAILED\033[0m (at Line %d)\n", __LINE__); \
|
||||
printf("\033[31mFAILED\033[0m (at %s:%d)\n", __FILE__, __LINE__); \
|
||||
return C_ERR_FAIL; \
|
||||
} \
|
||||
} while(0)
|
||||
|
||||
c_err_t c_StringBuffer_UnitTest(void) {
|
||||
c_StringBuffer_t sb;
|
||||
c_err_t err;
|
||||
char copy_target[64];
|
||||
|
||||
printf("==================================================\n");
|
||||
printf(" STARTING C_STRINGBUFFER UNIT TESTING \n");
|
||||
printf("==================================================\n");
|
||||
|
||||
/* 1. API Parameter Defensive Checks (Null Guards) */
|
||||
RUN_TEST(c_StringBuffer_Init(NULL, 16) == C_ERR_PARAM, "Init handles NULL self context");
|
||||
RUN_TEST(c_StringBuffer_Append(NULL, "a", 1) == C_ERR_PARAM, "Append checks NULL self");
|
||||
RUN_TEST(c_StringBuffer_Prepend(NULL, "a", 1) == C_ERR_PARAM, "Prepend checks NULL self");
|
||||
RUN_TEST(c_StringBuffer_InsertAt(NULL, 0, "a", 1) == C_ERR_PARAM, "InsertAt checks NULL self");
|
||||
RUN_TEST(c_StringBuffer_RemoveAt(NULL, 0, 1) == C_ERR_PARAM, "RemoveAt checks NULL self");
|
||||
RUN_TEST(c_StringBuffer_CopyTo(NULL, 0, 1, copy_target, 64) == C_ERR_PARAM, "CopyTo checks NULL self");
|
||||
|
||||
/* 2. Initialization Test Block (Init) */
|
||||
err = c_StringBuffer_Init(&sb, 4); // Initialize with small capacity to force upcoming resizing branches
|
||||
RUN_TEST(err == C_ERR_OK, "Initialization with tiny explicit capacity returns C_ERR_OK");
|
||||
RUN_TEST(sb.size == 0, "Initial tracked contents data size is 0");
|
||||
RUN_TEST(sb.capacity == 4, "Initial tracking allocation capacity is 4");
|
||||
RUN_TEST(sb.buffer != NULL, "Internal tracking byte storage buffer successfully bound");
|
||||
RUN_TEST(sb.buffer[0] == '\0', "Empty buffer is safely terminated with null byte");
|
||||
|
||||
/* 3. Length-bounded Insertion Operations (Append, Prepend, InsertAt) */
|
||||
// Append test
|
||||
err = c_StringBuffer_Append(&sb, "Trie", 4);
|
||||
RUN_TEST(err == C_ERR_OK, "Append bounded segment 'Trie'");
|
||||
RUN_TEST(sb.size == 4, "Size matches append width");
|
||||
RUN_TEST(strcmp(sb.buffer, "Trie") == 0, "Buffer contains exact match string 'Trie'");
|
||||
|
||||
// Prepend test
|
||||
err = c_StringBuffer_Prepend(&sb, "Nlp", 3);
|
||||
RUN_TEST(err == C_ERR_OK, "Prepend bounded segment 'Nlp' to front");
|
||||
RUN_TEST(sb.size == 7, "Size extended to 7 bytes total");
|
||||
RUN_TEST(strcmp(sb.buffer, "NlpTrie") == 0, "Buffer shifted correctly into 'NlpTrie'");
|
||||
|
||||
// InsertAt test (Middle shifting memory operation)
|
||||
err = c_StringBuffer_InsertAt(&sb, 3, "_", 1);
|
||||
RUN_TEST(err == C_ERR_OK, "InsertAt index 3 inserts an underscore character");
|
||||
RUN_TEST(strcmp(sb.buffer, "Nlp_Trie") == 0, "Memory shifted left/right flawlessly: 'Nlp_Trie'");
|
||||
|
||||
/* 4. Exponential Expansion Threshold Guard Check */
|
||||
// Pushing string past current internal storage boundaries to trigger C_ALLOC resizing
|
||||
err = c_StringBuffer_Append(&sb, "_DataStructure", 14);
|
||||
RUN_TEST(err == C_ERR_OK, "Forced exponential buffer reallocation with large string append");
|
||||
RUN_TEST(sb.size == 22, "Size correctly aggregated up to 22 bytes total");
|
||||
RUN_TEST(sb.capacity >= 23, "Capacity upscaled cleanly beyond its initial 4-byte threshold limit");
|
||||
RUN_TEST(strcmp(sb.buffer, "Nlp_Trie_DataStructure") == 0, "Post-reallocation string remains integrated and uncorrupted");
|
||||
|
||||
/* 5. Memory Shift Extraction Operations (RemoveAt) */
|
||||
// Current payload structure: "Nlp_Trie_DataStructure"
|
||||
// Remove mid segment "_DataStructure" starting at index 8
|
||||
err = c_StringBuffer_RemoveAt(&sb, 8, 14);
|
||||
RUN_TEST(err == C_ERR_OK, "RemoveAt clears middle segment '_DataStructure'");
|
||||
RUN_TEST(sb.size == 8, "Size downshifted cleanly to 8 bytes");
|
||||
RUN_TEST(strcmp(sb.buffer, "Nlp_Trie") == 0, "Character array closed gaps safely to hold 'Nlp_Trie'");
|
||||
|
||||
// Test automatic length clamping over boundary limit edge cases
|
||||
err = c_StringBuffer_RemoveAt(&sb, 3, 50); // 50 overshoot actual size limits
|
||||
RUN_TEST(err == C_ERR_OK, "RemoveAt automatically clamps requesting lengths overflowing edge limits");
|
||||
RUN_TEST(sb.size == 3, "Length updated down to index bounds");
|
||||
RUN_TEST(strcmp(sb.buffer, "Nlp") == 0, "Buffer contains truncated string 'Nlp'");
|
||||
|
||||
/* 6. Explicit String Wrapper Interfaces (AppendStr, PrependStr, InsertStrAt) */
|
||||
c_StringBuffer_Clear(&sb);
|
||||
RUN_TEST(sb.size == 0 && sb.buffer[0] == '\0', "Clear flushes buffer structure size indicators cleanly");
|
||||
|
||||
err = c_StringBuffer_AppendStr(&sb, "Core");
|
||||
err |= c_StringBuffer_PrependStr(&sb, "C_");
|
||||
err |= c_StringBuffer_InsertStrAt(&sb, "Nlp", 2); // Insert "Nlp" into index 2 ("C_Core" -> "C_NlpCore")
|
||||
|
||||
RUN_TEST(err == C_ERR_OK, "All explicit string wrapper functions evaluated with valid results");
|
||||
RUN_TEST(strcmp(sb.buffer, "C_NlpCore") == 0, "String wrapper cascade holds correct output value 'C_NlpCore'");
|
||||
|
||||
/* 7. Substring Extraction Pipeline Test (CopyTo) */
|
||||
// Test slice matching operations
|
||||
err = c_StringBuffer_CopyTo(&sb, 2, 3, copy_target, sizeof(copy_target));
|
||||
RUN_TEST(err == C_ERR_OK, "CopyTo safely slices subset out to isolated external layout target");
|
||||
RUN_TEST(strcmp(copy_target, "Nlp") == 0, "External buffer extracted substring captures token 'Nlp' correctly");
|
||||
|
||||
// Test out of bounds inputs rejection properties
|
||||
RUN_TEST(c_StringBuffer_CopyTo(&sb, 2, 3, copy_target, 2) == C_ERR_PARAM, "CopyTo blocks actions when external buffer is too small");
|
||||
RUN_TEST(c_StringBuffer_CopyTo(&sb, 999, 1, copy_target, sizeof(copy_target)) == C_ERR_PARAM, "CopyTo blocks crazy out of range index arguments");
|
||||
|
||||
/* 8. Multi-Byte UTF-8 String Asset Integrity Checks */
|
||||
c_StringBuffer_Clear(&sb);
|
||||
err = c_StringBuffer_AppendStr(&sb, "语言");
|
||||
err |= c_StringBuffer_PrependStr(&sb, "自然");
|
||||
err |= c_StringBuffer_AppendStr(&sb, "处理"); // "自然语言处理"
|
||||
|
||||
RUN_TEST(err == C_ERR_OK, "Piped raw multi-byte Chinese UTF-8 string tokens through buffer channels");
|
||||
RUN_TEST(strcmp(sb.buffer, "自然语言处理") == 0, "Raw multi-byte array matches validation configuration stream");
|
||||
|
||||
/* 9. Destruction Lifecycle Cleanliness Verification */
|
||||
c_StringBuffer_Destroy(&sb);
|
||||
RUN_TEST(sb.buffer == NULL, "Array tracking pointer nullified successfully upon calling destructor");
|
||||
RUN_TEST(sb.size == 0 && sb.capacity == 0, "Structural trackers set to 0");
|
||||
|
||||
// Idempotency execution test sequence
|
||||
c_StringBuffer_Destroy(&sb);
|
||||
c_StringBuffer_Destroy(NULL);
|
||||
printf("[TEST] Double string buffer destruction safety... \033[32mPASSED\033[0m\n");
|
||||
|
||||
printf("==================================================\n");
|
||||
printf("\033[32mSUCCESS: ALL C_STRINGBUFFER TESTS COMPLETED SUCCESSFULLY!\033[0m\n");
|
||||
printf("==================================================\n");
|
||||
|
||||
return C_ERR_OK;
|
||||
static c_err_t test_harness_vprintf(c_StringBuffer_t* self, const char* format, ...) {
|
||||
va_list args;
|
||||
va_start(args, format);
|
||||
c_err_t err = c_StringBuffer_VPrintf(self, format, args);
|
||||
va_end(args);
|
||||
return err;
|
||||
}
|
||||
|
||||
static c_err_t test_harness_vprintf_at(c_StringBuffer_t* self, c_size_t index, const char* format, ...) {
|
||||
va_list args;
|
||||
va_start(args, format);
|
||||
c_err_t err = c_StringBuffer_VPrintfAt(self, index, format, args);
|
||||
va_end(args);
|
||||
return err;
|
||||
}
|
||||
|
||||
/* --- Module 1: Structural Allocation Lifecycle Management --- */
|
||||
static void test_lifecycle_and_clear(void) {
|
||||
c_StringBuffer_t sb;
|
||||
|
||||
// Validate NULL parameters are rejected deterministically
|
||||
assert(c_StringBuffer_Init(NULL, 64) == C_ERR_INVALID_PARAM);
|
||||
|
||||
// Standard allocation flow verification
|
||||
assert(c_StringBuffer_Init(&sb, 16) == C_SUCCESS);
|
||||
assert(sb.size == 0);
|
||||
assert(sb.capacity >= 16); // Implicit null-terminator overhead validation
|
||||
assert(sb.buffer != NULL);
|
||||
assert(sb.buffer[0] == '\0');
|
||||
|
||||
// Data clearing verification
|
||||
assert(c_StringBuffer_AppendStr(&sb, "DynamicDataPayload") == C_SUCCESS);
|
||||
assert(sb.size == 18);
|
||||
c_StringBuffer_Clear(&sb);
|
||||
assert(sb.size == 0);
|
||||
assert(sb.buffer[0] == '\0'); // Ensure implicit closure byte remains active
|
||||
|
||||
// Release phase validation
|
||||
c_StringBuffer_Destroy(&sb);
|
||||
assert(sb.buffer == NULL);
|
||||
assert(sb.capacity == 0);
|
||||
assert(sb.size == 0);
|
||||
|
||||
// Idempotent protection check against multi-free configurations
|
||||
c_StringBuffer_Destroy(NULL);
|
||||
c_StringBuffer_Destroy(&sb);
|
||||
}
|
||||
|
||||
/* --- Module 2: Memory Relocation & Byte Array Mutation Ops --- */
|
||||
static void test_array_mutations(void) {
|
||||
c_StringBuffer_t sb;
|
||||
assert(c_StringBuffer_Init(&sb, 2) == C_SUCCESS); // Aggressive scaling constraint
|
||||
|
||||
// Check boundary anomalies
|
||||
assert(c_StringBuffer_Append(NULL, "data", 4) == C_ERR_INVALID_PARAM);
|
||||
assert(c_StringBuffer_Append(&sb, NULL, 4) == C_ERR_INVALID_PARAM);
|
||||
assert(c_StringBuffer_Append(&sb, "ZeroOp", 0) == C_ERR_INVALID_PARAM);
|
||||
|
||||
// Append tracking
|
||||
assert(c_StringBuffer_AppendStr(&sb, "Engine") == C_SUCCESS);
|
||||
assert(strcmp(sb.buffer, "Engine") == 0);
|
||||
assert(sb.size == 6);
|
||||
|
||||
// Prepend and structural layout shift tracking
|
||||
assert(c_StringBuffer_PrependStr(&sb, "Core ") == C_SUCCESS);
|
||||
assert(strcmp(sb.buffer, "Core Engine") == 0);
|
||||
assert(sb.size == 11);
|
||||
|
||||
// Index tracking and arbitrary memory slice insertions
|
||||
assert(c_StringBuffer_InsertStrAt(&sb, "Graphics ", 5) == C_SUCCESS);
|
||||
assert(strcmp(sb.buffer, "Core Graphics Engine") == 0);
|
||||
assert(c_StringBuffer_InsertStrAt(&sb, "OOB", 256) == C_ERR_OUT_OF_BOUNDS);
|
||||
|
||||
// Data element contraction testing via RemoveAt
|
||||
assert(c_StringBuffer_RemoveAt(&sb, 50, 2) == C_ERR_OUT_OF_BOUNDS);
|
||||
assert(c_StringBuffer_RemoveAt(&sb, 5, 0) == C_SUCCESS);
|
||||
assert(c_StringBuffer_RemoveAt(&sb, 5, 9) == C_SUCCESS); // Cleaves out "Graphics "
|
||||
assert(strcmp(sb.buffer, "Core Engine") == 0);
|
||||
assert(sb.size == 11);
|
||||
|
||||
// Clamping limits validation: Removing past structural layout capacity boundaries
|
||||
assert(c_StringBuffer_RemoveAt(&sb, 4, 100) == C_SUCCESS);
|
||||
assert(strcmp(sb.buffer, "Core") == 0);
|
||||
assert(sb.size == 4);
|
||||
|
||||
// Outbound array replication via CopyTo
|
||||
char export_buffer[16];
|
||||
assert(c_StringBuffer_CopyTo(&sb, 0, 4, export_buffer, sizeof(export_buffer)) == C_SUCCESS);
|
||||
assert(strcmp(export_buffer, "Core") == 0);
|
||||
|
||||
// Buffer optimization check: Truncation logic preservation on small arrays
|
||||
assert(c_StringBuffer_CopyTo(&sb, 0, 4, export_buffer, 3) == C_ERR_OUT_OF_BOUNDS); // Destination size limit 3
|
||||
// assert(strcmp(export_buffer, "Co") == 0); // Fits "Co" + '\0' safely
|
||||
|
||||
c_StringBuffer_Destroy(&sb);
|
||||
}
|
||||
|
||||
/* --- Module 3: Format Translators & Interleaved Injections --- */
|
||||
static void test_formatting_engines(void) {
|
||||
c_StringBuffer_t sb;
|
||||
assert(c_StringBuffer_Init(&sb, 8) == C_SUCCESS);
|
||||
|
||||
// Standard Printf string generation
|
||||
assert(c_StringBuffer_Printf(&sb, "%s = %04d", "Status", 200) == C_SUCCESS);
|
||||
assert(strcmp(sb.buffer, "Status = 0200") == 0);
|
||||
|
||||
// Reentrant list validation via VPrintf
|
||||
c_StringBuffer_Clear(&sb);
|
||||
assert(test_harness_vprintf(&sb, "Float: %.2f", 3.14159) == C_SUCCESS);
|
||||
assert(strcmp(sb.buffer, "Float: 3.14") == 0);
|
||||
|
||||
// Deep structural data layout testing: PrintfAt string middle-smashes
|
||||
c_StringBuffer_Clear(&sb);
|
||||
assert(c_StringBuffer_AppendStr(&sb, "Alpha-Gamma") == C_SUCCESS);
|
||||
|
||||
// Inject "Beta-" precisely at index position 6 without breaking string sequence chains
|
||||
assert(c_StringBuffer_PrintfAt(&sb, 6, "%s-", "Beta") == C_SUCCESS);
|
||||
assert(strcmp(sb.buffer, "Alpha-Beta-Gamma") == 0);
|
||||
assert(sb.size == 16);
|
||||
|
||||
// Reentrant multi-layer gap injection testing via VPrintfAt
|
||||
assert(test_harness_vprintf_at(&sb, 0, "[%c]", 'I') == C_SUCCESS);
|
||||
assert(strcmp(sb.buffer, "[I]Alpha-Beta-Gamma") == 0);
|
||||
|
||||
c_StringBuffer_Destroy(&sb);
|
||||
}
|
||||
|
||||
/* --- Module 4: Speculative Loop Chronology Modules --- */
|
||||
static void test_chronology_modules(void) {
|
||||
c_StringBuffer_t sb;
|
||||
assert(c_StringBuffer_Init(&sb, 4) == C_SUCCESS);
|
||||
|
||||
struct tm mock_epoch;
|
||||
mock_epoch.tm_year = 126; // Year 2026 representation framework
|
||||
mock_epoch.tm_mon = 7; // August calibration index
|
||||
mock_epoch.tm_mday = 10;
|
||||
mock_epoch.tm_hour = 14;
|
||||
mock_epoch.tm_min = 22;
|
||||
mock_epoch.tm_sec = 45;
|
||||
|
||||
// Direct temporal formatting validation
|
||||
assert(c_StringBuffer_AppendTimestamp(&sb, "%Y/%m/%d", &mock_epoch) == C_SUCCESS);
|
||||
assert(strcmp(sb.buffer, "2026/08/10") == 0);
|
||||
|
||||
// Isolated gap injection validation with temporal entities
|
||||
c_StringBuffer_Clear(&sb);
|
||||
assert(c_StringBuffer_AppendStr(&sb, "EventOccurred") == C_SUCCESS);
|
||||
assert(c_StringBuffer_InsertTimestampAt(&sb, 0, "%H:%M:%S ", &mock_epoch) == C_SUCCESS);
|
||||
assert(strcmp(sb.buffer, "14:22:45 EventOccurred") == 0);
|
||||
|
||||
// Running standard OS system time verification (Ensures dynamic layout executes cleanly)
|
||||
c_StringBuffer_Clear(&sb);
|
||||
assert(c_StringBuffer_AppendCurrentTimestamp(&sb, "%M", 1) == C_SUCCESS); // UTC trace scan
|
||||
assert(sb.size == 2); // Double-digit alignment validation
|
||||
|
||||
c_StringBuffer_Destroy(&sb);
|
||||
}
|
||||
|
||||
/* --- Module 5: Lexical Scanners & Backward Lookups --- */
|
||||
static void test_lexical_scanners(void) {
|
||||
c_StringBuffer_t sb;
|
||||
assert(c_StringBuffer_Init(&sb, 32) == C_SUCCESS);
|
||||
assert(c_StringBuffer_AppendStr(&sb, "ping-pong-ping-pong") == C_SUCCESS);
|
||||
|
||||
// Linear scanning paths verification
|
||||
assert(c_StringBuffer_IndexOfStr(&sb, 0, "pong") == 5);
|
||||
assert(c_StringBuffer_IndexOfStr(&sb, 6, "pong") == 15); // Offset search skip boundaries
|
||||
assert(c_StringBuffer_IndexOfStr(&sb, 0, "missing") == C_ERR_NOT_FOUND);
|
||||
assert(c_StringBuffer_IndexOfChar(&sb, 0, '-') == 4);
|
||||
assert(c_StringBuffer_IndexOfChar(&sb, 0, 'x') == C_ERR_NOT_FOUND);
|
||||
|
||||
// High performance reversed traversal trace verification
|
||||
assert(c_StringBuffer_LastIndexOfStr(&sb, 19, "ping") == 10);
|
||||
assert(c_StringBuffer_LastIndexOfStr(&sb, 8, "ping") == 0); // Window limits validation
|
||||
assert(c_StringBuffer_LastIndexOfChar(&sb, 19, '-') == 14);
|
||||
assert(c_StringBuffer_LastIndexOfChar(&sb, 2, '-') == C_ERR_NOT_FOUND);
|
||||
|
||||
c_StringBuffer_Destroy(&sb);
|
||||
}
|
||||
|
||||
/* --- Module 6: Matrix Transformations & Space Cleavers --- */
|
||||
static void test_transformations_and_cleavers(void) {
|
||||
c_StringBuffer_t sb;
|
||||
assert(c_StringBuffer_Init(&sb, 8) == C_SUCCESS);
|
||||
|
||||
// Substitute logic metrics path variations
|
||||
assert(c_StringBuffer_AppendStr(&sb, "one_two_one") == C_SUCCESS);
|
||||
assert(c_StringBuffer_ReplaceStr(&sb, "one", "1") == C_SUCCESS); // Footprint size contraction
|
||||
assert(strcmp(sb.buffer, "1_two_1") == 0);
|
||||
|
||||
assert(c_StringBuffer_ReplaceStr(&sb, "1", "three") == C_SUCCESS); // Footprint size expansion delta
|
||||
assert(strcmp(sb.buffer, "three_two_three") == 0);
|
||||
|
||||
// Whitespace elimination tracking loops
|
||||
c_StringBuffer_Clear(&sb);
|
||||
assert(c_StringBuffer_AppendStr(&sb, " \r\n\t TokenPayload \t ") == C_SUCCESS);
|
||||
|
||||
assert(c_StringBuffer_TrimLeft(&sb) == C_SUCCESS);
|
||||
assert(strcmp(sb.buffer, "TokenPayload \t ") == 0);
|
||||
|
||||
assert(c_StringBuffer_TrimRight(&sb) == C_SUCCESS);
|
||||
assert(strcmp(sb.buffer, "TokenPayload") == 0);
|
||||
assert(sb.size == 12);
|
||||
|
||||
c_StringBuffer_Destroy(&sb);
|
||||
}
|
||||
|
||||
/* --- Module 7: Lexical Casers & Coordinate Range Extractions --- */
|
||||
static void test_casers_and_extractions(void) {
|
||||
c_StringBuffer_t sb;
|
||||
assert(c_StringBuffer_Init(&sb, 16) == C_SUCCESS);
|
||||
assert(c_StringBuffer_AppendStr(&sb, "xYz987W") == C_SUCCESS);
|
||||
|
||||
// Case conversions
|
||||
assert(c_StringBuffer_ToUpper(&sb) == C_SUCCESS);
|
||||
assert(strcmp(sb.buffer, "XYZ987W") == 0);
|
||||
assert(c_StringBuffer_ToLower(&sb) == C_SUCCESS);
|
||||
assert(strcmp(sb.buffer, "xyz987w") == 0);
|
||||
|
||||
// In-place byte symmetry reversal loop verification
|
||||
c_StringBuffer_Clear(&sb);
|
||||
assert(c_StringBuffer_AppendStr(&sb, "radar-test") == C_SUCCESS);
|
||||
assert(c_StringBuffer_Reverse(&sb) == C_SUCCESS);
|
||||
assert(strcmp(sb.buffer, "tset-radar") == 0);
|
||||
|
||||
// Slicing metrics via Substr
|
||||
c_StringBuffer_Clear(&sb);
|
||||
assert(c_StringBuffer_AppendStr(&sb, "Distributed-Architecture") == C_SUCCESS);
|
||||
c_StringBuffer_t target_slice;
|
||||
assert(c_StringBuffer_Substr(&sb, 12, 12, &target_slice) == C_SUCCESS); // Extract "Architecture"
|
||||
assert(strcmp(target_slice.buffer, "Architecture") == 0);
|
||||
c_StringBuffer_Destroy(&target_slice);
|
||||
|
||||
// Coordinate clipping window tests via Slice
|
||||
assert(c_StringBuffer_Slice(&sb, 0, 11, &target_slice) == C_SUCCESS); // Extract "Distributed"
|
||||
assert(strcmp(target_slice.buffer, "Distributed") == 0);
|
||||
c_StringBuffer_Destroy(&target_slice);
|
||||
|
||||
c_StringBuffer_Destroy(&sb);
|
||||
}
|
||||
|
||||
/* --- Module 8: Dual-Scan Pipelines & Structural Join Topologies --- */
|
||||
static void test_pipeline_and_joins(void) {
|
||||
c_StringBuffer_t sb;
|
||||
assert(c_StringBuffer_Init(&sb, 64) == C_SUCCESS);
|
||||
assert(c_StringBuffer_AppendStr(&sb, "Alpha::Beta::::Gamma::") == C_SUCCESS); // Multi-byte delimiter with blanks
|
||||
|
||||
c_StringBuffer_t* token_array = NULL;
|
||||
c_size_t token_count = 0;
|
||||
|
||||
// Process double-scan split array pipeline
|
||||
assert(c_StringBuffer_Split(&sb, "::", &token_array, &token_count) == C_SUCCESS);
|
||||
|
||||
assert(token_count == 5);
|
||||
assert(strcmp(token_array[0].buffer, "Alpha") == 0);
|
||||
assert(strcmp(token_array[1].buffer, "Beta") == 0);
|
||||
assert(strcmp(token_array[2].buffer, "") == 0); // Gap null evaluation validation
|
||||
assert(strcmp(token_array[3].buffer, "Gamma") == 0);
|
||||
assert(strcmp(token_array[4].buffer, "") == 0); // Terminal tracking null check
|
||||
|
||||
// High performance sequential recombination loop testing via Join
|
||||
c_StringBuffer_t output_combiner;
|
||||
assert(c_StringBuffer_Init(&output_combiner, 8) == C_SUCCESS);
|
||||
assert(c_StringBuffer_Join(&output_combiner, token_array, token_count, "=>") == C_SUCCESS);
|
||||
assert(strcmp(output_combiner.buffer, "Alpha=>Beta=>=>Gamma=>") == 0);
|
||||
|
||||
// Double-scan array deallocation teardown routines
|
||||
for (c_size_t i = 0; i < token_count; i++) {
|
||||
c_StringBuffer_Destroy(&token_array[i]);
|
||||
}
|
||||
free(token_array);
|
||||
c_StringBuffer_Destroy(&output_combiner);
|
||||
c_StringBuffer_Destroy(&sb);
|
||||
}
|
||||
|
||||
/* --- Module 9: Evaluation Comparators & Alphabetical Sort Anchors --- */
|
||||
static void test_comparators(void) {
|
||||
c_StringBuffer_t sb;
|
||||
assert(c_StringBuffer_Init(&sb, 16) == C_SUCCESS);
|
||||
assert(c_StringBuffer_AppendStr(&sb, "Microcontroller-C") == C_SUCCESS);
|
||||
|
||||
// Equality filters verification
|
||||
assert(c_StringBuffer_Equals(&sb, "Microcontroller-C") == 1);
|
||||
assert(c_StringBuffer_Equals(&sb, "microcontroller-c") == 0);
|
||||
assert(c_StringBuffer_EqualsIgnoreCase(&sb, "microcontroller-c") == 1);
|
||||
assert(c_StringBuffer_Equals(&sb, "Microcontroller") == 0);
|
||||
|
||||
// Lexical lookup evaluation boundaries matching typical strcmp return matrices
|
||||
assert(c_StringBuffer_Compare(&sb, "Application") > 0); // M > A
|
||||
assert(c_StringBuffer_Compare(&sb, "Microcontroller-C") == 0);
|
||||
assert(c_StringBuffer_Compare(&sb, "Zebrafish") < 0); // M < Z
|
||||
assert(c_StringBuffer_Compare(&sb, NULL) > 0); // Edge-case null baseline swap check
|
||||
|
||||
c_StringBuffer_Destroy(&sb);
|
||||
}
|
||||
|
||||
static void test_strtoul_conversion(void) {
|
||||
c_StringBuffer_t sb;
|
||||
assert(c_StringBuffer_Init(&sb, 32) == C_SUCCESS);
|
||||
assert(c_StringBuffer_AppendStr(&sb, "Data: 1024, Hex: 0x2A") == C_SUCCESS);
|
||||
|
||||
unsigned long parsed_val = 0;
|
||||
c_size_t end_idx = 0;
|
||||
|
||||
// Test 1: Parse Base-10 integer from index position 6 ("1024...")
|
||||
assert(c_StringBuffer_strtoul(&sb, 6, 10, &parsed_val, &end_idx) == C_SUCCESS);
|
||||
assert(parsed_val == 1024);
|
||||
assert(end_idx == 10); // Index point of the trailing comma character
|
||||
|
||||
// Test 2: Parse Base-16 hexadecimal starting from index position 17 ("0x2A")
|
||||
assert(c_StringBuffer_strtoul(&sb, 17, 16, &parsed_val, NULL) == C_SUCCESS);
|
||||
assert(parsed_val == 42); // 0x2A translates to decimal 42
|
||||
|
||||
// Test 3: Attempt conversion from non-numeric text index (invalid param error)
|
||||
assert(c_StringBuffer_strtoul(&sb, 0, 10, &parsed_val, NULL) == C_ERR_INVALID_PARAM);
|
||||
|
||||
c_StringBuffer_Destroy(&sb);
|
||||
}
|
||||
|
||||
|
||||
#define RUN_TEST_CASE(test_func) \
|
||||
do { \
|
||||
printf("[RUNNING] %-40s ... ", #test_func); \
|
||||
fflush(stdout); \
|
||||
test_func(); \
|
||||
printf("[PASSED]\n"); \
|
||||
} while (0)
|
||||
|
||||
int main(int argc, char** argv){
|
||||
if (c_StringBuffer_UnitTest() != C_ERR_OK) {
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
printf("=====================================================================\n");
|
||||
printf(" LAUNCHING C_STRINGBUFFER CORNER-CASE SPECIFICATION VERIFICATION \n");
|
||||
printf("=====================================================================\n");
|
||||
|
||||
RUN_TEST_CASE(test_lifecycle_and_clear);
|
||||
RUN_TEST_CASE(test_array_mutations);
|
||||
RUN_TEST_CASE(test_formatting_engines);
|
||||
RUN_TEST_CASE(test_chronology_modules);
|
||||
RUN_TEST_CASE(test_lexical_scanners);
|
||||
RUN_TEST_CASE(test_transformations_and_cleavers);
|
||||
RUN_TEST_CASE(test_casers_and_extractions);
|
||||
RUN_TEST_CASE(test_pipeline_and_joins);
|
||||
RUN_TEST_CASE(test_comparators);
|
||||
RUN_TEST_CASE(test_strtoul_conversion);
|
||||
|
||||
printf("=====================================================================\n");
|
||||
printf(" [🎉 VERIFIED] Absolute architecture spec checklist matches perfectly. \n");
|
||||
printf("=====================================================================\n");
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user