#!/usr/bin/ruby

# Tests for the ternary operator

var (a,b) = (true ? (1, 2) : (42, 43))

assert_eq(a, 1)
assert_eq(b, 2)

(a,b) = (false ? (1, 2) : (42, 43))

assert_eq(a, 42)
assert_eq(b, 43)

var (c, d, e) = (false ? (3, 4, 5) : (9, 10, 11))

assert_eq(c, 9)
assert_eq(d, 10)
assert_eq(e, 11)

(c, d, e) = (true ? (13, 14, 15) : (101, 102, 103))

assert_eq(c, 13)
assert_eq(d, 14)
assert_eq(e, 15)

# Extra tests

(a, b) = (false || (3, 4))

assert_eq(a, 3)
assert_eq(b, 4)

(a, b) = (true && (12, 13))

assert_eq(a, 12)
assert_eq(b, 13)

var t = true
var f = false

assert_eq(t ? 4 : 9 -> isqrt, 2)
assert_eq(f ? 4 : 9 -> isqrt, 3)

assert_eq(t?(3):(4), 3)
assert_eq(f?(3):(4), 4)

assert_eq(t?(3):(4) + 9, 12)
assert_eq(f?(3):(4) + 9, 13)

assert_eq(
    t
        ? 4
        : 9 -> isqrt, 2)

assert_eq(
    f
        ? 4
        : 9 -> isqrt, 3)

assert_eq(
    t
        ? 4
        : 9 + 7, 11)

assert_eq(
    f
        ? 4
        : 9 + 7, 16)

assert_eq(t ? 2
            : 5, 2)

assert_eq(f ? 2
            : 5, 5)

assert_eq(f || t ? 2 : 5, 2)
assert_eq(t || f ? 2 : 5, 2)

assert_eq(t && f ? 2 : 5, 5)
assert_eq(f && t ? 2 : 5, 5)

assert_eq(t && t ? 2 : 5 + 11, 13)
assert_eq(t || f ? 2 : 5 + 11, 13)
assert_eq(f || t ? 2 : 5 + 11, 13)

assert_eq(t && f ? 2 : 5 + 11, 16)
assert_eq(f && t ? 2 : 5 + 11, 16)
assert_eq(f && f ? 2 : 5 + 11, 16)

assert_eq(3 == 3 ? 2 : 5 + 11, 13)
assert_eq(3 == 4 ? 2 : 5 + 11, 16)

assert_eq(3 == 4
    ? 2
    : 5 + 11, 16)

assert_eq(3 == 3
    ? 2
    : 5 + 11, 13)

say "** Test passed!"