Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-std

Source of release 0.7.3

0.7.3 / tests / unicode_casing / check.lucb

import c
import files
import interop
import memory
import strings
import unicode
import utf8

func convert(text: str, kind: u32, limit: usize? = none) -> interop.Owned[str]!:
    match kind:
        0: return try unicode.to_upper(text, limit)
        1: return try unicode.to_lower(text, limit)
        2: return try unicode.case_fold(text, false, limit)
        3: return try unicode.case_fold(text, true, limit)
        _: trap("invalid casing test operation")

pub func main(arguments: c.str[]) -> i32!:
    assert(unicode.version == "17.0.0")
    let corpus_file = try files.read(arguments[1])
    defer corpus_file.release()
    let corpus = corpus_file.value
    let properties_file = try files.read(arguments[2])
    defer properties_file.release()
    let properties = properties_file.value
    var position: usize = 0
    var count: usize = 0
    while position < corpus.length:
        let kind = memory.read[u32](corpus.data + position)
        let input_length = (usize)memory.read[u32](corpus.data + position + 4)
        let output_length = (usize)memory.read[u32](corpus.data + position + 8)
        position += 12
        let input = (str)corpus[position..<position + input_length]
        position += input_length
        let expected = (str)corpus[position..<position + output_length]
        position += output_length
        let converted = try convert(input, kind, expected.length)
        defer converted.release()
        let actual = converted.value
        if actual != expected:
            print(f"casing record {count}, operation {kind}")
            trap("Unicode casing differs from the reference")
        assert(actual.bytes.data[actual.length] == 0)
        if output_length > 0:
            var rejected = false
            let refused = convert(input, kind, output_length - 1) catch failure:
                assert(failure.code == strings.output_too_large)
                rejected = true
                recover interop.Owned[str]("")
            refused.release()
            assert(rejected)
        count += 1
    assert(count > 20000)
    position = 0
    while position < properties.length:
        let scalar = memory.read[u32](properties.data + position)
        let whitespace = memory.read[u32](properties.data + position + 4)
        let combining = memory.read[u32](properties.data + position + 8)
        assert(unicode.is_whitespace(scalar) == (whitespace != 0))
        assert((u32)unicode.combining_class(scalar) == combining)
        position += 12
    var malformed: u8[4] = [65, 237, 160, 128]
    var empty: u8[]
    var refusing = memory.FixedBuffer.over(empty)
    for kind in 0..<4:
        var rejected = false
        let refused = convert((str)malformed, (u32)kind) catch failure:
            assert(failure.code == utf8.invalid_sequence)
            rejected = true
            recover interop.Owned[str]("")
        refused.release()
        assert(rejected)
        rejected = false
        with refusing:
            let exhausted = convert("abc", (u32)kind) catch failure:
                assert(failure.code == memory.exhausted)
                rejected = true
                recover interop.Owned[str]("")
            exhausted.release()
        assert(rejected)
    print("ok Unicode casing and scalar properties")
    return 0