fn pub static new -> Tests {
  let out = Stdout.new
  let colors = match env.opt('NO_COLOR') {
    case Some(v) if v.size > 0 -> false
    case _ -> out.terminal?
  }

  Tests(
    tests: [],
    children: [],
    concurrency: cpu_cores,
    reporter: Plain.new(out, colors) as Reporter,
    filter: Filter.None,
    seed: Option.None,
  )
}

fn pub mut fork(name: String, child: fn, test: uni fn (mut Test, Process)) {
  let id = @children.size

  @children.push(child)
  test(name, fn move (t) { test.call(t, Process.new(id)) })
}

fn pub mut no_panic(name: String, code: uni fn) {
  fork(name, code, fn (test, process) {
    let output = process.spawn
    let code = output.status.to_int

    if code != 101 { return }

    let got = output.stderr.split('\n').last.or('the process panicked')

    test.failures.push(Failure.new(got, 'the process not to panic'))
  })
}

fn pub mut ok[T, E: Format](
  name: String,
  code: uni fn (mut Test) -> Result[T, E],
) {
  test(name, fn move (t) {
    match code.call(t) {
      case Error(e) -> {
        t.failures.push(
          Failure(
            got: 'Result.Error(${fmt(e)})',
            expected: 'a value matching the pattern Result.Ok(_)',
            path: t.path.clone,
            line: t.line,
          ),
        )
      }
      case _ -> {}
    }
  })
}

fn pub mut panic(name: String, code: uni fn) {
  fork(name, code, fn (test, process) {
    let output = process.spawn
    let code = output.status.to_int

    if code == 101 { return }

    # These tests run in a separate OS process, and `debug.stacktrace` won't
    # include any frames pointing to the unit tests's source file. To work
    # around that, we reuse the test's location.
    let failure = Failure(
      got: 'the process exited with status ${code}',
      expected: 'the process to panic with exit status 101',
      path: test.path.clone,
      line: test.line,
    )

    test.failures.push(failure)
  })
}

fn pub move run {
  match env.opt(CHILD_VAR) {
    case Some(id) -> return run_child(id)
    case _ -> {}
  }

  let seed = match @seed {
    case Some(seed) -> seed
    case _ -> Random.new.int
  }

  # We shuffle tests in a random order to ensure they don't end up
  # (implicitly) depending on a specific execution order. We do this first so
  # we can build a unique list of filtered tests (which retain the order).
  Shuffle.from_int(seed).sort(@tests)

  let filter = @filter
  let tests = @tests
    .into_iter
    .select_map(fn (test) {
      if test.matches?(filter) { Option.Some(test) } else { Option.None }
    })
    .reduce(recover [], fn (tests, test) {
      tests.push(test)
      tests
    })

  let size = tests.size
  let rep = @reporter
  let start = Instant.new
  let jobs = Jobs(tests)
  let output = Channel.new

  @concurrency.times(fn (_) { Runner(jobs, recover output.clone).schedule })

  size.times(fn (_) {
    let test = recover output.receive

    if test.failures.empty? { rep.passed(test) } else { rep.failed(test) }
  })

  if rep.finished(start.elapsed, seed) {
    exit(status: 0)
  } else {
    exit(status: 1)
  }
}

fn pub move run_child(id: String) {
  match
    Int.parse(id, IntFormat.Decimal).then(fn (v) { @children.opt_mut(v) })
  {
    case Some(block) -> block.call
    case _ -> process.panic("The child ID '${id}' is invalid")
  }
}

fn pub mut test(name: String, code: uni fn (mut Test)) {
  let id = @tests.size
  let test = recover {
    match unit_test_stack_frame {
      case { @path = path, @line = line } -> {
        Test.new(id, name, path, line, code)
      }
    }
  }

  @tests.push(test)
}