std/src/runtime/string_builder_test.nv - main - nv-lang/nova

std/src/runtime/string_builder_test.nv
198 строк8 KB
Evgeniy Golovin
style(std): D452 — migrate to canonical match-arm/statement separators
10 авг 2026, 03:57
10 авг 2026, 03:57685589a
// SPDX-License-Identifier: MIT OR Apache-2.0
// Plan 208 Ф.1 (D422/D179 amend) — peer test for the new StringBuilder
// methods (`@reserve`/`@advance`/`@write_padded`/`@pad_in_place`/
// `@into_str_checked`). A genuinely separate module from `runtime.string_builder`
// (this folder holds one module per file, [M-fmt-buf-module-path] confirmed by
// E_D78_MODULE_PATH_MISMATCH — mirrors `sync.nv`/`sync_test.nv`), so it imports
// what it needs rather than sharing module-private state; every method under
// test here is `export`ed (public D179-amend API), so this is unproblematic.
module runtime.string_builder_test

import std.runtime.string_builder.{StringBuilder, int_display_spec, f64_display_spec, f32_display_spec, bool_display_spec, char_display_spec, char_debug_display_spec, str_display_spec, str_debug_display_spec}
import std.runtime.fmt_buf.{Align}

test "StringBuilder: @reserve/@advance zero-copy digit-loop protocol" {
    consume sb = StringBuilder.new()
    sb.append("abc")
    sb.reserve(4)
    ro p = sb.spare()
    unsafe {
        p.write_at(0, '1' as u8)
        p.write_at(1, '2' as u8)
        p.write_at(2, '3' as u8)
        p.write_at(3, '4' as u8)
    }
    sb.advance(4)
    assert(sb.byte_len() == 7)
    ro s = sb.into_str()
    assert(s == "abc1234")
}

test "StringBuilder: @write_padded left/right/center" {
    consume sb1 = StringBuilder.new()
    sb1.write_padded("hi", 8, ' ', Align.Right)
    assert(sb1.into_str() == "      hi")

    consume sb2 = StringBuilder.new()
    sb2.write_padded("hi", 8, ' ', Align.Left)
    assert(sb2.into_str() == "hi      ")

    consume sb3 = StringBuilder.new()
    sb3.write_padded("hi", 8, '*', Align.Center)
    assert(sb3.into_str() == "***hi***")

    // width already satisfied — no padding inserted.
    consume sb4 = StringBuilder.new()
    sb4.write_padded("hello", 3, ' ', Align.Right)
    assert(sb4.into_str() == "hello")
}

test "StringBuilder: @pad_in_place right-aligns a streamed composite" {
    consume sb = StringBuilder.new()
    sb.append("| ")
    ro mark = sb.byte_len()
    sb.append("Point(1, 2)")   // simulates a streamed record @display body
    sb.pad_in_place(mark, 20, ' ', Align.Right)
    sb.append(" |")
    ro s = sb.into_str()
    assert(s.byte_len() == 2 + 20 + 2)
    assert(s.ends_with("Point(1, 2) |"))
    assert(s.starts_with("|          "))
}

test "StringBuilder: @pad_in_place left/center variants" {
    consume sbl = StringBuilder.new()
    ro markl = sbl.byte_len()
    sbl.append("ab")
    sbl.pad_in_place(markl, 5, '-', Align.Left)
    assert(sbl.into_str() == "ab---")

    consume sbc = StringBuilder.new()
    ro markc = sbc.byte_len()
    sbc.append("ab")
    sbc.pad_in_place(markc, 6, '-', Align.Center)
    assert(sbc.into_str() == "--ab--")

    // content already >= width — no-op.
    consume sbn = StringBuilder.new()
    ro markn = sbn.byte_len()
    sbn.append("hello")
    sbn.pad_in_place(markn, 3, ' ', Align.Right)
    assert(sbn.into_str() == "hello")
}

test "StringBuilder: @into_str_checked Ok/Err" {
    consume sb_ok = StringBuilder.new()
    sb_ok.append("héllo")
    match sb_ok.into_str_checked() {
        Ok(s) => assert(s == "héllo")
        Err(_) => assert(false)
    }

    consume sb_bad = StringBuilder.new()
    sb_bad.append([0xFF as u8])
    match sb_bad.into_str_checked() {
        Ok(_) => assert(false)
        Err(_) => assert(true)
    }
}

// Zero-alloc appendы (2026-07-20): байт-паритет с прежним to_str-путём,
// включая f32-канон (НЕ f64-расширение: 0.1 БЕЗ double-хвоста) и крайние капы.

test "SB append int/f64/f32 zero-alloc byte-parity" {
    consume sb = StringBuilder.new()
    sb.append(0).append(" ").append(-9223372036854775807 - 1).append(" ").append(1.5)
    assert(sb.into_str() == "0 -9223372036854775808 1.5")
    consume sb2 = StringBuilder.new()
    sb2.append(0.1 as f32).append(" ").append(-2.25 as f32)
    assert(sb2.into_str() == "0.1 -2.25")
}

// Plan 208 Ф.4R Ш1 (owner 2026-07-20): `*_display_spec` family gate —
// cross-checked directly against `spec_tests/conformance/d422_f4r_baseline_
// *.nv` (Ш0 byte-parity contract), same expected literals.

test "int_display_spec: decimal + radix, zero_pad, width/align/fill" {
    consume sb1 = StringBuilder.new()
    int_display_spec(sb1, -1, 0, 16, false, false, false, false, Align.Right, ' ')
    assert(sb1.into_str() == "ffffffffffffffff")

    consume sb2 = StringBuilder.new()
    int_display_spec(sb2, 255, 8, 16, false, true, false, false, Align.Right, ' ')
    assert(sb2.into_str() == "000000ff")

    consume sb3 = StringBuilder.new()
    int_display_spec(sb3, 42, 6, 10, false, false, false, false, Align.Center, '*')
    assert(sb3.into_str() == "**42**")

    consume sb4 = StringBuilder.new()
    int_display_spec(sb4, 255, 10, 16, false, true, false, true, Align.Right, ' ')
    assert(sb4.into_str() == "0x000000ff")
}

test "f64_display_spec: precision+width, -0.0 double-sign quirk, no-precision shortest" {
    consume sb1 = StringBuilder.new()
    f64_display_spec(sb1, -12.345, 10, true, 2, true, false, Align.Right, ' ')
    assert(sb1.into_str() == "-000012.35")

    consume sb2 = StringBuilder.new()
    f64_display_spec(sb2, -0.0, 0, true, 2, false, false, Align.Right, ' ')
    assert(sb2.into_str() == "--0.00")   // pinned quirk — see Ш0 baseline

    consume sb3 = StringBuilder.new()
    f64_display_spec(sb3, 1.0e20, 0, false, 0, false, false, Align.Right, ' ')
    assert(sb3.into_str() == "1e+20")

    consume sb4 = StringBuilder.new()
    f64_display_spec(sb4, -0.0, 0, false, 0, false, false, Align.Right, ' ')
    assert(sb4.into_str() == "-0")   // no double-sign in the no-precision branch

    consume sb5 = StringBuilder.new()
    f64_display_spec(sb5, 1.5, 0, true, 65, false, false, Align.Right, ' ')
    assert(sb5.into_str() == "1.5000000000000000000000000000000000000000000000000000000000000000")

    // zero_pad, NO precision — body carries its own embedded sign (shortest
    // engine), prefix is empty (sign_plus false) — zeros insert BEFORE the
    // embedded sign (matches pre-Ф.4R binary ground truth exactly, NOT the
    // "nicer-looking" `-00000100000`).
    consume sb6 = StringBuilder.new()
    f64_display_spec(sb6, -1.0e5, 12, false, 0, true, false, Align.Right, ' ')
    assert(sb6.into_str() == "00000-100000")

    consume sb7 = StringBuilder.new()
    f64_display_spec(sb7, 1.0e5, 12, false, 0, true, false, Align.Right, ' ')
    assert(sb7.into_str() == "000000100000")
}

test "str/char/bool display_spec: identity, Debug-escape, precision truncation" {
    consume sb1 = StringBuilder.new()
    str_display_spec(sb1, "hello world", 0, true, 5, Align.Left, ' ')
    assert(sb1.into_str() == "hello")

    consume sb2 = StringBuilder.new()
    str_debug_display_spec(sb2, "hello", 0, false, 0, Align.Left, ' ')
    assert(sb2.into_str() == "\"hello\"")

    consume sb3 = StringBuilder.new()
    char_display_spec(sb3, 'x', 0, Align.Left, ' ')
    assert(sb3.into_str() == "x")

    consume sb4 = StringBuilder.new()
    char_debug_display_spec(sb4, '\n', 0, Align.Left, ' ')
    assert(sb4.into_str() == "'\\n'")

    consume sb5 = StringBuilder.new()
    bool_display_spec(sb5, true, 0, Align.Left, ' ')
    assert(sb5.into_str() == "true")
}

test "f32_display_spec: f32-precise shortest engine" {
    consume sb1 = StringBuilder.new()
    f32_display_spec(sb1, 0.1 as f32, 0, Align.Left, ' ')
    assert(sb1.into_str() == "0.1")

    consume sb2 = StringBuilder.new()
    f32_display_spec(sb2, -2.25 as f32, 8, Align.Right, ' ')
    assert(sb2.into_str() == "   -2.25")
}