initial commit - from https://github.com/nim-lang/Nim/pull/9724
This commit is contained in:
Ștefan Talpalaru
commit
ae4d471d38
|
|
@ -0,0 +1,2 @@
|
||||||
|
nimcache/
|
||||||
|
|
||||||
|
|
@ -0,0 +1,22 @@
|
||||||
|
Copyright (c) 2011-2018 Zahary Karadjov. All rights reserved.
|
||||||
|
Copyright (c) 2018-2019 Ștefan Talpalaru <stefantalpalaru@yahoo.com>
|
||||||
|
|
||||||
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||||
|
of this software and associated documentation files (the "Software"), to deal
|
||||||
|
in the Software without restriction, including without limitation the rights
|
||||||
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||||
|
copies of the Software, and to permit persons to whom the Software is
|
||||||
|
furnished to do so, subject to the following conditions:
|
||||||
|
|
||||||
|
The above copyright notice and this permission notice shall be included in
|
||||||
|
all copies or substantial portions of the Software.
|
||||||
|
|
||||||
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||||
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||||
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||||
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||||
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||||
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||||
|
THE SOFTWARE.
|
||||||
|
|
||||||
|
[ MIT license: http://www.opensource.org/licenses/mit-license.php ]
|
||||||
|
|
@ -0,0 +1,36 @@
|
||||||
|
## description
|
||||||
|
|
||||||
|
**unittest2** is a fork of the [unittest](https://nim-lang.org/docs/unittest.html) module in the
|
||||||
|
[Nim](https://nim-lang.org/) standard library, with a focus on parallel test
|
||||||
|
execution.
|
||||||
|
|
||||||
|
This fork was originally a pull request: [https://github.com/nim-lang/Nim/pull/9724](https://github.com/nim-lang/Nim/pull/9724)
|
||||||
|
|
||||||
|
## testing
|
||||||
|
|
||||||
|
```text
|
||||||
|
nimble test
|
||||||
|
```
|
||||||
|
|
||||||
|
## installation
|
||||||
|
|
||||||
|
```text
|
||||||
|
nimble install
|
||||||
|
```
|
||||||
|
|
||||||
|
## usage
|
||||||
|
|
||||||
|
Replace `import unittest` with `import unittest2` and see the [unittest2.html]() documentation generated by `nim doc unittest2.nim`.
|
||||||
|
|
||||||
|
## license
|
||||||
|
|
||||||
|
MIT
|
||||||
|
|
||||||
|
## credits
|
||||||
|
|
||||||
|
- original author: Zahary Karadjov
|
||||||
|
|
||||||
|
- fork author: Ștefan Talpalaru <stefantalpalaru@yahoo.com>
|
||||||
|
|
||||||
|
- homepage: https://github.com/stefantalpalaru/nim-unittest2
|
||||||
|
|
||||||
|
|
@ -0,0 +1,8 @@
|
||||||
|
@if release:
|
||||||
|
nimcache = "nimcache/release/$projectName"
|
||||||
|
@else:
|
||||||
|
nimcache = "nimcache/debug/$projectName"
|
||||||
|
@end
|
||||||
|
|
||||||
|
--threads:on
|
||||||
|
|
||||||
|
|
@ -0,0 +1,2 @@
|
||||||
|
--path:"$projectDir/.."
|
||||||
|
|
||||||
|
|
@ -0,0 +1,179 @@
|
||||||
|
discard """
|
||||||
|
output: '''[Suite] suite with only teardown
|
||||||
|
|
||||||
|
[Suite] suite with only setup
|
||||||
|
|
||||||
|
[Suite] suite with none
|
||||||
|
|
||||||
|
[Suite] suite with both
|
||||||
|
|
||||||
|
[Suite] bug #4494
|
||||||
|
|
||||||
|
[Suite] bug #5571
|
||||||
|
|
||||||
|
[Suite] bug #5784
|
||||||
|
|
||||||
|
[Suite] test suite
|
||||||
|
|
||||||
|
[Suite] test name filtering
|
||||||
|
|
||||||
|
'''
|
||||||
|
"""
|
||||||
|
|
||||||
|
import unittest2, sequtils
|
||||||
|
|
||||||
|
proc doThings(spuds: var int): int =
|
||||||
|
spuds = 24
|
||||||
|
return 99
|
||||||
|
test "#964":
|
||||||
|
var spuds = 0
|
||||||
|
check doThings(spuds) == 99
|
||||||
|
check spuds == 24
|
||||||
|
|
||||||
|
|
||||||
|
from strutils import toUpperAscii
|
||||||
|
test "#1384":
|
||||||
|
check(@["hello", "world"].map(toUpperAscii) == @["HELLO", "WORLD"])
|
||||||
|
|
||||||
|
|
||||||
|
import options
|
||||||
|
test "unittest typedescs":
|
||||||
|
check(none(int) == none(int))
|
||||||
|
check(none(int) != some(1))
|
||||||
|
|
||||||
|
|
||||||
|
test "unittest multiple requires":
|
||||||
|
require(true)
|
||||||
|
require(true)
|
||||||
|
|
||||||
|
|
||||||
|
import math, random
|
||||||
|
from strutils import parseInt
|
||||||
|
proc defectiveRobot() =
|
||||||
|
randomize()
|
||||||
|
case rand(1..4)
|
||||||
|
of 1: raise newException(OSError, "CANNOT COMPUTE!")
|
||||||
|
of 2: discard parseInt("Hello World!")
|
||||||
|
of 3: raise newException(IOError, "I can't do that Dave.")
|
||||||
|
else: assert 2 + 2 == 5
|
||||||
|
test "unittest expect":
|
||||||
|
expect IOError, OSError, ValueError, AssertionError:
|
||||||
|
defectiveRobot()
|
||||||
|
|
||||||
|
var
|
||||||
|
a = 1
|
||||||
|
b = -1
|
||||||
|
c = 1
|
||||||
|
|
||||||
|
#unittests are sequential right now
|
||||||
|
suite "suite with only teardown":
|
||||||
|
teardown:
|
||||||
|
b = 2
|
||||||
|
|
||||||
|
test "unittest with only teardown 1":
|
||||||
|
check a == c
|
||||||
|
|
||||||
|
test "unittest with only teardown 2":
|
||||||
|
check b > a
|
||||||
|
|
||||||
|
suite "suite with only setup":
|
||||||
|
setup:
|
||||||
|
var testVar {.used.} = "from setup"
|
||||||
|
|
||||||
|
test "unittest with only setup 1":
|
||||||
|
check testVar == "from setup"
|
||||||
|
check b > a
|
||||||
|
b = -1
|
||||||
|
|
||||||
|
test "unittest with only setup 2":
|
||||||
|
check b < a
|
||||||
|
|
||||||
|
suite "suite with none":
|
||||||
|
test "unittest with none":
|
||||||
|
check b < a
|
||||||
|
|
||||||
|
suite "suite with both":
|
||||||
|
setup:
|
||||||
|
a = -2
|
||||||
|
|
||||||
|
teardown:
|
||||||
|
c = 2
|
||||||
|
|
||||||
|
test "unittest with both 1":
|
||||||
|
check b > a
|
||||||
|
|
||||||
|
test "unittest with both 2":
|
||||||
|
check c == 2
|
||||||
|
|
||||||
|
suite "bug #4494":
|
||||||
|
test "Uniqueness check":
|
||||||
|
var tags = @[1, 2, 3, 4, 5]
|
||||||
|
check:
|
||||||
|
allIt(0..3, tags[it] != tags[it + 1])
|
||||||
|
|
||||||
|
suite "bug #5571":
|
||||||
|
test "can define gcsafe procs within tests":
|
||||||
|
proc doTest {.gcsafe.} =
|
||||||
|
let line = "a"
|
||||||
|
check: line == "a"
|
||||||
|
doTest()
|
||||||
|
|
||||||
|
suite "bug #5784":
|
||||||
|
test "`or` should short circuit":
|
||||||
|
type Obj = ref object
|
||||||
|
field: int
|
||||||
|
var obj: Obj
|
||||||
|
check obj.isNil or obj.field == 0
|
||||||
|
|
||||||
|
type
|
||||||
|
SomeType = object
|
||||||
|
value: int
|
||||||
|
children: seq[SomeType]
|
||||||
|
|
||||||
|
# bug #5252
|
||||||
|
|
||||||
|
proc `==`(a, b: SomeType): bool =
|
||||||
|
return a.value == b.value
|
||||||
|
|
||||||
|
suite "test suite":
|
||||||
|
test "test":
|
||||||
|
let a = SomeType(value: 10)
|
||||||
|
let b = SomeType(value: 10)
|
||||||
|
|
||||||
|
check(a == b)
|
||||||
|
|
||||||
|
when defined(testing):
|
||||||
|
suite "test name filtering":
|
||||||
|
test "test name":
|
||||||
|
check matchFilter("suite1", "foo", "")
|
||||||
|
check matchFilter("suite1", "foo", "foo")
|
||||||
|
check matchFilter("suite1", "foo", "::")
|
||||||
|
check matchFilter("suite1", "foo", "*")
|
||||||
|
check matchFilter("suite1", "foo", "::foo")
|
||||||
|
check matchFilter("suite1", "::foo", "::foo")
|
||||||
|
|
||||||
|
test "test name - glob":
|
||||||
|
check matchFilter("suite1", "foo", "f*")
|
||||||
|
check matchFilter("suite1", "foo", "*oo")
|
||||||
|
check matchFilter("suite1", "12345", "12*345")
|
||||||
|
check matchFilter("suite1", "q*wefoo", "q*wefoo")
|
||||||
|
check false == matchFilter("suite1", "foo", "::x")
|
||||||
|
check false == matchFilter("suite1", "foo", "::x*")
|
||||||
|
check false == matchFilter("suite1", "foo", "::*x")
|
||||||
|
# overlap
|
||||||
|
check false == matchFilter("suite1", "12345", "123*345")
|
||||||
|
check matchFilter("suite1", "ab*c::d*e::f", "ab*c::d*e::f")
|
||||||
|
|
||||||
|
test "suite name":
|
||||||
|
check matchFilter("suite1", "foo", "suite1::")
|
||||||
|
check false == matchFilter("suite1", "foo", "suite2::")
|
||||||
|
check matchFilter("suite1", "qwe::foo", "qwe::foo")
|
||||||
|
check matchFilter("suite1", "qwe::foo", "suite1::qwe::foo")
|
||||||
|
|
||||||
|
test "suite name - glob":
|
||||||
|
check matchFilter("suite1", "foo", "::*")
|
||||||
|
check matchFilter("suite1", "foo", "*::*")
|
||||||
|
check matchFilter("suite1", "foo", "*::foo")
|
||||||
|
check false == matchFilter("suite1", "foo", "*ite2::")
|
||||||
|
check matchFilter("suite1", "q**we::foo", "q**we::foo")
|
||||||
|
check matchFilter("suite1", "a::b*c::d*e", "a::b*c::d*e")
|
||||||
|
|
@ -0,0 +1,134 @@
|
||||||
|
discard """
|
||||||
|
output: '''[Suite] suite #1
|
||||||
|
|
||||||
|
[Suite] suite #2
|
||||||
|
'''
|
||||||
|
"""
|
||||||
|
|
||||||
|
# Unfortunately, it's not possible to decouple the thread execution order from
|
||||||
|
# the number of available cores, due to how threadpool dynamically (and lazily)
|
||||||
|
# adjusts the number of worker threads, so we can't have a PRINT_ALL output in
|
||||||
|
# the verification section above.
|
||||||
|
|
||||||
|
import unittest2, os
|
||||||
|
|
||||||
|
test "independent test #1":
|
||||||
|
sleep(1000)
|
||||||
|
check 1 == 1
|
||||||
|
# check 1 == 2
|
||||||
|
# require 1 == 2
|
||||||
|
# var g {.global.}: seq[int]
|
||||||
|
# g.add(1)
|
||||||
|
|
||||||
|
test "independent test #2":
|
||||||
|
sleep(800)
|
||||||
|
check 1 == 1
|
||||||
|
|
||||||
|
test "independent test #3":
|
||||||
|
## nested tests
|
||||||
|
# we might as well keep this futile attempt at finding a problem with
|
||||||
|
# uninitialized `flowVars` in child threads
|
||||||
|
test "independent test #4":
|
||||||
|
test "independent test #5":
|
||||||
|
test "independent test #8":
|
||||||
|
test "independent test #9":
|
||||||
|
test "independent test #10":
|
||||||
|
test "independent test #11":
|
||||||
|
test "independent test #12":
|
||||||
|
test "independent test #13":
|
||||||
|
test "independent test #14":
|
||||||
|
test "independent test #15":
|
||||||
|
sleep(200)
|
||||||
|
check 1 == 1
|
||||||
|
test "independent test #16":
|
||||||
|
sleep(200)
|
||||||
|
check 1 == 1
|
||||||
|
test "independent test #17":
|
||||||
|
sleep(200)
|
||||||
|
check 1 == 1
|
||||||
|
test "independent test #18":
|
||||||
|
sleep(200)
|
||||||
|
check 1 == 1
|
||||||
|
test "independent test #19":
|
||||||
|
sleep(200)
|
||||||
|
check 1 == 1
|
||||||
|
test "independent test #20":
|
||||||
|
sleep(200)
|
||||||
|
check 1 == 1
|
||||||
|
test "independent test #21":
|
||||||
|
sleep(200)
|
||||||
|
check 1 == 1
|
||||||
|
test "independent test #22":
|
||||||
|
sleep(200)
|
||||||
|
check 1 == 1
|
||||||
|
test "independent test #23":
|
||||||
|
sleep(200)
|
||||||
|
check 1 == 1
|
||||||
|
test "independent test #24":
|
||||||
|
sleep(200)
|
||||||
|
check 1 == 1
|
||||||
|
test "independent test #25":
|
||||||
|
test "independent test #26":
|
||||||
|
sleep(200)
|
||||||
|
check 1 == 1
|
||||||
|
sleep(200)
|
||||||
|
check 1 == 1
|
||||||
|
sleep(200)
|
||||||
|
check 1 == 1
|
||||||
|
sleep(200)
|
||||||
|
check 1 == 1
|
||||||
|
sleep(200)
|
||||||
|
check 1 == 1
|
||||||
|
sleep(200)
|
||||||
|
check 1 == 1
|
||||||
|
sleep(200)
|
||||||
|
check 1 == 1
|
||||||
|
sleep(200)
|
||||||
|
check 1 == 1
|
||||||
|
sleep(200)
|
||||||
|
check 1 == 1
|
||||||
|
sleep(200)
|
||||||
|
check 1 == 1
|
||||||
|
sleep(400)
|
||||||
|
check 1 == 1
|
||||||
|
sleep(600)
|
||||||
|
check 1 == 1
|
||||||
|
|
||||||
|
suite "suite #1":
|
||||||
|
test "suite #1, test #1":
|
||||||
|
sleep(400)
|
||||||
|
check 1 == 1
|
||||||
|
|
||||||
|
test "suite #1, test #2":
|
||||||
|
sleep(300)
|
||||||
|
check 1 == 1
|
||||||
|
|
||||||
|
suite "suite #2":
|
||||||
|
setup:
|
||||||
|
# only here can we set formatters when running the tests in parallel
|
||||||
|
# (this setup will be executed for each test, so it may run multiple times
|
||||||
|
# in the same thread, hence the clearing of the threadvar before adding to it)
|
||||||
|
clearOutputFormatters()
|
||||||
|
addOutputFormatter(newConsoleOutputFormatter(PRINT_FAILURES, colorOutput=false))
|
||||||
|
|
||||||
|
teardown:
|
||||||
|
# we don't want the custom formatter to remain in worker threads after this
|
||||||
|
# suite is done
|
||||||
|
clearOutputFormatters()
|
||||||
|
|
||||||
|
test "suite #2, test #1":
|
||||||
|
sleep(200)
|
||||||
|
check 1 == 1
|
||||||
|
|
||||||
|
test "suite #2, test #2":
|
||||||
|
sleep(100)
|
||||||
|
check 1 == 1
|
||||||
|
|
||||||
|
test "independent test #6":
|
||||||
|
sleep(200)
|
||||||
|
check 1 == 1
|
||||||
|
|
||||||
|
test "independent test #7":
|
||||||
|
sleep(100)
|
||||||
|
check 1 == 1
|
||||||
|
|
||||||
|
|
@ -0,0 +1,2 @@
|
||||||
|
-d:nimtestParallel
|
||||||
|
|
||||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,828 @@
|
||||||
|
# See the file "LICENSE.txt", included in this
|
||||||
|
# distribution, for details about the copyright.
|
||||||
|
#
|
||||||
|
|
||||||
|
## :Authors: Zahary Karadjov, Ștefan Talpalaru
|
||||||
|
##
|
||||||
|
## This module implements boilerplate to make unit testing easy.
|
||||||
|
##
|
||||||
|
## The test status and name is printed after any output or traceback.
|
||||||
|
##
|
||||||
|
## Tests can be nested, however failure of a nested test will not mark the
|
||||||
|
## parent test as failed. Setup and teardown are inherited. Setup can be
|
||||||
|
## overridden locally.
|
||||||
|
##
|
||||||
|
## Compiled test files return the number of failed test as exit code, while
|
||||||
|
##
|
||||||
|
## .. code::
|
||||||
|
## nim c -r testfile.nim
|
||||||
|
##
|
||||||
|
## exits with 0 or 1.
|
||||||
|
##
|
||||||
|
## Running individual tests
|
||||||
|
## ========================
|
||||||
|
##
|
||||||
|
## Specify the test names as command line arguments.
|
||||||
|
##
|
||||||
|
## .. code::
|
||||||
|
##
|
||||||
|
## nim c -r test "my test name" "another test"
|
||||||
|
##
|
||||||
|
## Multiple arguments can be used.
|
||||||
|
##
|
||||||
|
## Running a single test suite
|
||||||
|
## ===========================
|
||||||
|
##
|
||||||
|
## Specify the suite name delimited by ``"::"``.
|
||||||
|
##
|
||||||
|
## .. code::
|
||||||
|
##
|
||||||
|
## nim c -r test "my suite name::"
|
||||||
|
##
|
||||||
|
## Selecting tests by pattern
|
||||||
|
## ==========================
|
||||||
|
##
|
||||||
|
## A single ``"*"`` can be used for globbing.
|
||||||
|
##
|
||||||
|
## Delimit the end of a suite name with ``"::"``.
|
||||||
|
##
|
||||||
|
## Tests matching **any** of the arguments are executed.
|
||||||
|
##
|
||||||
|
## .. code::
|
||||||
|
##
|
||||||
|
## nim c -r test fast_suite::mytest1 fast_suite::mytest2
|
||||||
|
## nim c -r test "fast_suite::mytest*"
|
||||||
|
## nim c -r test "auth*::" "crypto::hashing*"
|
||||||
|
## # Run suites starting with 'bug #' and standalone tests starting with '#'
|
||||||
|
## nim c -r test 'bug #*::' '::#*'
|
||||||
|
##
|
||||||
|
## Running tests in parallel
|
||||||
|
## =========================
|
||||||
|
##
|
||||||
|
## To enable the threadpool-based test parallelisation, "--threads:on" needs to
|
||||||
|
## be passed to the compiler, along with "-d:nimtestParallel" or the
|
||||||
|
## NIMTEST_PARALLEL environment variable:
|
||||||
|
##
|
||||||
|
## .. code::
|
||||||
|
##
|
||||||
|
## nim c -r --threads:on -d:nimtestParallel testfile.nim
|
||||||
|
## # or
|
||||||
|
## NIMTEST_PARALLEL=1 nim c -r --threads:on testfile.nim
|
||||||
|
##
|
||||||
|
## Since output formatters are kept in a threadvar, they need to be initialised
|
||||||
|
## for each thread in the thread pool. This means that customisation can only be
|
||||||
|
## done in a suite's "setup" section, which will run before each test in that
|
||||||
|
## suite - hence the need to clear existing formatters before adding new ones:
|
||||||
|
##
|
||||||
|
## .. code:: nim
|
||||||
|
##
|
||||||
|
## suite "custom formatter":
|
||||||
|
## setup:
|
||||||
|
## clearOutputFormatters()
|
||||||
|
## addOutputFormatter(newConsoleOutputFormatter(PRINT_FAILURES, colorOutput=false))
|
||||||
|
##
|
||||||
|
## # if you need to revert back to the default after the suite
|
||||||
|
## teardown:
|
||||||
|
## clearOutputFormatters()
|
||||||
|
##
|
||||||
|
## There are some implicit barriers where we wait for all the spawned jobs to
|
||||||
|
## complete: before and after each test suite and at the main thread's exit.
|
||||||
|
##
|
||||||
|
## The suite-related barriers are there to avoid mixing test output, but they
|
||||||
|
## also affect which groups of tests can be run in parallel, so keep them in
|
||||||
|
## mind when deciding how many tests to place in different suites (or between
|
||||||
|
## suites).
|
||||||
|
##
|
||||||
|
## Example
|
||||||
|
## -------
|
||||||
|
##
|
||||||
|
## .. code:: nim
|
||||||
|
##
|
||||||
|
## suite "description for this stuff":
|
||||||
|
## echo "suite setup: run once before the tests"
|
||||||
|
##
|
||||||
|
## setup:
|
||||||
|
## echo "run before each test"
|
||||||
|
##
|
||||||
|
## teardown:
|
||||||
|
## echo "run after each test"
|
||||||
|
##
|
||||||
|
## test "essential truths":
|
||||||
|
## # give up and stop if this fails
|
||||||
|
## require(true)
|
||||||
|
##
|
||||||
|
## test "slightly less obvious stuff":
|
||||||
|
## # print a nasty message and move on, skipping
|
||||||
|
## # the remainder of this block
|
||||||
|
## check(1 != 1)
|
||||||
|
## check("asd"[2] == 'd')
|
||||||
|
##
|
||||||
|
## test "out of bounds error is thrown on bad access":
|
||||||
|
## let v = @[1, 2, 3] # you can do initialization here
|
||||||
|
## expect(IndexError):
|
||||||
|
## discard v[4]
|
||||||
|
##
|
||||||
|
## echo "suite teardown: run once after the tests"
|
||||||
|
|
||||||
|
import
|
||||||
|
macros, strutils, streams, times, sets
|
||||||
|
|
||||||
|
when declared(stdout):
|
||||||
|
import os
|
||||||
|
|
||||||
|
when not defined(ECMAScript):
|
||||||
|
import terminal
|
||||||
|
|
||||||
|
when declared(stdout):
|
||||||
|
const paralleliseTests* = existsEnv("NIMTEST_PARALLEL") or defined(nimtestParallel)
|
||||||
|
## Whether parallel test running was enabled (set at compile time).
|
||||||
|
## This constant might be useful in custom output formatters.
|
||||||
|
else:
|
||||||
|
const paralleliseTests* = false
|
||||||
|
|
||||||
|
when paralleliseTests:
|
||||||
|
import threadpool, locks
|
||||||
|
|
||||||
|
# repeatedly calling sync() without waiting for results - on procs that don't
|
||||||
|
# return any - doesn't work properly (probably due to gSomeReady getting its
|
||||||
|
# counter increased back to the pre-call value) so we're stuck with these
|
||||||
|
# dummy flowvars
|
||||||
|
# (`flowVars` will be initialized in each child thread, when using nested tests, by the compiler)
|
||||||
|
var flowVars {.threadvar.}: seq[FlowVarBase]
|
||||||
|
proc repeatableSync() =
|
||||||
|
sync()
|
||||||
|
for flowVar in flowVars:
|
||||||
|
blockUntil(flowVar)
|
||||||
|
flowVars = @[]
|
||||||
|
|
||||||
|
# make sure all the spawned tests are done before exiting
|
||||||
|
# (this will be the last sync, so no need for repeatability)
|
||||||
|
let mainThreadID = getThreadId()
|
||||||
|
proc quitProc() {.noconv.} =
|
||||||
|
# "require" can exit from a worker thread and syncing in there would block
|
||||||
|
if getThreadId() == mainThreadID:
|
||||||
|
sync()
|
||||||
|
addQuitProc(quitProc)
|
||||||
|
|
||||||
|
var outputLock: Lock # used by testEnded() to avoid mixed test outputs
|
||||||
|
initLock(outputLock)
|
||||||
|
|
||||||
|
type
|
||||||
|
TestStatus* = enum ## The status of a test when it is done.
|
||||||
|
OK,
|
||||||
|
FAILED,
|
||||||
|
SKIPPED
|
||||||
|
|
||||||
|
OutputLevel* = enum ## The output verbosity of the tests.
|
||||||
|
PRINT_ALL, ## Print as much as possible.
|
||||||
|
PRINT_FAILURES, ## Print only the failed tests.
|
||||||
|
PRINT_NONE ## Print nothing.
|
||||||
|
|
||||||
|
TestResult* = object
|
||||||
|
suiteName*: string
|
||||||
|
## Name of the test suite that contains this test case.
|
||||||
|
## Can be ``nil`` if the test case is not in a suite.
|
||||||
|
testName*: string
|
||||||
|
## Name of the test case
|
||||||
|
status*: TestStatus
|
||||||
|
|
||||||
|
OutputFormatter* = ref object of RootObj
|
||||||
|
|
||||||
|
ConsoleOutputFormatter* = ref object of OutputFormatter
|
||||||
|
colorOutput: bool
|
||||||
|
## Have test results printed in color.
|
||||||
|
## Default is true for the non-js target,
|
||||||
|
## for which ``stdout`` is a tty.
|
||||||
|
## Setting the environment variable
|
||||||
|
## ``NIMTEST_COLOR`` to ``always`` or
|
||||||
|
## ``never`` changes the default for the
|
||||||
|
## non-js target to true or false respectively.
|
||||||
|
## The deprecated environment variable
|
||||||
|
## ``NIMTEST_NO_COLOR``, when set,
|
||||||
|
## changes the defualt to true, if
|
||||||
|
## ``NIMTEST_COLOR`` is undefined.
|
||||||
|
outputLevel: OutputLevel
|
||||||
|
## Set the verbosity of test results.
|
||||||
|
## Default is ``PRINT_ALL``, unless
|
||||||
|
## the ``NIMTEST_OUTPUT_LVL`` environment
|
||||||
|
## variable is set for the non-js target.
|
||||||
|
isInSuite: bool
|
||||||
|
isInTest: bool
|
||||||
|
|
||||||
|
JUnitOutputFormatter* = ref object of OutputFormatter
|
||||||
|
stream: Stream
|
||||||
|
testErrors: seq[string]
|
||||||
|
testStartTime: float
|
||||||
|
testStackTrace: string
|
||||||
|
|
||||||
|
var
|
||||||
|
abortOnError* {.threadvar.}: bool ## Set to true in order to quit
|
||||||
|
## immediately on fail. Default is false,
|
||||||
|
## unless the ``NIMTEST_ABORT_ON_ERROR``
|
||||||
|
## environment variable is set for
|
||||||
|
## the non-js target.
|
||||||
|
|
||||||
|
checkpoints {.threadvar.}: seq[string]
|
||||||
|
formatters {.threadvar.}: seq[OutputFormatter]
|
||||||
|
testsFilters {.threadvar.}: HashSet[string]
|
||||||
|
disabledParamFiltering: bool
|
||||||
|
|
||||||
|
when declared(stdout):
|
||||||
|
abortOnError = existsEnv("NIMTEST_ABORT_ON_ERROR")
|
||||||
|
|
||||||
|
method suiteStarted*(formatter: OutputFormatter, suiteName: string) {.base, gcsafe.} =
|
||||||
|
discard
|
||||||
|
method testStarted*(formatter: OutputFormatter, testName: string) {.base, gcsafe.} =
|
||||||
|
discard
|
||||||
|
method failureOccurred*(formatter: OutputFormatter, checkpoints: seq[string], stackTrace: string) {.base, gcsafe.} =
|
||||||
|
## ``stackTrace`` is provided only if the failure occurred due to an exception.
|
||||||
|
## ``checkpoints`` is never ``nil``.
|
||||||
|
discard
|
||||||
|
method testEnded*(formatter: OutputFormatter, testResult: TestResult) {.base, gcsafe.} =
|
||||||
|
discard
|
||||||
|
method suiteEnded*(formatter: OutputFormatter) {.base, gcsafe.} =
|
||||||
|
discard
|
||||||
|
|
||||||
|
proc clearOutputFormatters*() =
|
||||||
|
formatters = @[]
|
||||||
|
|
||||||
|
proc addOutputFormatter*(formatter: OutputFormatter) =
|
||||||
|
formatters.add(formatter)
|
||||||
|
|
||||||
|
proc newConsoleOutputFormatter*(outputLevel: OutputLevel = PRINT_ALL,
|
||||||
|
colorOutput = true): ConsoleOutputFormatter =
|
||||||
|
ConsoleOutputFormatter(
|
||||||
|
outputLevel: outputLevel,
|
||||||
|
colorOutput: colorOutput
|
||||||
|
)
|
||||||
|
|
||||||
|
proc defaultConsoleFormatter*(): ConsoleOutputFormatter =
|
||||||
|
when declared(stdout):
|
||||||
|
# Reading settings
|
||||||
|
# On a terminal this branch is executed
|
||||||
|
var envOutLvl = os.getEnv("NIMTEST_OUTPUT_LVL").string
|
||||||
|
var colorOutput = isatty(stdout)
|
||||||
|
if existsEnv("NIMTEST_COLOR"):
|
||||||
|
let colorEnv = getenv("NIMTEST_COLOR")
|
||||||
|
if colorEnv == "never":
|
||||||
|
colorOutput = false
|
||||||
|
elif colorEnv == "always":
|
||||||
|
colorOutput = true
|
||||||
|
elif existsEnv("NIMTEST_NO_COLOR"):
|
||||||
|
colorOutput = false
|
||||||
|
var outputLevel = PRINT_ALL
|
||||||
|
if envOutLvl.len > 0:
|
||||||
|
for opt in countup(low(OutputLevel), high(OutputLevel)):
|
||||||
|
if $opt == envOutLvl:
|
||||||
|
outputLevel = opt
|
||||||
|
break
|
||||||
|
result = newConsoleOutputFormatter(outputLevel, colorOutput)
|
||||||
|
else:
|
||||||
|
result = newConsoleOutputFormatter()
|
||||||
|
|
||||||
|
method suiteStarted*(formatter: ConsoleOutputFormatter, suiteName: string) =
|
||||||
|
template rawPrint() = echo("\n[Suite] ", suiteName)
|
||||||
|
when not defined(ECMAScript):
|
||||||
|
if formatter.colorOutput:
|
||||||
|
styledEcho styleBright, fgBlue, "\n[Suite] ", resetStyle, suiteName
|
||||||
|
else: rawPrint()
|
||||||
|
else: rawPrint()
|
||||||
|
formatter.isInSuite = true
|
||||||
|
|
||||||
|
method testStarted*(formatter: ConsoleOutputFormatter, testName: string) =
|
||||||
|
formatter.isInTest = true
|
||||||
|
|
||||||
|
method failureOccurred*(formatter: ConsoleOutputFormatter, checkpoints: seq[string], stackTrace: string) =
|
||||||
|
if stackTrace.len > 0:
|
||||||
|
echo stackTrace
|
||||||
|
let prefix = if formatter.isInSuite: " " else: ""
|
||||||
|
for msg in items(checkpoints):
|
||||||
|
echo prefix, msg
|
||||||
|
|
||||||
|
method testEnded*(formatter: ConsoleOutputFormatter, testResult: TestResult) =
|
||||||
|
formatter.isInTest = false
|
||||||
|
|
||||||
|
if formatter.outputLevel != PRINT_NONE and
|
||||||
|
(formatter.outputLevel == PRINT_ALL or testResult.status == FAILED):
|
||||||
|
let prefix = if testResult.suiteName.len > 0: " " else: ""
|
||||||
|
template rawPrint() = echo(prefix, "[", $testResult.status, "] ", testResult.testName)
|
||||||
|
when not defined(ECMAScript):
|
||||||
|
if formatter.colorOutput and not defined(ECMAScript):
|
||||||
|
var color = case testResult.status
|
||||||
|
of OK: fgGreen
|
||||||
|
of FAILED: fgRed
|
||||||
|
of SKIPPED: fgYellow
|
||||||
|
styledEcho styleBright, color, prefix, "[", $testResult.status, "] ", resetStyle, testResult.testName
|
||||||
|
else:
|
||||||
|
rawPrint()
|
||||||
|
else:
|
||||||
|
rawPrint()
|
||||||
|
|
||||||
|
method suiteEnded*(formatter: ConsoleOutputFormatter) =
|
||||||
|
formatter.isInSuite = false
|
||||||
|
|
||||||
|
proc xmlEscape(s: string): string =
|
||||||
|
result = newStringOfCap(s.len)
|
||||||
|
for c in items(s):
|
||||||
|
case c:
|
||||||
|
of '<': result.add("<")
|
||||||
|
of '>': result.add(">")
|
||||||
|
of '&': result.add("&")
|
||||||
|
of '"': result.add(""")
|
||||||
|
of '\'': result.add("'")
|
||||||
|
else:
|
||||||
|
if ord(c) < 32:
|
||||||
|
result.add("&#" & $ord(c) & ';')
|
||||||
|
else:
|
||||||
|
result.add(c)
|
||||||
|
|
||||||
|
proc newJUnitOutputFormatter*(stream: Stream): JUnitOutputFormatter =
|
||||||
|
## Creates a formatter that writes report to the specified stream in
|
||||||
|
## JUnit format.
|
||||||
|
## The ``stream`` is NOT closed automatically when the test are finished,
|
||||||
|
## because the formatter has no way to know when all tests are finished.
|
||||||
|
## You should invoke formatter.close() to finalize the report.
|
||||||
|
result = JUnitOutputFormatter(
|
||||||
|
stream: stream,
|
||||||
|
testErrors: @[],
|
||||||
|
testStackTrace: "",
|
||||||
|
testStartTime: 0.0
|
||||||
|
)
|
||||||
|
stream.writeLine("<?xml version=\"1.0\" encoding=\"UTF-8\"?>")
|
||||||
|
stream.writeLine("<testsuites>")
|
||||||
|
|
||||||
|
proc close*(formatter: JUnitOutputFormatter) =
|
||||||
|
## Completes the report and closes the underlying stream.
|
||||||
|
formatter.stream.writeLine("</testsuites>")
|
||||||
|
formatter.stream.close()
|
||||||
|
|
||||||
|
method suiteStarted*(formatter: JUnitOutputFormatter, suiteName: string) =
|
||||||
|
formatter.stream.writeLine("\t<testsuite name=\"$1\">" % xmlEscape(suiteName))
|
||||||
|
|
||||||
|
method testStarted*(formatter: JUnitOutputFormatter, testName: string) =
|
||||||
|
formatter.testErrors.setLen(0)
|
||||||
|
formatter.testStackTrace.setLen(0)
|
||||||
|
formatter.testStartTime = epochTime()
|
||||||
|
|
||||||
|
method failureOccurred*(formatter: JUnitOutputFormatter, checkpoints: seq[string], stackTrace: string) =
|
||||||
|
## ``stackTrace`` is provided only if the failure occurred due to an exception.
|
||||||
|
## ``checkpoints`` is never ``nil``.
|
||||||
|
formatter.testErrors.add(checkpoints)
|
||||||
|
if stackTrace.len > 0:
|
||||||
|
formatter.testStackTrace = stackTrace
|
||||||
|
|
||||||
|
method testEnded*(formatter: JUnitOutputFormatter, testResult: TestResult) =
|
||||||
|
let time = epochTime() - formatter.testStartTime
|
||||||
|
let timeStr = time.formatFloat(ffDecimal, precision = 8)
|
||||||
|
formatter.stream.writeLine("\t\t<testcase name=\"$#\" time=\"$#\">" % [xmlEscape(testResult.testName), timeStr])
|
||||||
|
case testResult.status:
|
||||||
|
of OK:
|
||||||
|
discard
|
||||||
|
of SKIPPED:
|
||||||
|
formatter.stream.writeLine("<skipped />")
|
||||||
|
of FAILED:
|
||||||
|
let failureMsg = if formatter.testStackTrace.len > 0 and
|
||||||
|
formatter.testErrors.len > 0:
|
||||||
|
xmlEscape(formatter.testErrors[^1])
|
||||||
|
elif formatter.testErrors.len > 0:
|
||||||
|
xmlEscape(formatter.testErrors[0])
|
||||||
|
else: "The test failed without outputting an error"
|
||||||
|
|
||||||
|
var errs = ""
|
||||||
|
if formatter.testErrors.len > 1:
|
||||||
|
var startIdx = if formatter.testStackTrace.len > 0: 0 else: 1
|
||||||
|
var endIdx = if formatter.testStackTrace.len > 0: formatter.testErrors.len - 2
|
||||||
|
else: formatter.testErrors.len - 1
|
||||||
|
|
||||||
|
for errIdx in startIdx..endIdx:
|
||||||
|
if errs.len > 0:
|
||||||
|
errs.add("\n")
|
||||||
|
errs.add(xmlEscape(formatter.testErrors[errIdx]))
|
||||||
|
|
||||||
|
if formatter.testStackTrace.len > 0:
|
||||||
|
formatter.stream.writeLine("\t\t\t<error message=\"$#\">$#</error>" % [failureMsg, xmlEscape(formatter.testStackTrace)])
|
||||||
|
if errs.len > 0:
|
||||||
|
formatter.stream.writeLine("\t\t\t<system-err>$#</system-err>" % errs)
|
||||||
|
else:
|
||||||
|
formatter.stream.writeLine("\t\t\t<failure message=\"$#\">$#</failure>" % [failureMsg, errs])
|
||||||
|
|
||||||
|
formatter.stream.writeLine("\t\t</testcase>")
|
||||||
|
|
||||||
|
method suiteEnded*(formatter: JUnitOutputFormatter) =
|
||||||
|
formatter.stream.writeLine("\t</testsuite>")
|
||||||
|
|
||||||
|
proc glob(matcher, filter: string): bool =
|
||||||
|
## Globbing using a single `*`. Empty `filter` matches everything.
|
||||||
|
if filter.len == 0:
|
||||||
|
return true
|
||||||
|
|
||||||
|
if not filter.contains('*'):
|
||||||
|
return matcher == filter
|
||||||
|
|
||||||
|
let beforeAndAfter = filter.split('*', maxsplit=1)
|
||||||
|
if beforeAndAfter.len == 1:
|
||||||
|
# "foo*"
|
||||||
|
return matcher.startswith(beforeAndAfter[0])
|
||||||
|
|
||||||
|
if matcher.len < filter.len - 1:
|
||||||
|
return false # "12345" should not match "123*345"
|
||||||
|
|
||||||
|
return matcher.startsWith(beforeAndAfter[0]) and matcher.endsWith(beforeAndAfter[1])
|
||||||
|
|
||||||
|
proc matchFilter(suiteName, testName, filter: string): bool =
|
||||||
|
if filter == "":
|
||||||
|
return true
|
||||||
|
if testName == filter:
|
||||||
|
# corner case for tests containing "::" in their name
|
||||||
|
return true
|
||||||
|
let suiteAndTestFilters = filter.split("::", maxsplit=1)
|
||||||
|
|
||||||
|
if suiteAndTestFilters.len == 1:
|
||||||
|
# no suite specified
|
||||||
|
let test_f = suiteAndTestFilters[0]
|
||||||
|
return glob(testName, test_f)
|
||||||
|
|
||||||
|
return glob(suiteName, suiteAndTestFilters[0]) and glob(testName, suiteAndTestFilters[1])
|
||||||
|
|
||||||
|
when defined(testing): export matchFilter
|
||||||
|
|
||||||
|
proc shouldRun(currentSuiteName, testName: string): bool =
|
||||||
|
## Check if a test should be run by matching suiteName and testName against
|
||||||
|
## test filters.
|
||||||
|
if testsFilters.len == 0:
|
||||||
|
return true
|
||||||
|
|
||||||
|
for f in testsFilters:
|
||||||
|
if matchFilter(currentSuiteName, testName, f):
|
||||||
|
return true
|
||||||
|
|
||||||
|
return false
|
||||||
|
|
||||||
|
proc ensureInitialized() =
|
||||||
|
if formatters.len == 0:
|
||||||
|
formatters = @[OutputFormatter(defaultConsoleFormatter())]
|
||||||
|
|
||||||
|
if not disabledParamFiltering and not testsFilters.isValid:
|
||||||
|
testsFilters.init()
|
||||||
|
when declared(paramCount):
|
||||||
|
# Read tests to run from the command line.
|
||||||
|
for i in 1 .. paramCount():
|
||||||
|
testsFilters.incl(paramStr(i))
|
||||||
|
|
||||||
|
proc suiteStarted(name: string) =
|
||||||
|
when paralleliseTests:
|
||||||
|
repeatableSync() # wait for any independent tests from the threadpool before starting the suite
|
||||||
|
for formatter in formatters:
|
||||||
|
formatter.suiteStarted(name)
|
||||||
|
|
||||||
|
proc suiteEnded() =
|
||||||
|
when paralleliseTests:
|
||||||
|
repeatableSync() # wait for a suite's tests from the threadpool before moving on to the next suite
|
||||||
|
for formatter in formatters:
|
||||||
|
formatter.suiteEnded()
|
||||||
|
|
||||||
|
proc testStarted(name: string) =
|
||||||
|
for formatter in formatters:
|
||||||
|
formatter.testStarted(name)
|
||||||
|
|
||||||
|
proc testEnded(testResult: TestResult) =
|
||||||
|
for formatter in formatters:
|
||||||
|
when paralleliseTests:
|
||||||
|
withLock outputLock:
|
||||||
|
formatter.testEnded(testResult)
|
||||||
|
else:
|
||||||
|
formatter.testEnded(testResult)
|
||||||
|
|
||||||
|
template suite*(name, body) {.dirty.} =
|
||||||
|
## Declare a test suite identified by `name` with optional ``setup``
|
||||||
|
## and/or ``teardown`` section.
|
||||||
|
##
|
||||||
|
## A test suite is a series of one or more related tests sharing a
|
||||||
|
## common fixture (``setup``, ``teardown``). The fixture is executed
|
||||||
|
## for EACH test.
|
||||||
|
##
|
||||||
|
## .. code-block:: nim
|
||||||
|
## suite "test suite for addition":
|
||||||
|
## setup:
|
||||||
|
## let result = 4
|
||||||
|
##
|
||||||
|
## test "2 + 2 = 4":
|
||||||
|
## check(2+2 == result)
|
||||||
|
##
|
||||||
|
## test "(2 + -2) != 4":
|
||||||
|
## check(2 + -2 != result)
|
||||||
|
##
|
||||||
|
## # No teardown needed
|
||||||
|
##
|
||||||
|
## The suite will run the individual test cases in the order in which
|
||||||
|
## they were listed. With default global settings the above code prints:
|
||||||
|
##
|
||||||
|
## .. code-block::
|
||||||
|
##
|
||||||
|
## [Suite] test suite for addition
|
||||||
|
## [OK] 2 + 2 = 4
|
||||||
|
## [OK] (2 + -2) != 4
|
||||||
|
bind formatters, ensureInitialized, suiteStarted, suiteEnded
|
||||||
|
|
||||||
|
block:
|
||||||
|
template setup(setupBody: untyped) {.dirty, used.} =
|
||||||
|
var testSetupIMPLFlag {.used.} = true
|
||||||
|
template testSetupIMPL: untyped {.dirty.} = setupBody
|
||||||
|
|
||||||
|
template teardown(teardownBody: untyped) {.dirty, used.} =
|
||||||
|
var testTeardownIMPLFlag {.used.} = true
|
||||||
|
template testTeardownIMPL: untyped {.dirty.} = teardownBody
|
||||||
|
|
||||||
|
let testSuiteName {.used.} = name
|
||||||
|
|
||||||
|
ensureInitialized()
|
||||||
|
try:
|
||||||
|
suiteStarted(name)
|
||||||
|
body
|
||||||
|
finally:
|
||||||
|
suiteEnded()
|
||||||
|
|
||||||
|
template exceptionTypeName(e: typed): string = $e.name
|
||||||
|
|
||||||
|
template test*(name, body) =
|
||||||
|
## Define a single test case identified by `name`.
|
||||||
|
##
|
||||||
|
## .. code-block:: nim
|
||||||
|
##
|
||||||
|
## test "roses are red":
|
||||||
|
## let roses = "red"
|
||||||
|
## check(roses == "red")
|
||||||
|
##
|
||||||
|
## The above code outputs:
|
||||||
|
##
|
||||||
|
## .. code-block::
|
||||||
|
##
|
||||||
|
## [OK] roses are red
|
||||||
|
bind shouldRun, checkpoints, formatters, ensureInitialized, testStarted, testEnded, exceptionTypeName
|
||||||
|
|
||||||
|
# `gensym` can't be in here because it's not a first-class pragma
|
||||||
|
when paralleliseTests:
|
||||||
|
{.pragma: testrunner, gcsafe.}
|
||||||
|
else:
|
||||||
|
{.pragma: testrunner.}
|
||||||
|
|
||||||
|
proc runTest(testSuiteName: string): int {.gensym, testrunner.} =
|
||||||
|
# when running tests in parallel, the only place we can use
|
||||||
|
# addOutputFormatter() is in a suite's setup(), so we need to run it before
|
||||||
|
# ensureInitialized()
|
||||||
|
when declared(testSetupIMPLFlag):
|
||||||
|
testSetupIMPL()
|
||||||
|
|
||||||
|
ensureInitialized()
|
||||||
|
|
||||||
|
if shouldRun(testSuiteName, name):
|
||||||
|
checkpoints = @[]
|
||||||
|
var testStatusIMPL {.inject.} = OK
|
||||||
|
|
||||||
|
testStarted(name)
|
||||||
|
|
||||||
|
try:
|
||||||
|
body
|
||||||
|
except:
|
||||||
|
when not defined(js):
|
||||||
|
let e = getCurrentException()
|
||||||
|
let eTypeDesc = "[" & exceptionTypeName(e) & "]"
|
||||||
|
checkpoint("Unhandled exception: " & getCurrentExceptionMsg() & " " & eTypeDesc)
|
||||||
|
var stackTrace {.inject.} = e.getStackTrace()
|
||||||
|
fail()
|
||||||
|
|
||||||
|
finally:
|
||||||
|
if testStatusIMPL == FAILED:
|
||||||
|
programResult += 1
|
||||||
|
let testResult = TestResult(
|
||||||
|
suiteName: testSuiteName,
|
||||||
|
testName: name,
|
||||||
|
status: testStatusIMPL
|
||||||
|
)
|
||||||
|
testEnded(testResult)
|
||||||
|
checkpoints = @[]
|
||||||
|
# when running tests in parallel, "formatters" manipulation may occur in
|
||||||
|
# teardown(), so it needs to be after testEnded()
|
||||||
|
when declared(testTeardownIMPLFlag):
|
||||||
|
testTeardownIMPL()
|
||||||
|
|
||||||
|
let optionalTestSuiteName = when declared(testSuiteName): testSuiteName else: ""
|
||||||
|
when paralleliseTests:
|
||||||
|
flowVars.add(spawn runTest(optionalTestSuiteName))
|
||||||
|
else:
|
||||||
|
discard runTest(optionalTestSuiteName)
|
||||||
|
|
||||||
|
proc checkpoint*(msg: string) =
|
||||||
|
## Set a checkpoint identified by `msg`. Upon test failure all
|
||||||
|
## checkpoints encountered so far are printed out. Example:
|
||||||
|
##
|
||||||
|
## .. code-block:: nim
|
||||||
|
##
|
||||||
|
## checkpoint("Checkpoint A")
|
||||||
|
## check((42, "the Answer to life and everything") == (1, "a"))
|
||||||
|
## checkpoint("Checkpoint B")
|
||||||
|
##
|
||||||
|
## outputs "Checkpoint A" once it fails.
|
||||||
|
checkpoints.add(msg)
|
||||||
|
# TODO: add support for something like SCOPED_TRACE from Google Test
|
||||||
|
|
||||||
|
template fail* =
|
||||||
|
## Print out the checkpoints encountered so far and quit if ``abortOnError``
|
||||||
|
## is true. Otherwise, erase the checkpoints and indicate the test has
|
||||||
|
## failed (change exit code and test status). This template is useful
|
||||||
|
## for debugging, but is otherwise mostly used internally. Example:
|
||||||
|
##
|
||||||
|
## .. code-block:: nim
|
||||||
|
##
|
||||||
|
## checkpoint("Checkpoint A")
|
||||||
|
## complicatedProcInThread()
|
||||||
|
## fail()
|
||||||
|
##
|
||||||
|
## outputs "Checkpoint A" before quitting.
|
||||||
|
bind ensureInitialized
|
||||||
|
|
||||||
|
when declared(testStatusIMPL):
|
||||||
|
testStatusIMPL = FAILED
|
||||||
|
else:
|
||||||
|
programResult += 1
|
||||||
|
|
||||||
|
ensureInitialized()
|
||||||
|
|
||||||
|
# var stackTrace: string = nil
|
||||||
|
for formatter in formatters:
|
||||||
|
when declared(stackTrace):
|
||||||
|
formatter.failureOccurred(checkpoints, stackTrace)
|
||||||
|
else:
|
||||||
|
formatter.failureOccurred(checkpoints, "")
|
||||||
|
|
||||||
|
when not defined(ECMAScript):
|
||||||
|
if abortOnError:
|
||||||
|
when declared(testStatusIMPL):
|
||||||
|
# this wasn't incremented yet, because it's normally incremented in the
|
||||||
|
# "test" template, but we're exiting earlier here
|
||||||
|
programResult += 1
|
||||||
|
quit(programResult)
|
||||||
|
|
||||||
|
checkpoints = @[]
|
||||||
|
|
||||||
|
template skip* =
|
||||||
|
## Mark the test as skipped. Should be used directly
|
||||||
|
## in case when it is not possible to perform test
|
||||||
|
## for reasons depending on outer environment,
|
||||||
|
## or certain application logic conditions or configurations.
|
||||||
|
## The test code is still executed.
|
||||||
|
##
|
||||||
|
## .. code-block:: nim
|
||||||
|
##
|
||||||
|
## if not isGLConextCreated():
|
||||||
|
## skip()
|
||||||
|
bind checkpoints
|
||||||
|
|
||||||
|
testStatusIMPL = SKIPPED
|
||||||
|
checkpoints = @[]
|
||||||
|
|
||||||
|
macro check*(conditions: untyped): untyped =
|
||||||
|
## Verify if a statement or a list of statements is true.
|
||||||
|
## A helpful error message and set checkpoints are printed out on
|
||||||
|
## failure (if ``outputLevel`` is not ``PRINT_NONE``).
|
||||||
|
## Example:
|
||||||
|
##
|
||||||
|
## .. code-block:: nim
|
||||||
|
##
|
||||||
|
## import strutils
|
||||||
|
##
|
||||||
|
## check("AKB48".toLowerAscii() == "akb48")
|
||||||
|
##
|
||||||
|
## let teams = {'A', 'K', 'B', '4', '8'}
|
||||||
|
##
|
||||||
|
## check:
|
||||||
|
## "AKB48".toLowerAscii() == "akb48"
|
||||||
|
## 'C' in teams
|
||||||
|
let checked = callsite()[1]
|
||||||
|
|
||||||
|
template asgn(a: untyped, value: typed) =
|
||||||
|
var a = value # XXX: we need "var: var" here in order to
|
||||||
|
# preserve the semantics of var params
|
||||||
|
|
||||||
|
template print(name: untyped, value: typed) =
|
||||||
|
when compiles(string($value)):
|
||||||
|
checkpoint(name & " was " & $value)
|
||||||
|
|
||||||
|
proc inspectArgs(exp: NimNode): tuple[assigns, check, printOuts: NimNode] =
|
||||||
|
result.check = copyNimTree(exp)
|
||||||
|
result.assigns = newNimNode(nnkStmtList)
|
||||||
|
result.printOuts = newNimNode(nnkStmtList)
|
||||||
|
|
||||||
|
var counter = 0
|
||||||
|
|
||||||
|
if exp[0].kind == nnkIdent and
|
||||||
|
$exp[0] in ["not", "in", "notin", "==", "<=",
|
||||||
|
">=", "<", ">", "!=", "is", "isnot"]:
|
||||||
|
|
||||||
|
for i in 1 ..< exp.len:
|
||||||
|
if exp[i].kind notin nnkLiterals:
|
||||||
|
inc counter
|
||||||
|
let argStr = exp[i].toStrLit
|
||||||
|
let paramAst = exp[i]
|
||||||
|
if exp[i].kind == nnkIdent:
|
||||||
|
result.printOuts.add getAst(print(argStr, paramAst))
|
||||||
|
if exp[i].kind in nnkCallKinds + { nnkDotExpr, nnkBracketExpr }:
|
||||||
|
let callVar = newIdentNode(":c" & $counter)
|
||||||
|
result.assigns.add getAst(asgn(callVar, paramAst))
|
||||||
|
result.check[i] = callVar
|
||||||
|
result.printOuts.add getAst(print(argStr, callVar))
|
||||||
|
if exp[i].kind == nnkExprEqExpr:
|
||||||
|
# ExprEqExpr
|
||||||
|
# Ident !"v"
|
||||||
|
# IntLit 2
|
||||||
|
result.check[i] = exp[i][1]
|
||||||
|
if exp[i].typekind notin {ntyTypeDesc}:
|
||||||
|
let arg = newIdentNode(":p" & $counter)
|
||||||
|
result.assigns.add getAst(asgn(arg, paramAst))
|
||||||
|
result.printOuts.add getAst(print(argStr, arg))
|
||||||
|
if exp[i].kind != nnkExprEqExpr:
|
||||||
|
result.check[i] = arg
|
||||||
|
else:
|
||||||
|
result.check[i][1] = arg
|
||||||
|
|
||||||
|
case checked.kind
|
||||||
|
of nnkCallKinds:
|
||||||
|
|
||||||
|
let (assigns, check, printOuts) = inspectArgs(checked)
|
||||||
|
let lineinfo = newStrLitNode(checked.lineinfo)
|
||||||
|
let callLit = checked.toStrLit
|
||||||
|
result = quote do:
|
||||||
|
block:
|
||||||
|
`assigns`
|
||||||
|
if not `check`:
|
||||||
|
checkpoint(`lineinfo` & ": Check failed: " & `callLit`)
|
||||||
|
`printOuts`
|
||||||
|
fail()
|
||||||
|
|
||||||
|
of nnkStmtList:
|
||||||
|
result = newNimNode(nnkStmtList)
|
||||||
|
for node in checked:
|
||||||
|
if node.kind != nnkCommentStmt:
|
||||||
|
result.add(newCall(!"check", node))
|
||||||
|
|
||||||
|
else:
|
||||||
|
let lineinfo = newStrLitNode(checked.lineinfo)
|
||||||
|
let callLit = checked.toStrLit
|
||||||
|
|
||||||
|
result = quote do:
|
||||||
|
if not `checked`:
|
||||||
|
checkpoint(`lineinfo` & ": Check failed: " & `callLit`)
|
||||||
|
fail()
|
||||||
|
|
||||||
|
template require*(conditions: untyped) =
|
||||||
|
## Same as `check` except any failed test causes the program to quit
|
||||||
|
## immediately. Any teardown statements are not executed and the failed
|
||||||
|
## test output is not generated.
|
||||||
|
let savedAbortOnError = abortOnError
|
||||||
|
block:
|
||||||
|
abortOnError = true
|
||||||
|
check conditions
|
||||||
|
abortOnError = savedAbortOnError
|
||||||
|
|
||||||
|
macro expect*(exceptions: varargs[typed], body: untyped): untyped =
|
||||||
|
## Test if `body` raises an exception found in the passed `exceptions`.
|
||||||
|
## The test passes if the raised exception is part of the acceptable
|
||||||
|
## exceptions. Otherwise, it fails.
|
||||||
|
## Example:
|
||||||
|
##
|
||||||
|
## .. code-block:: nim
|
||||||
|
##
|
||||||
|
## import math, random
|
||||||
|
## proc defectiveRobot() =
|
||||||
|
## randomize()
|
||||||
|
## case random(1..4)
|
||||||
|
## of 1: raise newException(OSError, "CANNOT COMPUTE!")
|
||||||
|
## of 2: discard parseInt("Hello World!")
|
||||||
|
## of 3: raise newException(IOError, "I can't do that Dave.")
|
||||||
|
## else: assert 2 + 2 == 5
|
||||||
|
##
|
||||||
|
## expect IOError, OSError, ValueError, AssertionError:
|
||||||
|
## defectiveRobot()
|
||||||
|
let exp = callsite()
|
||||||
|
template expectBody(errorTypes, lineInfoLit, body): NimNode {.dirty.} =
|
||||||
|
try:
|
||||||
|
body
|
||||||
|
checkpoint(lineInfoLit & ": Expect Failed, no exception was thrown.")
|
||||||
|
fail()
|
||||||
|
except errorTypes:
|
||||||
|
discard
|
||||||
|
except:
|
||||||
|
checkpoint(lineInfoLit & ": Expect Failed, unexpected exception was thrown.")
|
||||||
|
fail()
|
||||||
|
|
||||||
|
var body = exp[exp.len - 1]
|
||||||
|
|
||||||
|
var errorTypes = newNimNode(nnkBracket)
|
||||||
|
for i in countup(1, exp.len - 2):
|
||||||
|
errorTypes.add(exp[i])
|
||||||
|
|
||||||
|
result = getAst(expectBody(errorTypes, exp.lineinfo, body))
|
||||||
|
|
||||||
|
proc disableParamFiltering* =
|
||||||
|
## disables filtering tests with the command line params
|
||||||
|
disabledParamFiltering = true
|
||||||
|
|
@ -0,0 +1,14 @@
|
||||||
|
mode = ScriptMode.Verbose
|
||||||
|
|
||||||
|
version = "0.0.1"
|
||||||
|
author = "Ștefan Talpalaru"
|
||||||
|
description = "unittest fork with support for parallel test execution"
|
||||||
|
license = "MIT"
|
||||||
|
requires "nim >= 0.19.4"
|
||||||
|
|
||||||
|
task test, "Run tests":
|
||||||
|
for f in listFiles("tests"):
|
||||||
|
if f.len > 4 and f[^4..^1] == ".nim":
|
||||||
|
exec "nim c -r -f --hints:off --verbosity:0 " & f
|
||||||
|
rmFile(f[0..^5].toExe())
|
||||||
|
|
||||||
Loading…
Reference in New Issue