std/src/encoding/base64/core_test.nv - main - nv-lang/nova

std/src/encoding/base64/core_test.nv
108 строк4 KB
Evgeniy Golovin
canon(bytes/const): свип std+examples — редундантные .bytes() call-arg и const-аннотации сняты
21 июл 2026, 20:38
21 июл 2026, 20:38e2d2062
// stdlib/base64/core_test.nv — tests for Base64 encoding/decoding по RFC 4648
// (`core.nv`, same folder-module `encoding.base64`, Plan 200 П17 split).
//
// Спецификация: https://www.rfc-editor.org/rfc/rfc4648
//
// Поддержка:
//   - Standard Base64 (RFC 4648 § 4): A-Z, a-z, 0-9, +, /
//   - URL-safe Base64 (RFC 4648 § 5): A-Z, a-z, 0-9, -, _
//   - Padding с `=` (опционально для URL-safe)

module encoding.base64

// ──────────────────────────────────────────────────────────────────────────
// Тесты — RFC 4648 § 10 test vectors
// ──────────────────────────────────────────────────────────────────────────

test "encode: пустой массив" {
    ro empty []u8 = []
    assert(Base64.encode(empty) == "")
}

test "encode: RFC 4648 test vectors" {
    // § 10 test vectors:
    //   ""      → ""
    //   "f"     → "Zg=="
    //   "fo"    → "Zm8="
    //   "foo"   → "Zm9v"
    //   "foob"  => "Zm9vYg=="
    //   "fooba" => "Zm9vYmE="
    //   "foobar"=> "Zm9vYmFy"
    assert(Base64.encode("f") == "Zg==")
    assert(Base64.encode("fo") == "Zm8=")
    assert(Base64.encode("foo") == "Zm9v")
    assert(Base64.encode("foob") == "Zm9vYg==")
    assert(Base64.encode("fooba") == "Zm9vYmE=")
    assert(Base64.encode("foobar") == "Zm9vYmFy")
}

test "decode: RFC 4648 test vectors" {
    assert(Base64.decode("")!! == [])
    assert(Base64.decode("Zg==")!! == "f".bytes())
    assert(Base64.decode("Zm8=")!! == "fo".bytes())
    assert(Base64.decode("Zm9v")!! == "foo".bytes())
    assert(Base64.decode("Zm9vYg==")!! == "foob".bytes())
    assert(Base64.decode("Zm9vYmE=")!! == "fooba".bytes())
    assert(Base64.decode("Zm9vYmFy")!! == "foobar".bytes())
}

test "round-trip: encode + decode == original" {
    ro cases = ["", "Hello", "The quick brown fox", "binary\x00data"]
    for s in cases {
        ro bytes = s.bytes()
        ro encoded = Base64.encode(bytes)
        ro decoded = Base64.decode(encoded)!!
        assert(decoded == bytes)
    }
}

test "URL-safe: + и / заменяются на - и _" {
    // Байты со значениями которые дают `+` или `/` в обычном:
    // value 62 (`+`) и 63 (`/`).
    // Один способ — закодировать [0xFB, 0xFF, 0xFF] которые дадут "+/":
    //   0xFB FF FF = 1111 1011 1111 1111 1111 1111
    //   6-bit groups: 111110 111111 111111 111111 = 62 63 63 63 = +///
    ro data []u8 = [0xFB, 0xFF, 0xFF]
    ro std_encoded = Base64.encode(data)
    ro url_encoded = Base64.encode_url(data)
    assert(std_encoded.contains("+") || std_encoded.contains("/"))
    assert(!url_encoded.contains("+"))
    assert(!url_encoded.contains("/"))
    assert(url_encoded.contains("-") || url_encoded.contains("_"))
}

test "URL-safe round-trip" {
    ro data []u8 = [0xFB, 0xFF, 0xFF, 0x00, 0x42]
    ro encoded = Base64.encode_url(data)
    ro decoded = Base64.decode_url(encoded)!!
    assert(decoded == data)
}

test "decode: ошибка — нечётная длина без padding в strict mode" {
    ro r = Base64.decode("abc")                // 3 символа — не кратно 4
    assert(match r {
        Err(InvalidLength { .. }) => true
        _                         => false
    })
}

test "decode: ошибка — невалидный символ" {
    ro r = Base64.decode("Zm$=")               // $ не в alphabet
    assert(match r {
        Err(InvalidChar { .. }) => true
        _                       => false
    })
}

test "Base64 → JWT-like usage" {
    // Симулируем JWT header'а: `{"alg":"HS256","typ":"JWT"}` в URL-safe.
    ro header = "{\"alg\":\"HS256\",\"typ\":\"JWT\"}"
    ro encoded = Base64.encode_url(header.bytes())
    // Не содержит padding и URL-safe alphabet
    assert(!encoded.contains("="))
    assert(!encoded.contains("+"))
    assert(!encoded.contains("/"))
    // Round-trip
    ro decoded = Base64.decode_url(encoded)!!
    assert(decoded == header.bytes())
}