plum

module std

import std/Option

import std/Result

import std/List

import std/Bool

import std/Number

import std/Str

# Small jest/rspec-style assertion helpers for use inside `test` blocks, e.g.

#

#   test "add works"

#     assert expectEq(add(1, 2), 3)

#     assert expectTrue(isEven(4))

#

# These are plain functions returning `Bool` (`assert` only takes a bare

# boolean expression — see `plum-core/parser.rs`'s `assert` rule), not a new

# grammar form. They exist purely to make the condition read like an

# assertion instead of a raw comparison.

#

# `expectArray`/`expectSome`/`expectOk`/`expectErr` below take a container

# type (`List[T]`/`Option[T]`/`Result[T, E]`) whose OWN generic param is

# nested inside the param type — this used to hit a real monomorphizer bug

# (misclassified as a "bare generic class reference" fn, then lost its type

# argument when the specialized signature was registered, mismatching the

# caller's concrete arg type; fixed in `plum-checker/src/monomorphize.rs`'s

# `fnGenericParams`/`resolveFnInstantiation`, see the

# `plum_generic_method_self_nesting_landmine`-adjacent compiler-bugs memory).

# The underlying type's own method (`result.isOk()`, `listA.equals(listB)`)

# still works too and reads just as well — use whichever fits the call site.

#

# CAVEAT on `expectEq`/`expectNotEq`/`expectObject`/`List.equals`: Plum's

# `==`/`!=` have no operator-overloading mechanism. For Int/Str/Bool/Float

# they do real value comparison (Str is content-compared, not

# reference-compared). For class/enum instances there is no such override,

# so `==` compiles to reference identity — `expectEq` on two

# separately-constructed-but-equal structs will wrongly report `false`. For

# those types, prefer the type's own `equals(self, other)` method (e.g.

# `Uuid.equals`, `Time.equals`) directly in `assert` instead.

fun expectTrue(cond: Bool) -> Bool =

  cond

fun expectFalse(cond: Bool) -> Bool =

  !cond

fun expectEq(a: T, b: T) -> Bool =

  a == b

fun expectNotEq(a: T, b: T) -> Bool =

  a != b

# See the module-level CAVEAT above — this is `expectEq` under a name that

# reads better at a class/struct call site; it does NOT do structural

# (field-by-field) comparison.

fun expectObject(a: T, b: T) -> Bool =

  a == b

# Elementwise `List[T]` comparison — see the module-level CAVEAT above for

# what `List.equals`'s own `==` means when `T` is a class/enum.

fun expectArray(a: List[T], b: List[T]) -> Bool =

  a.equals(b)

fun expectSome(o: Option[T]) -> Bool =

  o.isSome()

fun expectNone(o: Option[T]) -> Bool =

  o.isNone()

fun expectOk(r: Result[T, E]) -> Bool =

  r.isOk()

fun expectErr(r: Result[T, E]) -> Bool =

  r.isErr()

fun makeOkForTestingTest() -> Result[Int, Str] =

  return Ok(5)

fun makeErrForTestingTest() -> Result[Int, Str] =

  return Err("bad")

fun makeNoneForTestingTest() -> Option[Int] =

  return None

test "expectTrue and expectFalse"

  assert expectTrue(1 == 1)

  assert expectFalse(1 == 2)

test "expectEq and expectNotEq"

  assert expectEq(2 + 2, 4)

  assert expectEq("ab" + "c", "abc")

  assert expectNotEq(2 + 2, 5)

test "list equality via the List.equals method"

  a := List(1, 2, 3)

  b := List(1, 2, 3)

  c := List(1, 2)

  assert a.equals(b)

  assert expectFalse(a.equals(c))

test "Option/Result checks via their own isSome/isNone/isOk/isErr methods"

  assert Some(1).isSome()

  assert makeNoneForTestingTest().isNone()

  assert makeOkForTestingTest().isOk()

  assert makeErrForTestingTest().isErr()

test "expectArray compares two List[T]s elementwise"

  a := List(1, 2, 3)

  b := List(1, 2, 3)

  c := List(1, 2)

  assert expectArray(a, b)

  assert expectFalse(expectArray(a, c))

  d := List("x", "y")

  e := List("x", "y")

  assert expectArray(d, e)

test "expectSome/expectNone/expectOk/expectErr check the right variant"

  assert expectSome(Some(1))

  assert expectFalse(expectSome(makeNoneForTestingTest()))

  assert expectNone(makeNoneForTestingTest())

  assert expectOk(makeOkForTestingTest())

  assert expectFalse(expectOk(makeErrForTestingTest()))

  assert expectErr(makeErrForTestingTest())

  assert expectFalse(expectErr(makeOkForTestingTest()))