Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-usd

Source of release 0.9.2

0.9.2 / tests / checks / expression_checks.lucb

## Variable expressions (sdf/expressions.lucb) against the behaviour of
## OpenUSD's SdfVariableExpression: substitution, functions, lists, typed
## results, nested and circular variables, and syntax errors.
from luce_usd.kernel import Names, Value, ValueKind, Dictionary, Evaluated, ExpressionKind, evaluate_expression, expression_string

## A dictionary value of expression variables.
func variables(names: Names*) -> Value!:
    let made = try Dictionary.create()
    var owner = Value.of_object(ValueKind.dictionary, (void*)made)
    errdefer owner.release()
    try made.put(try names.token("A"), Value.scalar(ValueKind.string, (u64)(try names.token("left"))))
    try made.put(try names.token("N"), Value.scalar(ValueKind.int, 3))
    try made.put(try names.token("ON"), Value.scalar(ValueKind.boolean, 1))
    try made.put(try names.token("NESTED"), Value.scalar(ValueKind.string, (u64)(try names.token("`\"${A}_nested\"`"))))
    try made.put(try names.token("LOOP"), Value.scalar(ValueKind.string, (u64)(try names.token("`${LOOP2}`"))))
    try made.put(try names.token("LOOP2"), Value.scalar(ValueKind.string, (u64)(try names.token("`${LOOP}`"))))
    return owner

## The string an expression gives ("" when it fails or is not a string).
func text_of(names: Names*, vars: const Value*, expression: str) -> str!:
    return names.text_of(try expression_string(names, expression, vars))

## The kind and number an expression gives.
func value_of(names: Names*, vars: const Value*, expression: str) -> Evaluated!:
    return try evaluate_expression(names, expression, vars)

func is_true(names: Names*, vars: const Value*, expression: str) -> bool!:
    var result = try value_of(names, vars, expression)
    defer result.close()
    return not result.failed and result.kind == ExpressionKind.boolean and result.number == 1

func fails(names: Names*, vars: const Value*, expression: str) -> bool!:
    var result = try value_of(names, vars, expression)
    defer result.close()
    return result.failed

pub func expressions() -> !:
    var names = try Names()
    defer names.close()
    var vars = try variables(&names)
    defer vars.release()
    # Substitution; an unset variable leaves its name; escapes.
    assert((try text_of(&names, &vars, "`\"${A}.usda\"`")) == "left.usda")
    assert((try text_of(&names, &vars, "`'${MISSING}_x'`")) == "MISSING_x")
    assert((try text_of(&names, &vars, "`\"a\\tb\\\\c\\$\"`")) == "a\tb\\c$")
    assert((try text_of(&names, &vars, "`${NESTED}`")) == "left_nested")
    assert(try fails(&names, &vars, "`${LOOP}`"))
    assert(try fails(&names, &vars, "`${MISSING}`"))
    # Typed results: an integer is no string.
    assert((try text_of(&names, &vars, "`${N}`")) == "")
    # Functions.
    assert((try text_of(&names, &vars, "`if(${ON}, \"yes\", \"no\")`")) == "yes")
    assert((try text_of(&names, &vars, "`if(not(${ON}), \"yes\")`")) == "")
    assert(try is_true(&names, &vars, "`and(${ON}, eq(${N}, 3), lt(\"a\", \"b\"))`"))
    assert(try is_true(&names, &vars, "`or(${ON}, ${MISSING})`"))
    assert(try fails(&names, &vars, "`and(${ON}, ${MISSING})`"))
    assert(try is_true(&names, &vars, "`contains([1, 2, 3], ${N})`"))
    assert(try is_true(&names, &vars, "`contains(${A}, \"ef\")`"))
    assert((try text_of(&names, &vars, "`at(['x', 'y', 'z'], -1)`")) == "z")
    assert(try is_true(&names, &vars, "`eq(len(${A}), 4)`"))
    assert(try is_true(&names, &vars, "`defined(\"A\", \"N\")`"))
    assert(not try is_true(&names, &vars, "`defined(\"A\", \"MISSING\")`"))
    assert(try is_true(&names, &vars, "`eq(None, None)`"))
    # Type errors, mixed lists, syntax errors and unknown functions fail.
    assert(try fails(&names, &vars, "`eq(1, \"1\")`"))
    assert(try fails(&names, &vars, "`[1, 'a']`"))
    assert(try fails(&names, &vars, "`\"${BAD\"`"))
    assert(try fails(&names, &vars, "`nope(1)`"))
    assert(try fails(&names, &vars, "`or(${ON}, nope(1))`"))
    var list = try value_of(&names, &vars, "`['a', 'b']`")
    defer list.close()
    assert(list.kind == ExpressionKind.strings and list.items.count == 2)