vyre-conform 0.1.0

// primitive.math.add — binary u32 operation.
// Expected values are hand-computed from the operation definition.
test_binary_op!(
    test_add,
    "primitive.math.add",
    [
        (0x00000000, 0x00000000, 0x00000000, "zero vs zero"),
        (
            0x00000001,
            0x00000000,
            0x00000001,
            "one vs zero (also tests div-by-zero)"
        ),
        (
            0xFFFFFFFF,
            0x00000001,
            0x00000000,
            "max / all-bits-set vs one"
        ),
        (0xAAAAAAAA, 0x55555555, 0xFFFFFFFF, "alternating patterns"),
        (
            0x55555555,
            0xAAAAAAAA,
            0xFFFFFFFF,
            "inverse alternating patterns"
        ),
        (0x80000000, 0x80000000, 0x00000000, "sign-bit vs sign-bit"),
        (0x00000007, 0x00000003, 0x0000000A, "prime (7) vs prime (3)"),
        (
            0x0000000C,
            0x00000005,
            0x00000011,
            "composite (12) vs prime (5)"
        ),
    ]
);

// primitive.math.sub — binary u32 operation.
// Expected values are hand-computed from the operation definition.
test_binary_op!(
    test_sub,
    "primitive.math.sub",
    [
        (0x00000000, 0x00000000, 0x00000000, "zero vs zero"),
        (
            0x00000001,
            0x00000000,
            0x00000001,
            "one vs zero (also tests div-by-zero)"
        ),
        (
            0xFFFFFFFF,
            0x00000001,
            0xFFFFFFFE,
            "max / all-bits-set vs one"
        ),
        (0xAAAAAAAA, 0x55555555, 0x55555555, "alternating patterns"),
        (
            0x55555555,
            0xAAAAAAAA,
            0xAAAAAAAB,
            "inverse alternating patterns"
        ),
        (0x80000000, 0x80000000, 0x00000000, "sign-bit vs sign-bit"),
        (0x00000007, 0x00000003, 0x00000004, "prime (7) vs prime (3)"),
        (
            0x0000000C,
            0x00000005,
            0x00000007,
            "composite (12) vs prime (5)"
        ),
    ]
);

// primitive.math.mul — binary u32 operation.
// Expected values are hand-computed from the operation definition.
test_binary_op!(
    test_mul,
    "primitive.math.mul",
    [
        (0x00000000, 0x00000000, 0x00000000, "zero vs zero"),
        (
            0x00000001,
            0x00000000,
            0x00000000,
            "one vs zero (also tests div-by-zero)"
        ),
        (
            0xFFFFFFFF,
            0x00000001,
            0xFFFFFFFF,
            "max / all-bits-set vs one"
        ),
        (0xAAAAAAAA, 0x55555555, 0x71C71C72, "alternating patterns"),
        (
            0x55555555,
            0xAAAAAAAA,
            0x71C71C72,
            "inverse alternating patterns"
        ),
        (0x80000000, 0x80000000, 0x00000000, "sign-bit vs sign-bit"),
        (0x00000007, 0x00000003, 0x00000015, "prime (7) vs prime (3)"),
        (
            0x0000000C,
            0x00000005,
            0x0000003C,
            "composite (12) vs prime (5)"
        ),
    ]
);

// primitive.math.div — binary u32 operation.
// Expected values are hand-computed from the operation definition.
test_binary_op!(
    test_div,
    "primitive.math.div",
    [
        (0x00000000, 0x00000000, 0x00000000, "zero vs zero"),
        (
            0x00000001,
            0x00000000,
            0x00000000,
            "one vs zero (also tests div-by-zero)"
        ),
        (
            0xFFFFFFFF,
            0x00000001,
            0xFFFFFFFF,
            "max / all-bits-set vs one"
        ),
        (0xAAAAAAAA, 0x55555555, 0x00000002, "alternating patterns"),
        (
            0x55555555,
            0xAAAAAAAA,
            0x00000000,
            "inverse alternating patterns"
        ),
        (0x80000000, 0x80000000, 0x00000001, "sign-bit vs sign-bit"),
        (0x00000007, 0x00000003, 0x00000002, "prime (7) vs prime (3)"),
        (
            0x0000000C,
            0x00000005,
            0x00000002,
            "composite (12) vs prime (5)"
        ),
    ]
);

// primitive.math.mod — binary u32 operation.
// Expected values are hand-computed from the operation definition.
test_binary_op!(
    test_mod,
    "primitive.math.mod",
    [
        (0x00000000, 0x00000000, 0x00000000, "zero vs zero"),
        (
            0x00000001,
            0x00000000,
            0x00000000,
            "one vs zero (also tests div-by-zero)"
        ),
        (
            0xFFFFFFFF,
            0x00000001,
            0x00000000,
            "max / all-bits-set vs one"
        ),
        (0xAAAAAAAA, 0x55555555, 0x00000000, "alternating patterns"),
        (
            0x55555555,
            0xAAAAAAAA,
            0x55555555,
            "inverse alternating patterns"
        ),
        (0x80000000, 0x80000000, 0x00000000, "sign-bit vs sign-bit"),
        (0x00000007, 0x00000003, 0x00000001, "prime (7) vs prime (3)"),
        (
            0x0000000C,
            0x00000005,
            0x00000002,
            "composite (12) vs prime (5)"
        ),
    ]
);

// primitive.math.min — binary u32 operation.
// Expected values are hand-computed from the operation definition.
test_binary_op!(
    test_min,
    "primitive.math.min",
    [
        (0x00000000, 0x00000000, 0x00000000, "zero vs zero"),
        (
            0x00000001,
            0x00000000,
            0x00000000,
            "one vs zero (also tests div-by-zero)"
        ),
        (
            0xFFFFFFFF,
            0x00000001,
            0x00000001,
            "max / all-bits-set vs one"
        ),
        (0xAAAAAAAA, 0x55555555, 0x55555555, "alternating patterns"),
        (
            0x55555555,
            0xAAAAAAAA,
            0x55555555,
            "inverse alternating patterns"
        ),
        (0x80000000, 0x80000000, 0x80000000, "sign-bit vs sign-bit"),
        (0x00000007, 0x00000003, 0x00000003, "prime (7) vs prime (3)"),
        (
            0x0000000C,
            0x00000005,
            0x00000005,
            "composite (12) vs prime (5)"
        ),
    ]
);

// primitive.math.max — binary u32 operation.
// Expected values are hand-computed from the operation definition.
test_binary_op!(
    test_max,
    "primitive.math.max",
    [
        (0x00000000, 0x00000000, 0x00000000, "zero vs zero"),
        (
            0x00000001,
            0x00000000,
            0x00000001,
            "one vs zero (also tests div-by-zero)"
        ),
        (
            0xFFFFFFFF,
            0x00000001,
            0xFFFFFFFF,
            "max / all-bits-set vs one"
        ),
        (0xAAAAAAAA, 0x55555555, 0xAAAAAAAA, "alternating patterns"),
        (
            0x55555555,
            0xAAAAAAAA,
            0xAAAAAAAA,
            "inverse alternating patterns"
        ),
        (0x80000000, 0x80000000, 0x80000000, "sign-bit vs sign-bit"),
        (0x00000007, 0x00000003, 0x00000007, "prime (7) vs prime (3)"),
        (
            0x0000000C,
            0x00000005,
            0x0000000C,
            "composite (12) vs prime (5)"
        ),
    ]
);
// primitive.compare.select — binary u32 operation.
// Expected values are hand-computed from the operation definition.
test_binary_op!(
    test_select,
    "primitive.compare.select",
    [
        (0x00000000, 0x00000000, 0x00000000, "zero vs zero"),
        (
            0x00000001,
            0x00000000,
            0x00000000,
            "one vs zero (also tests div-by-zero)"
        ),
        (
            0xFFFFFFFF,
            0x00000001,
            0xFFFFFFFF,
            "max / all-bits-set vs one"
        ),
        (0xAAAAAAAA, 0x55555555, 0xAAAAAAAA, "alternating patterns"),
        (
            0x55555555,
            0xAAAAAAAA,
            0x55555555,
            "inverse alternating patterns"
        ),
        (0x80000000, 0x80000000, 0x80000000, "sign-bit vs sign-bit"),
        (0x00000007, 0x00000003, 0x00000007, "prime (7) vs prime (3)"),
        (
            0x0000000C,
            0x00000005,
            0x0000000C,
            "composite (12) vs prime (5)"
        ),
    ]
);

// primitive.math.clamp — binary u32 operation.
// Expected values are hand-computed from the operation definition.
test_binary_op!(
    test_clamp,
    "primitive.math.clamp",
    [
        (0x00000000, 0x00000000, 0x00000000, "zero vs zero"),
        (
            0x00000001,
            0x00000000,
            0x00000000,
            "one vs zero (also tests div-by-zero)"
        ),
        (
            0xFFFFFFFF,
            0x00000001,
            0x00000001,
            "max / all-bits-set vs one"
        ),
        (0xAAAAAAAA, 0x55555555, 0x00005555, "alternating patterns"),
        (
            0x55555555,
            0xAAAAAAAA,
            0x0000AAAA,
            "inverse alternating patterns"
        ),
        (0x80000000, 0x80000000, 0x00008000, "sign-bit vs sign-bit"),
        (0x00000007, 0x00000003, 0x00000003, "prime (7) vs prime (3)"),
        (
            0x0000000C,
            0x00000005,
            0x00000005,
            "composite (12) vs prime (5)"
        ),
    ]
);