Std.Test

44 public declarations

• absentStr -> &Option[T] -> Std.Test.Check

  A check that holds when an optional value is absent.

  fn
• allStr -> &Array[T] -> fn(T) -> Bool -> Std.Test.Check

  A check that holds when every value satisfies the test.

  fn
• Check

  One check: what it was called, and what it found.

  type
• closeToStr -> Decimal -> Decimal -> Decimal -> Std.Test.Check

  A check that holds when two exact numbers differ by no more than a

  fn
• combine&Std.Test.Report -> &Std.Test.Report -> Std.Test.Report

  Two reports added together.

  fn
• combineAll&Array[Std.Test.Report] -> Std.Test.Report

  Every report added together.

  fn
• containsStr -> &Array[T] -> T -> Std.Test.Check

  A check that holds when a sequence contains a value.

  fn
• differsStr -> &T -> &T -> Std.Test.Check

  A check that holds when two values differ.

  fn
• each&Array[T] -> fn(T) -> Str -> fn(T) -> Bool -> Array[Std.Test.Check]

  The same check over a table of cases.

  fn
• eachOf&Array[T] -> fn(T) -> Std.Test.Check -> Array[Std.Test.Check]

  The same check over a table of cases, where each case builds its own check.

  fn
• equalsStr -> &T -> &T -> Std.Test.Check

  A check that holds when two values are the same.

  fn
• erroredStr -> &Result[T, E] -> Std.Test.Check

  A check that holds when a result failed.

  fn
• failedOf&Std.Test.Report -> Int

  How many checks did not.

  fn
• failsStr -> &Std.Test.Check -> Std.Test.Check

  A check that holds exactly when the one it is given does not.

  fn
• failuresOf&Std.Test.Report -> Array[Str]

  What each failing check said.

  fn
• filtered&Std.Test.Suite -> fn(Str) -> Bool -> Std.Test.Suite

  Only the checks whose name the test accepts, through the whole tree.

  fn
• groupStr -> &Array[Std.Test.Suite] -> Std.Test.Suite

  A group of groups under a name.

  fn
• held&Std.Test.Check -> Bool

  Whether a check held.

  fn
• lines&Std.Test.Report -> Array[Str]

  A report as lines, the failures first and a summary last.

  fn
• names&Std.Test.Suite -> Array[Str]

  The names of the checks in a suite and every group beneath it.

  fn
• notStr -> Bool -> Std.Test.Check

  A check that holds when the condition does not.

  fn
• Outcome

  What one check found.

  type
• passed&Std.Test.Report -> Bool

  Whether every check held.

  fn
• passedOf&Std.Test.Report -> Int

  How many checks held.

  fn
• pending&Std.Test.Check -> Bool

  Whether a check was left to be written.

  fn
• pendingOf&Std.Test.Report -> Int

  How many checks were left to be written.

  fn
• presentStr -> &Option[T] -> Std.Test.Check

  A check that holds when an optional value is present, whatever it holds.

  fn
• rendered&Std.Test.Report -> Str

  The report rendered as one block of text.

  fn
• report&Std.Test.Report -> Int

  What a suite run by `pudu test` should answer.

  fn
• Report

  What running a suite found, counted and with the failures kept.

  type
• run&Std.Test.Suite -> Std.Test.Report

  The report a suite answers, counted through every group beneath it.

  fn
• runIfBool -> Str -> &Std.Test.Check -> Std.Test.Check

  A check kept only when a condition holds, and left pending otherwise.

  fn
• sameElementsStr -> &Array[T] -> &Array[T] -> Std.Test.Check where T: Ord

  A check that holds when two sequences hold the same values, in any order.

  fn
• skipIfBool -> Str -> &Std.Test.Check -> Std.Test.Check

  A check left pending when a condition holds, and kept otherwise.

  fn
• status&Std.Test.Report -> Int

  The status a program should leave with, which is zero only when every check

  fn
• succeededStr -> &Result[T, E] -> Std.Test.Check

  A check that holds when a result succeeded.

  fn
• suiteStr -> &Array[Std.Test.Check] -> Std.Test.Suite

  A group of checks under a name.

  fn
• Suite

  A named group of checks, and the groups beneath it.

  type
• summary&Std.Test.Report -> Str

  One line saying how many of how many held.

  fn
• thatStr -> Bool -> Std.Test.Check

  A check that holds when the condition does.

  fn
• todoStr -> Str -> Std.Test.Check

  A check not yet written, carrying why.

  fn
• total&Std.Test.Report -> Int

  How many checks ran.

  fn
• withCheck&Std.Test.Suite -> &Std.Test.Check -> Std.Test.Suite

  The suite with another check in it.

  fn
• withGroup&Std.Test.Suite -> &Std.Test.Suite -> Std.Test.Suite

  The suite with another group beneath it.

  fn