WriteFmtLn

Macro
October 8, 2025

Table of Contents

`WriteFmtLn`

Description

Write formatted output to the standard output stream (stdout) followed by a newline. This is a convenience macro calling FWriteFmtLn with stdout.

Parameters

Name	Direction	Description
`fmtstr`	in	Format string with `{}` placeholders. should be wrapped with `variable`.

Success

Placeholders in fmtstr are replaced by the passed arguments, and the resulting formatted string followed by a newline is written to stdout.

Failure

Failure might occur during memory allocation for the temporary string or during the write operation to stdout (fputs or fputc). Errors from StrWriteFmtInternal (logging messages) might also occur.

Usage example (Cross-references)

In Vec.Remove.c:29:

    // Test VecPopBack function
    bool test_vec_pop_back(void) {
    WriteFmtLn("Testing VecPopBack");
    
    // Create a vector of integers

In Vec.Remove.c:77:

    // Test VecPopFront function
    bool test_vec_pop_front(void) {
    WriteFmtLn("Testing VecPopFront");
    
    // Create a vector of integers

In Vec.Remove.c:125:

    // Test VecDelete function
    bool test_vec_delete(void) {
    WriteFmtLn("Testing VecDelete");
    
    // Create a vector of integers

In Vec.Remove.c:173:

    // Test VecDeleteFast function
    bool test_vec_delete_fast(void) {
    WriteFmtLn("Testing VecDeleteFast");
    
    // Create a vector of integers

In Vec.Remove.c:210:

    // Test VecDeleteRange function
    bool test_vec_delete_range(void) {
    WriteFmtLn("Testing VecDeleteRange");
    
    // Create a vector of integers

In Vec.Remove.c:246:

    // Test VecDeleteRangeFast
    bool test_vec_delete_range_fast(void) {
    WriteFmtLn("Testing VecDeleteRangeFast");
    
    // Create a vector of integers

In Vec.Remove.c:322:

    // Test VecDeleteLast function
    bool test_vec_delete_last(void) {
    WriteFmtLn("Testing VecDeleteLast");
    
    // Create a vector of integers

In Vec.Remove.c:368:

    // Test L-value standard delete operations
    bool test_lvalue_delete_operations(void) {
    WriteFmtLn("Testing L-value standard delete operations");
    
    // Create a vector of integers

In Vec.Remove.c:404:

    // Test R-value standard delete operations
    bool test_rvalue_delete_operations(void) {
    WriteFmtLn("Testing R-value standard delete operations");
    
    // Create a vector of integers

In Vec.Remove.c:439:

    // Test L-value fast delete operations
    bool test_lvalue_fast_delete_operations(void) {
    WriteFmtLn("Testing L-value fast delete operations");
    
    // Create a vector of integers

In Vec.Remove.c:489:

    // Check that the value at the deleted position is now the last value
    result = result && (VecAt(&vec, fast_index) == lastValue);
    WriteFmtLn(
    "Value at deleted position ({}) is now {} (expected {})\n",
    fast_index,

In Vec.Remove.c:508:

    result = result && found;
    if (!found) {
    WriteFmtLn("Value {} should be present but was not found", expected_values[i]);
    }
    }

In Vec.Remove.c:520:

    // Test R-value fast delete operations
    bool test_rvalue_fast_delete_operations(void) {
    WriteFmtLn("Testing R-value fast delete operations");
    
    // Create a vector of integers

In Vec.Remove.c:571:

    // Check that the value at the deleted position is now the last value
    result = result && (VecAt(&vec, 2) == lastValue);
    WriteFmtLn("Value at deleted position (2) is now {} (expected {})\n", VecAt(&vec, 2), lastValue);
    
    // Verify all expected values (except the deleted one and the moved one) are still present

In Vec.Remove.c:585:

    result = result && found;
    if (!found) {
    WriteFmtLn("Value {} should be present but was not found", expected_values[i]);
    }
    }

In Vec.Remove.c:597:

    // Test L-value delete range operations
    bool test_lvalue_delete_range_operations(void) {
    WriteFmtLn("Testing L-value delete range operations");
    
    // Create a vector of integers

In Vec.Remove.c:634:

    // Test R-value delete range operations
    bool test_rvalue_delete_range_operations(void) {
    WriteFmtLn("Testing R-value delete range operations");
    
    // Create a vector of integers

In Vec.Remove.c:669:

    // Test L-value fast delete range operations
    bool test_lvalue_fast_delete_range_operations(void) {
    WriteFmtLn("Testing L-value fast delete range operations");
    
    // Create a vector of integers

In Vec.Remove.c:720:

    result = result && !found;
    if (found) {
    WriteFmtLn("Value {} should be deleted but was found", valuesToDelete[i]);
    }
    }

In Vec.Remove.c:736:

    result = result && found;
    if (!found) {
    WriteFmtLn("Value {} should be present but was not found", remainingValues[i]);
    }
    }

In Vec.Remove.c:748:

    // Test R-value fast delete range operations
    bool test_rvalue_fast_delete_range_operations(void) {
    WriteFmtLn("Testing R-value fast delete range operations");
    
    // Create a vector of integers

In Vec.Remove.c:797:

    result = result && !found;
    if (found) {
    WriteFmtLn("Value {} should be deleted but was found", valuesToDelete[i]);
    }
    }

In Vec.Remove.c:813:

    result = result && found;
    if (!found) {
    WriteFmtLn("Value {} should be present but was not found", remainingValues[i]);
    }
    }

In BitVec.BitWise.c:33:

    // Test BitVecAnd function
    bool test_bitvec_and(void) {
    WriteFmtLn("Testing BitVecAnd");
    
    BitVec bv1    = BitVecInit();

In BitVec.BitWise.c:71:

    // Test BitVecOr function
    bool test_bitvec_or(void) {
    WriteFmtLn("Testing BitVecOr");
    
    BitVec bv1    = BitVecInit();

In BitVec.BitWise.c:109:

    // Test BitVecXor function
    bool test_bitvec_xor(void) {
    WriteFmtLn("Testing BitVecXor");
    
    BitVec bv1    = BitVecInit();

In BitVec.BitWise.c:147:

    // Test BitVecNot function
    bool test_bitvec_not(void) {
    WriteFmtLn("Testing BitVecNot");
    
    BitVec bv     = BitVecInit();

In BitVec.BitWise.c:177:

    // Test BitVecShiftLeft function - CORRECTED EXPECTATIONS
    bool test_bitvec_shift_left(void) {
    WriteFmtLn("Testing BitVecShiftLeft");
    
    BitVec bv = BitVecInit();

In BitVec.BitWise.c:218:

    // Test BitVecShiftRight function - CORRECTED EXPECTATIONS
    bool test_bitvec_shift_right(void) {
    WriteFmtLn("Testing BitVecShiftRight");
    
    BitVec bv = BitVecInit();

In BitVec.BitWise.c:252:

    // Test BitVecRotateLeft function
    bool test_bitvec_rotate_left(void) {
    WriteFmtLn("Testing BitVecRotateLeft");
    
    BitVec bv = BitVecInit();

In BitVec.BitWise.c:280:

    // Test BitVecRotateRight function
    bool test_bitvec_rotate_right(void) {
    WriteFmtLn("Testing BitVecRotateRight");
    
    BitVec bv = BitVecInit();

In BitVec.BitWise.c:308:

    // Test BitVecReverse function
    bool test_bitvec_reverse(void) {
    WriteFmtLn("Testing BitVecReverse");
    
    BitVec bv = BitVecInit();

In BitVec.BitWise.c:336:

    // Edge case tests
    bool test_bitvec_shift_edge_cases(void) {
    WriteFmtLn("Testing BitVec shift edge cases");
    
    BitVec bv     = BitVecInit();

In BitVec.BitWise.c:372:

    
    bool test_bitvec_rotate_edge_cases(void) {
    WriteFmtLn("Testing BitVec rotate edge cases");
    
    BitVec bv     = BitVecInit();

In BitVec.BitWise.c:400:

    
    bool test_bitvec_bitwise_ops_edge_cases(void) {
    WriteFmtLn("Testing BitVec bitwise operations edge cases");
    
    BitVec bv1    = BitVecInit();

In BitVec.BitWise.c:439:

    
    bool test_bitvec_reverse_edge_cases(void) {
    WriteFmtLn("Testing BitVecReverse edge cases");
    
    BitVec bv     = BitVecInit();

In BitVec.BitWise.c:473:

    // NEW: Comprehensive bitwise operations testing
    bool test_bitvec_bitwise_comprehensive(void) {
    WriteFmtLn("Testing BitVec comprehensive bitwise operations");
    
    BitVec bv1         = BitVecInit();

In BitVec.BitWise.c:539:

    // NEW: Comprehensive shift testing
    bool test_bitvec_shift_comprehensive(void) {
    WriteFmtLn("Testing BitVec comprehensive shift operations");
    
    BitVec bv     = BitVecInit();

In BitVec.BitWise.c:605:

    // NEW: Comprehensive rotate testing
    bool test_bitvec_rotate_comprehensive(void) {
    WriteFmtLn("Testing BitVec comprehensive rotate operations");
    
    BitVec bv     = BitVecInit();

In BitVec.BitWise.c:667:

    // NEW: Identity operations testing
    bool test_bitvec_bitwise_identity_operations(void) {
    WriteFmtLn("Testing BitVec bitwise identity operations");
    
    BitVec bv1         = BitVecInit();

In BitVec.BitWise.c:761:

    // NEW: Commutative properties testing
    bool test_bitvec_bitwise_commutative_properties(void) {
    WriteFmtLn("Testing BitVec bitwise commutative properties");
    
    BitVec bv1         = BitVecInit();

In BitVec.BitWise.c:823:

    // NEW: Large pattern testing
    bool test_bitvec_bitwise_large_patterns(void) {
    WriteFmtLn("Testing BitVec bitwise operations with large patterns");
    
    BitVec bv1         = BitVecInit();

In BitVec.BitWise.c:884:

    // Deadend tests
    bool test_bitvec_bitwise_null_failures(void) {
    WriteFmtLn("Testing BitVec bitwise NULL pointer handling");
    
    // Test NULL bitvec pointer - should abort

In BitVec.BitWise.c:893:

    
    bool test_bitvec_bitwise_ops_null_failures(void) {
    WriteFmtLn("Testing BitVec bitwise operations NULL handling");
    
    BitVec bv  = BitVecInit();

In BitVec.BitWise.c:907:

    
    bool test_bitvec_reverse_null_failures(void) {
    WriteFmtLn("Testing BitVec reverse NULL handling");
    
    // Test NULL pointer - should abort

In BitVec.BitWise.c:917:

    // NEW: Additional deadend tests
    bool test_bitvec_shift_ops_null_failures(void) {
    WriteFmtLn("Testing BitVec shift operations NULL handling");
    
    // Test NULL pointer for shift right - should abort

In BitVec.BitWise.c:926:

    
    bool test_bitvec_rotate_ops_null_failures(void) {
    WriteFmtLn("Testing BitVec rotate operations NULL handling");
    
    // Test NULL pointer for rotate - should abort

In BitVec.BitWise.c:935:

    
    bool test_bitvec_and_result_null_failures(void) {
    WriteFmtLn("Testing BitVec AND with NULL result handling");
    
    BitVec bv1 = BitVecInit();

In BitVec.BitWise.c:951:

    
    bool test_bitvec_or_operand_null_failures(void) {
    WriteFmtLn("Testing BitVec OR with NULL operand handling");
    
    BitVec result = BitVecInit();

In BitVec.BitWise.c:965:

    
    bool test_bitvec_xor_second_operand_null_failures(void) {
    WriteFmtLn("Testing BitVec XOR with NULL second operand handling");
    
    BitVec result = BitVecInit();

In BitVec.BitWise.c:979:

    
    bool test_bitvec_not_null_failures(void) {
    WriteFmtLn("Testing BitVec NOT with NULL handling");
    
    BitVec result = BitVecInit();

In BitVec.BitWise.c:992:

    // Main function that runs all tests
    int main(void) {
    WriteFmtLn("[INFO] Starting BitVec.BitWise tests");
    
    // Array of normal test functions

In RoundTrip.c:86:

    // Test 1: Simple value round-trip
    bool test_simple_roundtrip(void) {
    WriteFmtLn("Testing simple value round-trip");
    
    bool success = true;

In RoundTrip.c:107:

    });
    
    WriteFmtLn("[DEBUG] Generated JSON: {}", json);
    
    // Read back from JSON

In RoundTrip.c:128:

    if (original.count == parsed.count && original.temperature == parsed.temperature &&
    original.enabled == parsed.enabled && StrCmp(&original.message, &parsed.message) == 0) {
    WriteFmtLn("[DEBUG] Simple round-trip test passed");
    } else {
    WriteFmtLn("[DEBUG] Simple round-trip test FAILED");

In RoundTrip.c:130:

    WriteFmtLn("[DEBUG] Simple round-trip test passed");
    } else {
    WriteFmtLn("[DEBUG] Simple round-trip test FAILED");
    WriteFmtLn(
    "[DEBUG] Original: count={}, temp={}, enabled={}, msg='{}'",

In RoundTrip.c:131:

    } else {
    WriteFmtLn("[DEBUG] Simple round-trip test FAILED");
    WriteFmtLn(
    "[DEBUG] Original: count={}, temp={}, enabled={}, msg='{}'",
    original.count,

In RoundTrip.c:138:

    original.message.data
    );
    WriteFmtLn(
    "[DEBUG] Parsed: count={}, temp={}, enabled={}, msg='{}'",
    parsed.count,

In RoundTrip.c:156:

    // Test 2: Numeric precision round-trip
    bool test_numeric_roundtrip(void) {
    WriteFmtLn("Testing numeric precision round-trip");
    
    bool success = true;

In RoundTrip.c:181:

    });
    
    WriteFmtLn("[DEBUG] Numeric JSON: {}", json);
    
    // Read back from JSON

In RoundTrip.c:214:

    
    if (ints_match && floats_match) {
    WriteFmtLn("[DEBUG] Numeric round-trip test passed");
    } else {
    WriteFmtLn("[DEBUG] Numeric round-trip test FAILED");

In RoundTrip.c:216:

    WriteFmtLn("[DEBUG] Numeric round-trip test passed");
    } else {
    WriteFmtLn("[DEBUG] Numeric round-trip test FAILED");
    WriteFmtLn("[DEBUG] Integers match: {}", ints_match ? "true" : "false");
    WriteFmtLn("[DEBUG] Floats match: {}", floats_match ? "true" : "false");

In RoundTrip.c:217:

    } else {
    WriteFmtLn("[DEBUG] Numeric round-trip test FAILED");
    WriteFmtLn("[DEBUG] Integers match: {}", ints_match ? "true" : "false");
    WriteFmtLn("[DEBUG] Floats match: {}", floats_match ? "true" : "false");
    success = false;

In RoundTrip.c:218:

    WriteFmtLn("[DEBUG] Numeric round-trip test FAILED");
    WriteFmtLn("[DEBUG] Integers match: {}", ints_match ? "true" : "false");
    WriteFmtLn("[DEBUG] Floats match: {}", floats_match ? "true" : "false");
    success = false;
    }

In RoundTrip.c:228:

    // Test 3: Boolean round-trip
    bool test_boolean_roundtrip(void) {
    WriteFmtLn("Testing boolean round-trip");
    
    bool success = true;

In RoundTrip.c:268:

    if (original.flag1 == parsed.flag1 && original.flag2 == parsed.flag2 && original.flag3 == parsed.flag3 &&
    original.flag4 == parsed.flag4) {
    WriteFmtLn("[DEBUG] Boolean round-trip test passed");
    } else {
    WriteFmtLn("[DEBUG] Boolean round-trip test FAILED");

In RoundTrip.c:270:

    WriteFmtLn("[DEBUG] Boolean round-trip test passed");
    } else {
    WriteFmtLn("[DEBUG] Boolean round-trip test FAILED");
    success = false;
    }

In RoundTrip.c:280:

    // Test 4: String round-trip
    bool test_string_roundtrip(void) {
    WriteFmtLn("Testing string round-trip");
    
    bool success = true;

In RoundTrip.c:326:

    StrCmp(&original.with_spaces, &parsed.with_spaces) == 0 &&
    StrCmp(&original.with_special, &parsed.with_special) == 0) {
    WriteFmtLn("[DEBUG] String round-trip test passed");
    } else {
    WriteFmtLn("[DEBUG] String round-trip test FAILED");

In RoundTrip.c:328:

    WriteFmtLn("[DEBUG] String round-trip test passed");
    } else {
    WriteFmtLn("[DEBUG] String round-trip test FAILED");
    success = false;
    }

In RoundTrip.c:347:

    // Test 5: Array round-trip
    bool test_array_roundtrip(void) {
    WriteFmtLn("Testing array round-trip");
    
    bool success = true;

In RoundTrip.c:421:

    
    if (numbers_match && strings_match) {
    WriteFmtLn("[DEBUG] Array round-trip test passed");
    } else {
    WriteFmtLn("[DEBUG] Array round-trip test FAILED");

In RoundTrip.c:423:

    WriteFmtLn("[DEBUG] Array round-trip test passed");
    } else {
    WriteFmtLn("[DEBUG] Array round-trip test FAILED");
    WriteFmtLn(
    "[DEBUG] Numbers match: {} (orig {}, parsed {})\n",

In RoundTrip.c:424:

    } else {
    WriteFmtLn("[DEBUG] Array round-trip test FAILED");
    WriteFmtLn(
    "[DEBUG] Numbers match: {} (orig {}, parsed {})\n",
    numbers_match ? "true" : "false",

In RoundTrip.c:430:

    VecLen(&parsed_numbers)
    );
    WriteFmtLn(
    "[DEBUG] Strings match: {} (orig {}, parsed {})\n",
    strings_match ? "true" : "false",

In RoundTrip.c:450:

    // Test 6: Nested object round-trip
    bool test_nested_object_roundtrip(void) {
    WriteFmtLn("Testing nested object round-trip");
    
    bool success = true;

In RoundTrip.c:485:

    // Compare
    if (compare_persons(&original_person, &parsed_person)) {
    WriteFmtLn("[DEBUG] Nested object round-trip test passed");
    } else {
    WriteFmtLn("[DEBUG] Nested object round-trip test FAILED");

In RoundTrip.c:487:

    WriteFmtLn("[DEBUG] Nested object round-trip test passed");
    } else {
    WriteFmtLn("[DEBUG] Nested object round-trip test FAILED");
    success = false;
    }

In RoundTrip.c:500:

    // Test 7: Complex data round-trip
    bool test_complex_data_roundtrip(void) {
    WriteFmtLn("Testing complex data round-trip");
    
    bool success = true;

In RoundTrip.c:556:

    });
    
    WriteFmtLn("[DEBUG] Complex JSON length: {}", json);
    
    // Read back from JSON

In RoundTrip.c:624:

    
    if (user_match && config_match && numbers_match && flags_match) {
    WriteFmtLn("[DEBUG] Complex data round-trip test passed");
    } else {
    WriteFmtLn("[DEBUG] Complex data round-trip test FAILED");

In RoundTrip.c:626:

    WriteFmtLn("[DEBUG] Complex data round-trip test passed");
    } else {
    WriteFmtLn("[DEBUG] Complex data round-trip test FAILED");
    WriteFmtLn("[DEBUG] User match: {}", user_match ? "true" : "false");
    WriteFmtLn("[DEBUG] Config match: {}", config_match ? "true" : "false");

In RoundTrip.c:627:

    } else {
    WriteFmtLn("[DEBUG] Complex data round-trip test FAILED");
    WriteFmtLn("[DEBUG] User match: {}", user_match ? "true" : "false");
    WriteFmtLn("[DEBUG] Config match: {}", config_match ? "true" : "false");
    WriteFmtLn("[DEBUG] Numbers match: {}", numbers_match ? "true" : "false");

In RoundTrip.c:628:

    WriteFmtLn("[DEBUG] Complex data round-trip test FAILED");
    WriteFmtLn("[DEBUG] User match: {}", user_match ? "true" : "false");
    WriteFmtLn("[DEBUG] Config match: {}", config_match ? "true" : "false");
    WriteFmtLn("[DEBUG] Numbers match: {}", numbers_match ? "true" : "false");
    WriteFmtLn("[DEBUG] Flags match: {}", flags_match ? "true" : "false");

In RoundTrip.c:629:

    WriteFmtLn("[DEBUG] User match: {}", user_match ? "true" : "false");
    WriteFmtLn("[DEBUG] Config match: {}", config_match ? "true" : "false");
    WriteFmtLn("[DEBUG] Numbers match: {}", numbers_match ? "true" : "false");
    WriteFmtLn("[DEBUG] Flags match: {}", flags_match ? "true" : "false");
    success = false;

In RoundTrip.c:630:

    WriteFmtLn("[DEBUG] Config match: {}", config_match ? "true" : "false");
    WriteFmtLn("[DEBUG] Numbers match: {}", numbers_match ? "true" : "false");
    WriteFmtLn("[DEBUG] Flags match: {}", flags_match ? "true" : "false");
    success = false;
    }

In RoundTrip.c:643:

    // Test 8: Empty containers round-trip
    bool test_empty_containers_roundtrip(void) {
    WriteFmtLn("Testing empty containers round-trip");
    
    bool success = true;

In RoundTrip.c:692:

    if (parsed_str.length == 0 && VecLen(&parsed_numbers) == 0 && VecLen(&parsed_strings) == 0 &&
    !found_empty_object) { // Empty object should not execute the content
    WriteFmtLn("[DEBUG] Empty containers round-trip test passed");
    } else {
    WriteFmtLn("[DEBUG] Empty containers round-trip test FAILED");

In RoundTrip.c:694:

    WriteFmtLn("[DEBUG] Empty containers round-trip test passed");
    } else {
    WriteFmtLn("[DEBUG] Empty containers round-trip test FAILED");
    WriteFmtLn(
    "[DEBUG] String length: {}, numbers: {}, strings: {}, found_obj: {}\n",

In RoundTrip.c:695:

    } else {
    WriteFmtLn("[DEBUG] Empty containers round-trip test FAILED");
    WriteFmtLn(
    "[DEBUG] String length: {}, numbers: {}, strings: {}, found_obj: {}\n",
    parsed_str.length,

In RoundTrip.c:718:

    // Test 9: Edge cases round-trip
    bool test_edge_cases_roundtrip(void) {
    WriteFmtLn("Testing edge cases round-trip");
    
    bool success = true;

In RoundTrip.c:767:

    original.zero_float == parsed.zero_float && original.true_val == parsed.true_val &&
    original.false_val == parsed.false_val) {
    WriteFmtLn("[DEBUG] Edge cases round-trip test passed");
    } else {
    WriteFmtLn("[DEBUG] Edge cases round-trip test FAILED");

In RoundTrip.c:769:

    WriteFmtLn("[DEBUG] Edge cases round-trip test passed");
    } else {
    WriteFmtLn("[DEBUG] Edge cases round-trip test FAILED");
    success = false;
    }

In Read.EdgeCases.c:45:

    // Test 1: Empty object reading
    bool test_empty_object_reading(void) {
    WriteFmtLn("Testing empty object reading");
    
    bool success = true;

In Read.EdgeCases.c:63:

    
    if (!obj1.found_anything) {     // Should still be true for empty object (reader block didn't execute)
    WriteFmtLn("[DEBUG] Empty object test 1 passed - no fields processed");
    } else {
    WriteFmtLn("[DEBUG] Empty object test 1 FAILED - unexpected field processing");

In Read.EdgeCases.c:65:

    WriteFmtLn("[DEBUG] Empty object test 1 passed - no fields processed");
    } else {
    WriteFmtLn("[DEBUG] Empty object test 1 FAILED - unexpected field processing");
    success = false;
    }

In Read.EdgeCases.c:81:

    
    if (!obj2.found_anything) { // Should still be true for empty object
    WriteFmtLn("[DEBUG] Empty object with whitespace test passed");
    } else {
    WriteFmtLn("[DEBUG] Empty object with whitespace test FAILED");

In Read.EdgeCases.c:83:

    WriteFmtLn("[DEBUG] Empty object with whitespace test passed");
    } else {
    WriteFmtLn("[DEBUG] Empty object with whitespace test FAILED");
    success = false;
    }

In Read.EdgeCases.c:94:

    // Test 2: Empty array reading
    bool test_empty_array_reading(void) {
    WriteFmtLn("Testing empty array reading");
    
    bool success = true;

In Read.EdgeCases.c:113:

    
    if (VecLen(&items) == 0) {
    WriteFmtLn("[DEBUG] Empty array test passed - no items added");
    } else {
    WriteFmtLn("[DEBUG] Empty array test FAILED - {} items found", VecLen(&items));

In Read.EdgeCases.c:115:

    WriteFmtLn("[DEBUG] Empty array test passed - no items added");
    } else {
    WriteFmtLn("[DEBUG] Empty array test FAILED - {} items found", VecLen(&items));
    success = false;
    }

In Read.EdgeCases.c:134:

    
    if (VecLen(&data) == 0) {
    WriteFmtLn("[DEBUG] Empty array with whitespace test passed");
    } else {
    WriteFmtLn("[DEBUG] Empty array with whitespace test FAILED");

In Read.EdgeCases.c:136:

    WriteFmtLn("[DEBUG] Empty array with whitespace test passed");
    } else {
    WriteFmtLn("[DEBUG] Empty array with whitespace test FAILED");
    success = false;
    }

In Read.EdgeCases.c:378:

    });
    
    WriteFmtLn("[DEBUG] Escape sequences - escaped: '{}'\n", obj.escaped);
    WriteFmtLn("[DEBUG] Escape sequences - backslash: '{}'\n", obj.backslash);
    WriteFmtLn("[DEBUG] Escape sequences - newline length: {}\n", obj.newline.length);

In Read.EdgeCases.c:379:

    
    WriteFmtLn("[DEBUG] Escape sequences - escaped: '{}'\n", obj.escaped);
    WriteFmtLn("[DEBUG] Escape sequences - backslash: '{}'\n", obj.backslash);
    WriteFmtLn("[DEBUG] Escape sequences - newline length: {}\n", obj.newline.length);
    WriteFmtLn("[DEBUG] Escape sequences - tab length: {}\n", obj.tab.length);

In Read.EdgeCases.c:380:

    WriteFmtLn("[DEBUG] Escape sequences - escaped: '{}'\n", obj.escaped);
    WriteFmtLn("[DEBUG] Escape sequences - backslash: '{}'\n", obj.backslash);
    WriteFmtLn("[DEBUG] Escape sequences - newline length: {}\n", obj.newline.length);
    WriteFmtLn("[DEBUG] Escape sequences - tab length: {}\n", obj.tab.length);

In Read.EdgeCases.c:381:

    WriteFmtLn("[DEBUG] Escape sequences - backslash: '{}'\n", obj.backslash);
    WriteFmtLn("[DEBUG] Escape sequences - newline length: {}\n", obj.newline.length);
    WriteFmtLn("[DEBUG] Escape sequences - tab length: {}\n", obj.tab.length);
    
    // Basic validation that strings were parsed

In Read.EdgeCases.c:445:

    // Test 10: Nested empty containers
    bool test_nested_empty_containers(void) {
    WriteFmtLn("Testing nested empty containers\n");
    
    bool success = true;

In Write.EdgeCases.c:36:

    
    if (!result) {
    WriteFmtLn("[DEBUG] JSON comparison failed");
    WriteFmt("[DEBUG] Expected: '");
    for (u64 i = 0; i < expected_clean.length; i++) {

In Write.EdgeCases.c:41:

    WriteFmt("{c}", expected_clean.data[i]);
    }
    WriteFmtLn("'");
    
    WriteFmt("[DEBUG] Got: '");

In Write.EdgeCases.c:47:

    WriteFmt("{c}", output_clean.data[i]);
    }
    WriteFmtLn("'");
    }

In Write.EdgeCases.c:73:

    // Test 1: Empty object writing
    bool test_empty_object_writing(void) {
    WriteFmtLn("Testing empty object writing");
    
    bool success = true;

In Write.EdgeCases.c:97:

    // Test 2: Empty array writing
    bool test_empty_array_writing(void) {
    WriteFmtLn("Testing empty array writing");
    
    bool success = true;

In Write.EdgeCases.c:123:

    // Test 3: Empty string writing
    bool test_empty_string_writing(void) {
    WriteFmtLn("Testing empty string writing");
    
    bool success = true;

In Write.EdgeCases.c:149:

    // Test 4: Negative numbers writing
    bool test_negative_numbers_writing(void) {
    WriteFmtLn("Testing negative numbers writing");
    
    bool success = true;

In Write.EdgeCases.c:175:

    // Test 5: Large numbers writing
    bool test_large_numbers_writing(void) {
    WriteFmtLn("Testing large numbers writing");
    
    bool success = true;

In Write.EdgeCases.c:192:

    // For large numbers, just check that valid JSON was produced
    if (json.length > 0 && json.data[0] == '{' && json.data[json.length - 1] == '}') {
    WriteFmtLn("[DEBUG] Large numbers test passed - produced valid JSON structure");
    } else {
    WriteFmtLn("[DEBUG] Large numbers test FAILED - invalid JSON structure");

In Write.EdgeCases.c:194:

    WriteFmtLn("[DEBUG] Large numbers test passed - produced valid JSON structure");
    } else {
    WriteFmtLn("[DEBUG] Large numbers test FAILED - invalid JSON structure");
    success = false;
    }

In Write.EdgeCases.c:198:

    }
    
    WriteFmtLn("[DEBUG] Large numbers JSON: {}", json);
    
    StrDeinit(&json);

In Write.EdgeCases.c:206:

    // Test 6: Zero values writing
    bool test_zero_values_writing(void) {
    WriteFmtLn("Testing zero values writing\n");
    
    bool success = true;

In Write.EdgeCases.c:232:

    // Test 7: Special characters writing
    bool test_special_characters_writing(void) {
    WriteFmtLn("Testing special characters writing");
    
    bool success = true;

In Write.EdgeCases.c:248:

    });
    
    WriteFmtLn("[DEBUG] Special characters JSON: {}", json);
    
    // Just verify that valid JSON structure was produced

In Write.EdgeCases.c:252:

    // Just verify that valid JSON structure was produced
    if (json.length > 0 && json.data[0] == '{' && json.data[json.length - 1] == '}') {
    WriteFmtLn("[DEBUG] Special characters test passed - produced valid JSON");
    } else {
    WriteFmtLn("[DEBUG] Special characters test FAILED - invalid JSON structure");

In Write.EdgeCases.c:254:

    WriteFmtLn("[DEBUG] Special characters test passed - produced valid JSON");
    } else {
    WriteFmtLn("[DEBUG] Special characters test FAILED - invalid JSON structure");
    success = false;
    }

In Write.EdgeCases.c:267:

    // Test 8: Escape sequences writing
    bool test_escape_sequences_writing(void) {
    WriteFmtLn("Testing escape sequences writing");
    
    bool success = true;

In Write.EdgeCases.c:285:

    });
    
    WriteFmtLn("[DEBUG] Escape sequences JSON: {}", json);
    
    // Verify valid JSON structure was produced

In Write.EdgeCases.c:289:

    // Verify valid JSON structure was produced
    if (json.length > 0 && json.data[0] == '{' && json.data[json.length - 1] == '}') {
    WriteFmtLn("[DEBUG] Escape sequences test passed - produced valid JSON");
    } else {
    WriteFmtLn("[DEBUG] Escape sequences test FAILED - invalid JSON structure");

In Write.EdgeCases.c:291:

    WriteFmtLn("[DEBUG] Escape sequences test passed - produced valid JSON");
    } else {
    WriteFmtLn("[DEBUG] Escape sequences test FAILED - invalid JSON structure");
    success = false;
    }

In Write.EdgeCases.c:305:

    // Test 9: Nested empty containers writing
    bool test_nested_empty_containers_writing(void) {
    WriteFmtLn("Testing nested empty containers writing");
    
    bool success = true;

In Write.EdgeCases.c:344:

    // Test 10: Mixed empty and filled containers writing
    bool test_mixed_empty_and_filled_writing(void) {
    WriteFmtLn("Testing mixed empty and filled containers writing");
    
    bool success = true;

In Write.EdgeCases.c:383:

    // Test 11: Boundary integers writing
    bool test_boundary_integers_writing(void) {
    WriteFmtLn("Testing boundary integers writing");
    
    bool success = true;

In Write.EdgeCases.c:411:

    // Test 12: Boundary floats writing
    bool test_boundary_floats_writing(void) {
    WriteFmtLn("Testing boundary floats writing");
    
    bool success = true;

In Write.EdgeCases.c:430:

    // Check for reasonable float formatting (exact precision may vary)
    if (json.length > 0 && json.data[0] == '{' && json.data[json.length - 1] == '}') {
    WriteFmtLn("[DEBUG] Boundary floats test passed - JSON: {}", json);
    } else {
    WriteFmtLn("[DEBUG] Boundary floats test FAILED");

In Write.EdgeCases.c:432:

    WriteFmtLn("[DEBUG] Boundary floats test passed - JSON: {}", json);
    } else {
    WriteFmtLn("[DEBUG] Boundary floats test FAILED");
    success = false;
    }

In Write.EdgeCases.c:442:

    // Test 13: Single values writing (minimal valid JSON objects)
    bool test_single_values_writing(void) {
    WriteFmtLn("Testing single values writing");
    
    bool success = true;

In ElfInfo.c:376:

    );
    
    WriteFmtLn(
    "ElfHeader64 {{\n"
    "  meta: {{class: {}, encoding: {}, version: {}, os_abi: {}}}\n"

In ElfInfo.c:416:

    Vec(int) vi = VecInit();
    VecForeachIdx(&vi, val, i) {
    WriteFmtLn("{}", val);
    }

In SubProcComm.c:19:

    
    // write the retrieved value to stdout (parent, not child)
    WriteFmtLn("got value = {}", val);
    
    // wait for program to exit for 1 second

In Main.c:15:

    
    if (rule_name.length) {
    WriteFmtLn("Got Rule : {}", rule_name);
    StrDeinit(&rule_name);
    }

WriteFmtLn

`WriteFmtLn`

Description

Parameters

Success

Failure

Usage example (Cross-references)

Tags :

Share :

Related Posts

WriteFmt

FReadFmt

StrWriteFmtInternal