Converted under_scores to CamelCase.
This commit is contained in:
Joey Payne
parent
210290b38c
commit
8a9ab60118
3 changed files with 198 additions and 198 deletions
42
README.md
42
README.md
|
|
@ -7,7 +7,7 @@ Einheit is a Nim unit testing library inspired by Python's unit tests. Nim's uni
|
|||
The benefit of the macro style I chose means that you can document your tests nicely as well :)
|
||||
|
||||
### Description
|
||||
test_suite is a compile-time macro that allows a user to easily define tests and run them.
|
||||
testSuite is a compile-time macro that allows a user to easily define tests and run them.
|
||||
|
||||
Methods are used for inheritance, so if you want to derive a test suite, then you have to make sure the base suite uses methods for the tests that you want to derive.
|
||||
|
||||
|
|
@ -17,7 +17,7 @@ A special proc/method is called setup(). The macro will inject this method/proc
|
|||
|
||||
Test methods/procs to be run are prefixed with "test" in the method/proc name. This is so that you can write tests that call procs that do other things and won't be run as a test.
|
||||
|
||||
For each suite method/proc, an implicit variable called "self" is added. This lets you access the test_suite in an OO kind of way.
|
||||
For each suite method/proc, an implicit variable called "self" is added. This lets you access the testSuite in an OO kind of way.
|
||||
|
||||
### Installation
|
||||
|
||||
|
|
@ -32,41 +32,41 @@ nimble install einheit
|
|||
```nim
|
||||
import einheit
|
||||
|
||||
test_suite SuiteName of TestSuite:
|
||||
testSuite SuiteName of TestSuite:
|
||||
|
||||
var
|
||||
suite_var: string
|
||||
test_obj: int
|
||||
suiteVar: string
|
||||
testObj: int
|
||||
|
||||
method setup()=
|
||||
## do setup code here
|
||||
self.suite_var = "Testing"
|
||||
self.test_obj = 90
|
||||
self.suiteVar = "Testing"
|
||||
self.testObj = 90
|
||||
|
||||
method test_adding_string()=
|
||||
## adds a string to the suite_var
|
||||
self.suite_var &= " 123"
|
||||
self.assert_equal(self.suite_var, "Testing 123")
|
||||
method testAddingString()=
|
||||
## adds a string to the suiteVar
|
||||
self.suiteVar &= " 123"
|
||||
self.assertEqual(self.suiteVar, "Testing 123")
|
||||
|
||||
proc raises_os()=
|
||||
proc raisesOs()=
|
||||
# This proc won't be invoked as a test, it must begin with "test" in lowercase
|
||||
raise newException(OSError, "Oh no! OS malfunction!")
|
||||
|
||||
method test_raises()=
|
||||
method testRaises()=
|
||||
# Two ways of asserting
|
||||
self.assert_raises OSError:
|
||||
self.raises_os()
|
||||
self.assertRaises OSError:
|
||||
self.raisesOs()
|
||||
|
||||
self.assert_raises(OSError, self.raises_os())
|
||||
self.assertRaises(OSError, self.raisesOs())
|
||||
|
||||
method test_test_obj()=
|
||||
self.assert_true(self.test_obj == 90)
|
||||
method testTestObj()=
|
||||
self.assertTrue(self.testObj == 90)
|
||||
|
||||
method test_more_more()=
|
||||
self.assert_false("String" != "String")
|
||||
method testMoreMore()=
|
||||
self.assertFalse("String" != "String")
|
||||
|
||||
when isMainModule:
|
||||
einheit.run_tests()
|
||||
einheit.runTests()
|
||||
```
|
||||
|
||||
You can also find examples in the [test.nim](test.nim) file, including inheritance.
|
||||
|
|
|
|||
278
einheit.nim
278
einheit.nim
|
|
@ -7,12 +7,12 @@
|
|||
##
|
||||
## .. code:: nim
|
||||
##
|
||||
## test_suite UnitTests:
|
||||
## proc this_is_a_test()=
|
||||
## self.assert_equals(1, 1)
|
||||
## self.assert_true(2 != 3)
|
||||
## self.assert_false(3 == 4)
|
||||
## self.assert_raises(OSError, newException(OSError, "OS is exploding!"))
|
||||
## testSuite UnitTests:
|
||||
## proc thisIsATest()=
|
||||
## self.assertEquals(1, 1)
|
||||
## self.assertTrue(2 != 3)
|
||||
## self.assertFalse(3 == 4)
|
||||
## self.assertRaises(OSError, newException(OSError, "OS is exploding!"))
|
||||
##
|
||||
import macros
|
||||
import strutils
|
||||
|
|
@ -24,17 +24,17 @@ type
|
|||
TestSuite = ref object of RootObj
|
||||
## The base TestSuite
|
||||
name: string
|
||||
current_test_name: string
|
||||
tests_passed: int
|
||||
num_tests: int
|
||||
currentTestName: string
|
||||
testsPassed: int
|
||||
numTests: int
|
||||
|
||||
TestAssertError = object of Exception
|
||||
## assert_true and other assert_* statements will raise
|
||||
## assertTrue and other assert_* statements will raise
|
||||
## this exception when the condition fails
|
||||
line_number: int
|
||||
file_name: string
|
||||
code_snip: string
|
||||
test_name: string
|
||||
lineNumber: int
|
||||
fileName: string
|
||||
codeSnip: string
|
||||
testName: string
|
||||
|
||||
# -- Methods for the TestSuite base --
|
||||
|
||||
|
|
@ -42,19 +42,19 @@ method setup*(suite: TestSuite)=
|
|||
## Base method for setup code
|
||||
discard
|
||||
|
||||
method run_tests*(suite: TestSuite)=
|
||||
method runTests*(suite: TestSuite)=
|
||||
## Base method for running tests
|
||||
discard
|
||||
|
||||
# ------------------------------------
|
||||
|
||||
|
||||
template return_exception(name, test_name, snip, vals)=
|
||||
template returnException(name, testName, snip, vals)=
|
||||
## private template for raising an exception
|
||||
let pos = instantiationInfo(fullpaths=true)
|
||||
let pos_rel = instantiationInfo()
|
||||
let posRel = instantiationInfo()
|
||||
var
|
||||
filename = pos_rel.filename
|
||||
filename = posRel.filename
|
||||
line = pos.line
|
||||
var message = "\n"
|
||||
message &= " Condition: $2($1)\n".format(snip.replace("\n","").strip(), name)
|
||||
|
|
@ -62,49 +62,49 @@ template return_exception(name, test_name, snip, vals)=
|
|||
message &= " Location: $1; line $2".format(filename, line)
|
||||
|
||||
var exc = newException(TestAssertError, message)
|
||||
exc.file_name = filename
|
||||
exc.line_number = line
|
||||
exc.code_snip = snip
|
||||
exc.test_name = test_name
|
||||
exc.fileName = filename
|
||||
exc.lineNumber = line
|
||||
exc.codeSnip = snip
|
||||
exc.testName = testName
|
||||
raise exc
|
||||
|
||||
# --------------------------- Templates for assertion --------------------------------------
|
||||
|
||||
template assert_equal*(self: TestSuite, lhs: untyped, rhs: untyped): untyped {.immediate.}=
|
||||
template assertEqual*(self: TestSuite, lhs: untyped, rhs: untyped): untyped {.immediate.}=
|
||||
## Raises a TestAssertError when the lhs and the rhs are not equal.
|
||||
if (lhs) != (rhs):
|
||||
var snip = astToStr(lhs) & ", " & astToStr(rhs)
|
||||
|
||||
var
|
||||
vals = "$3 == $1; $1 != $2".format(lhs, rhs, astToStr(lhs))
|
||||
test_name = self.current_test_name
|
||||
testName = self.currentTestName
|
||||
|
||||
return_exception("assert_true", test_name, snip, vals)
|
||||
returnException("assertTrue", testName, snip, vals)
|
||||
|
||||
template assert_true*(self: TestSuite, code: untyped): untyped {.immediate.}=
|
||||
template assertTrue*(self: TestSuite, code: untyped): untyped {.immediate.}=
|
||||
## Raises a TestAssertError when the code is false.
|
||||
if not code:
|
||||
var snip = astToStr(code)
|
||||
|
||||
var
|
||||
vals = "($1) == $2".format(snip, code)
|
||||
test_name = self.current_test_name
|
||||
testName = self.currentTestName
|
||||
|
||||
return_exception("assert_true", test_name, snip, vals)
|
||||
returnException("assertTrue", testName, snip, vals)
|
||||
|
||||
template assert_false*(self: TestSuite, code: untyped): untyped {.immediate.}=
|
||||
template assertFalse*(self: TestSuite, code: untyped): untyped {.immediate.}=
|
||||
## Raises a TestAssertError when the code is true.
|
||||
if code:
|
||||
var snip = astToStr(code)
|
||||
|
||||
var
|
||||
vals = "($1) == $2".format(snip, code)
|
||||
test_name = self.current_test_name
|
||||
testName = self.currentTestName
|
||||
|
||||
return_exception("assert_false", test_name, snip, vals)
|
||||
returnException("assertFalse", testName, snip, vals)
|
||||
|
||||
|
||||
template assert_raises*(self: TestSuite, error: untyped, code: untyped): untyped {.immediate.}=
|
||||
template assertRaises*(self: TestSuite, error: Exception, code: untyped): untyped {.immediate.}=
|
||||
## Raises a TestAssertError when the exception "error" is
|
||||
## not thrown in the code
|
||||
try:
|
||||
|
|
@ -112,9 +112,9 @@ template assert_raises*(self: TestSuite, error: untyped, code: untyped): untyped
|
|||
var
|
||||
snip = astToStr(code)
|
||||
vals = "No Exception Raised"
|
||||
test_name = self.current_test_name
|
||||
testName = self.currentTestName
|
||||
|
||||
return_exception("assert_raises", test_name, snip, vals)
|
||||
returnException("assertRaises", testName, snip, vals)
|
||||
|
||||
except error:
|
||||
discard
|
||||
|
|
@ -124,9 +124,9 @@ template assert_raises*(self: TestSuite, error: untyped, code: untyped): untyped
|
|||
var
|
||||
snip = astToStr(code)
|
||||
vals = "Exception != $1".format(astToStr(error))
|
||||
test_name = self.current_test_name
|
||||
testName = self.currentTestName
|
||||
|
||||
return_exception("assert_raises", test_name, snip, vals)
|
||||
returnException("assertRaises", testName, snip, vals)
|
||||
|
||||
discard
|
||||
|
||||
|
|
@ -134,9 +134,9 @@ template assert_raises*(self: TestSuite, error: untyped, code: untyped): untyped
|
|||
|
||||
|
||||
# A list to hold all test suites that are created
|
||||
var test_suites: seq[TestSuite] = @[]
|
||||
var testSuites: seq[TestSuite] = @[]
|
||||
|
||||
macro test_suite*(head: untyped, body: untyped): untyped =
|
||||
macro testSuite*(head: untyped, body: untyped): untyped =
|
||||
## Compile-time macro that allows a user to define tests and run them
|
||||
##
|
||||
## Methods are used for inheritance, so if you want to derive a test
|
||||
|
|
@ -154,36 +154,36 @@ macro test_suite*(head: untyped, body: untyped): untyped =
|
|||
## procs that do other things and won't be run as a test.
|
||||
##
|
||||
## For each suite method/proc, an implicit variable called "self"
|
||||
## is added. This lets you access the test_suite in an OO kind
|
||||
## is added. This lets you access the testSuite in an OO kind
|
||||
## of way.
|
||||
##
|
||||
## Usage:
|
||||
##
|
||||
## .. code:: nim
|
||||
##
|
||||
## test_suite SuiteName of TestSuite:
|
||||
## testSuite SuiteName of TestSuite:
|
||||
##
|
||||
## var
|
||||
## suite_var: string
|
||||
## suiteVar: string
|
||||
##
|
||||
## method setup()=
|
||||
## ## do setup code here
|
||||
## self.suite_var = "Testing"
|
||||
## self.suiteVar = "Testing"
|
||||
##
|
||||
## method test_adding_string()=
|
||||
## ## adds a string to the suite_var
|
||||
## self.suite_var &= " 123"
|
||||
## self.assert_equal(self.suite_var, "Testing 123")
|
||||
## method testAddingString()=
|
||||
## ## adds a string to the suiteVar
|
||||
## self.suiteVar &= " 123"
|
||||
## self.assertEqual(self.suiteVar, "Testing 123")
|
||||
##
|
||||
## when isMainModule:
|
||||
## einheit.run_tests()
|
||||
## einheit.runTests()
|
||||
|
||||
# object reference name inside methods.
|
||||
# ie: self, self
|
||||
let obj_reference = "self"
|
||||
var export_class: bool = false
|
||||
let objReference = "self"
|
||||
var exportClass: bool = false
|
||||
|
||||
template import_required_libs()=
|
||||
template importRequiredLibs()=
|
||||
import strutils
|
||||
when not defined(ECMAScript):
|
||||
import terminal
|
||||
|
|
@ -217,11 +217,11 @@ macro test_suite*(head: untyped, body: untyped): untyped =
|
|||
# Prefix
|
||||
# Ident !"of"
|
||||
# Ident !"RootObj"
|
||||
export_class = true
|
||||
exportClass = true
|
||||
typeName = head[1]
|
||||
baseName = head[2][1]
|
||||
elif head.kind == nnkInfix and $head[0] == "*":
|
||||
export_class = true
|
||||
exportClass = true
|
||||
typeName = head[1]
|
||||
else:
|
||||
quit "Invalid node: " & head.lispRepr
|
||||
|
|
@ -250,7 +250,7 @@ macro test_suite*(head: untyped, body: untyped): untyped =
|
|||
# StmtList
|
||||
# StrLit ...
|
||||
# MethodDef
|
||||
# Ident !"age_human_yrs"
|
||||
# Ident !"ageHumanYrs"
|
||||
# Empty
|
||||
# Empty
|
||||
# FormalParams
|
||||
|
|
@ -276,37 +276,37 @@ macro test_suite*(head: untyped, body: untyped): untyped =
|
|||
# return `baseName`(self)
|
||||
# result.add(super)
|
||||
|
||||
template set_node_name(n2, proc_name, type_name)=
|
||||
template setNodeName(n2, procName, typeName)=
|
||||
if n2.name.kind == nnkIdent:
|
||||
proc_name = $(n2.name.toStrLit())
|
||||
n2.name = ident(proc_name & type_name)
|
||||
procName = $(n2.name.toStrLit())
|
||||
n2.name = ident(procName & typeName)
|
||||
elif n2.name.kind == nnkPostFix:
|
||||
if n2.name[1].kind == nnkIdent:
|
||||
proc_name = $(n2.name[1].toStrLit())
|
||||
n2.name[1] = ident(proc_name & type_name)
|
||||
procName = $(n2.name[1].toStrLit())
|
||||
n2.name[1] = ident(procName & typeName)
|
||||
elif n2.name[1].kind == nnkAccQuoted:
|
||||
proc_name = $(n2.name[1][0].toStrLit())
|
||||
n2.name[1][0] = ident(proc_name & type_name)
|
||||
procName = $(n2.name[1][0].toStrLit())
|
||||
n2.name[1][0] = ident(procName & typeName)
|
||||
elif n2.name.kind == nnkAccQuoted:
|
||||
proc_name = $(n2.name[0].toStrLit())
|
||||
n2.name[0] = ident(proc_name & type_name)
|
||||
procName = $(n2.name[0].toStrLit())
|
||||
n2.name[0] = ident(procName & typeName)
|
||||
result.add(n2)
|
||||
|
||||
|
||||
template run_tests_proc(self, typeName, base_method, type_method)=
|
||||
method type_method(self: typeName)=
|
||||
when compiles(self.base_method()):
|
||||
self.base_method()
|
||||
template runTestsProc(self, typeName, baseMethod, typeMethod)=
|
||||
method typeMethod(self: typeName)=
|
||||
when compiles(self.baseMethod()):
|
||||
self.baseMethod()
|
||||
|
||||
method run_tests(self: typeName)=
|
||||
self.type_method()
|
||||
method runTests(self: typeName)=
|
||||
self.typeMethod()
|
||||
|
||||
var base_method_name = ident("run_tests" & $baseName.toStrLit())
|
||||
var type_method_name = ident("run_tests" & $typeName.toStrLit())
|
||||
var baseMethodName = ident("runTests" & $baseName.toStrLit())
|
||||
var typeMethodName = ident("runTests" & $typeName.toStrLit())
|
||||
|
||||
var run_tests = getAst(run_tests_proc(ident(obj_reference), typeName, base_method_name, type_method_name))
|
||||
var runTests = getAst(runTestsProc(ident(objReference), typeName, baseMethodName, typeMethodName))
|
||||
|
||||
var found_setup = false
|
||||
var foundSetup = false
|
||||
|
||||
# Make forward declarations so that function order
|
||||
# does not matter, just like in real OOP!
|
||||
|
|
@ -315,7 +315,7 @@ macro test_suite*(head: untyped, body: untyped): untyped =
|
|||
of nnkMethodDef, nnkProcDef:
|
||||
# inject `self: T` into the arguments
|
||||
let n = copyNimTree(node)
|
||||
n.params.insert(1, newIdentDefs(ident(obj_reference), typeName))
|
||||
n.params.insert(1, newIdentDefs(ident(objReference), typeName))
|
||||
# clear the body so we only get a
|
||||
# declaration
|
||||
n.body = newEmptyNode()
|
||||
|
|
@ -323,30 +323,30 @@ macro test_suite*(head: untyped, body: untyped): untyped =
|
|||
|
||||
# forward declare the inheritable method
|
||||
let n2 = copyNimTree(n)
|
||||
let type_name = $(typeName.toStrLit())
|
||||
var proc_name = ""
|
||||
let typeName = $(typeName.toStrLit())
|
||||
var procName = ""
|
||||
|
||||
set_node_name(n2, proc_name, type_name)
|
||||
setNodeName(n2, procName, typeName)
|
||||
|
||||
if proc_name == "setup":
|
||||
found_setup = true
|
||||
if procName == "setup":
|
||||
foundSetup = true
|
||||
else:
|
||||
discard
|
||||
|
||||
if not found_setup:
|
||||
template setup_proc(self, typeName, setup_proc)=
|
||||
if not foundSetup:
|
||||
template setupProc(self, typeName, setupProc)=
|
||||
method setup(self: typeName)
|
||||
method setup_proc(self: typeName)
|
||||
method setupProc(self: typeName)
|
||||
|
||||
template setup_decl(self, base_method)=
|
||||
template setupDecl(self, baseMethod)=
|
||||
method setup()=
|
||||
self.base_method()
|
||||
self.baseMethod()
|
||||
discard
|
||||
|
||||
var setup_proc_typename = ident("setup" & $typeName.toStrLit())
|
||||
var base_method_name = ident("setup" & $baseName.toStrLit())
|
||||
result.add(getAst(setup_proc(ident(obj_reference), typeName, setup_proc_typename)))
|
||||
body.add(getAst(setup_decl(ident(obj_reference), base_method_name))[0])
|
||||
var setupProcTypename = ident("setup" & $typeName.toStrLit())
|
||||
var baseMethodName = ident("setup" & $baseName.toStrLit())
|
||||
result.add(getAst(setupProc(ident(objReference), typeName, setupProcTypename)))
|
||||
body.add(getAst(setupDecl(ident(objReference), baseMethodName))[0])
|
||||
|
||||
# Iterate over the statements, adding `self: T`
|
||||
# to the parameters of functions
|
||||
|
|
@ -355,45 +355,45 @@ macro test_suite*(head: untyped, body: untyped): untyped =
|
|||
of nnkMethodDef, nnkProcDef:
|
||||
# inject `self: T` into the arguments
|
||||
let n = copyNimTree(node)
|
||||
n.params.insert(1, newIdentDefs(ident(obj_reference), typeName))
|
||||
n.params.insert(1, newIdentDefs(ident(objReference), typeName))
|
||||
|
||||
# Copy the proc or method for inheritance
|
||||
# ie: procName_ClassName()
|
||||
let n2 = copyNimTree(node)
|
||||
n2.params.insert(1, newIdentDefs(ident(obj_reference), typeName))
|
||||
n2.params.insert(1, newIdentDefs(ident(objReference), typeName))
|
||||
|
||||
let type_name = $(typeName.toStrLit())
|
||||
var proc_name = $(n2.name.toStrLit())
|
||||
var is_assignment = proc_name.contains("=")
|
||||
let typeName = $(typeName.toStrLit())
|
||||
var procName = $(n2.name.toStrLit())
|
||||
var isAssignment = procName.contains("=")
|
||||
|
||||
set_node_name(n2, proc_name, type_name)
|
||||
setNodeName(n2, procName, typeName)
|
||||
|
||||
if proc_name == "setup":
|
||||
let dot_name = newDotExpr(ident(obj_reference), ident("name"))
|
||||
let set_name = newAssignment(dot_name, newLit(typeName))
|
||||
n2.body.add(set_name)
|
||||
elif proc_name.startswith("test"):
|
||||
let proc_call = newDotExpr(ident(obj_reference),
|
||||
ident(proc_name & type_name))
|
||||
if procName == "setup":
|
||||
let dotName = newDotExpr(ident(objReference), ident("name"))
|
||||
let setName = newAssignment(dotName, newLit(typeName))
|
||||
n2.body.add(setName)
|
||||
elif procName.startswith("test"):
|
||||
let procCall = newDotExpr(ident(objReference),
|
||||
ident(procName & typeName))
|
||||
|
||||
template set_test_name(self, proc_name)=
|
||||
self.current_test_name = proc_name
|
||||
template setTestName(self, procName)=
|
||||
self.currentTestName = procName
|
||||
|
||||
template try_block(self, test_call)=
|
||||
self.num_tests += 1
|
||||
template tryBlock(self, testCall)=
|
||||
self.numTests += 1
|
||||
try:
|
||||
test_call
|
||||
styled_echo(styleBright, fgGreen, "[OK]",
|
||||
fgWhite, " ", self.current_test_name)
|
||||
self.tests_passed += 1
|
||||
testCall
|
||||
styledEcho(styleBright, fgGreen, "[OK]",
|
||||
fgWhite, " ", self.currentTestName)
|
||||
self.testsPassed += 1
|
||||
except TestAssertError:
|
||||
let e = (ref TestAssertError)(getCurrentException())
|
||||
styled_echo(styleBright,
|
||||
styledEcho(styleBright,
|
||||
fgRed, "[Failed]",
|
||||
fgWhite, " ", self.current_test_name, e.msg)
|
||||
fgWhite, " ", self.currentTestName, e.msg)
|
||||
|
||||
run_tests[0][6].add(getAst(set_test_name(ident(obj_reference), proc_name)))
|
||||
run_tests[0][6].add(getAst(try_block(ident(obj_reference), proc_call)))
|
||||
runTests[0][6].add(getAst(setTestName(ident(objReference), procName)))
|
||||
runTests[0][6].add(getAst(tryBlock(ident(objReference), procCall)))
|
||||
|
||||
# simply call the class method from here
|
||||
# proc procName=
|
||||
|
|
@ -401,11 +401,11 @@ macro test_suite*(head: untyped, body: untyped): untyped =
|
|||
var p: seq[NimNode] = @[]
|
||||
for i in 1..n.params.len-1:
|
||||
p.add(n.params[i][0])
|
||||
if is_assignment:
|
||||
let dot = newDotExpr(ident(obj_reference), ident(proc_name & type_name))
|
||||
if isAssignment:
|
||||
let dot = newDotExpr(ident(objReference), ident(procName & typeName))
|
||||
n.body = newStmtList(newAssignment(dot, p[1]))
|
||||
else:
|
||||
n.body = newStmtList(newCall(proc_name & type_name, p))
|
||||
n.body = newStmtList(newCall(procName & typeName, p))
|
||||
|
||||
result.add(n)
|
||||
|
||||
|
|
@ -438,27 +438,27 @@ macro test_suite*(head: untyped, body: untyped): untyped =
|
|||
# Ident !"int"
|
||||
# Empty
|
||||
|
||||
var type_decl: NimNode
|
||||
var typeDecl: NimNode
|
||||
|
||||
template declare_type_export(tname, bname)=
|
||||
template declareTypeExport(tname, bname)=
|
||||
type tname* = ref object of bname
|
||||
template declare_type(tname, bname)=
|
||||
template declareType(tname, bname)=
|
||||
type tname = ref object of bname
|
||||
|
||||
if baseName == nil:
|
||||
if export_class:
|
||||
type_decl = getAst(declare_type_export(typeName, TestSuite))
|
||||
if exportClass:
|
||||
typeDecl = getAst(declareTypeExport(typeName, TestSuite))
|
||||
else:
|
||||
type_decl = getAst(declare_type(typeName, TestSuite))
|
||||
typeDecl = getAst(declareType(typeName, TestSuite))
|
||||
else:
|
||||
if export_class:
|
||||
type_decl = getAst(declare_type_export(typeName, baseName))
|
||||
if exportClass:
|
||||
typeDecl = getAst(declareTypeExport(typeName, baseName))
|
||||
else:
|
||||
type_decl = getAst(declare_type(typeName, baseName))
|
||||
typeDecl = getAst(declareType(typeName, baseName))
|
||||
|
||||
# Inspect the tree structure:
|
||||
#
|
||||
# echo type_decl.treeRepr
|
||||
# echo typeDecl.treeRepr
|
||||
# --------------------
|
||||
# StmtList
|
||||
# TypeSection
|
||||
|
|
@ -471,40 +471,40 @@ macro test_suite*(head: untyped, body: untyped): untyped =
|
|||
# OfInherit
|
||||
# Ident !"RootObj"
|
||||
# Empty <= We want to replace this
|
||||
type_decl[0][0][2][0][2] = recList
|
||||
typeDecl[0][0][2][0][2] = recList
|
||||
|
||||
# insert the type declaration
|
||||
result.insert(0, type_decl)
|
||||
result.insert(0, typeDecl)
|
||||
|
||||
# insert libs needed
|
||||
result.insert(0, getAst(import_required_libs()))
|
||||
result.insert(0, getAst(importRequiredLibs()))
|
||||
|
||||
result.add(run_tests)
|
||||
result.add(runTests)
|
||||
|
||||
template add_test_suite(typeName)=
|
||||
test_suites.add(typeName())
|
||||
template addTestSuite(typeName)=
|
||||
testSuites.add(typeName())
|
||||
|
||||
result.add(getAst(add_test_suite(typeName)))
|
||||
result.add(getAst(addTestSuite(typeName)))
|
||||
|
||||
|
||||
proc run_tests*()=
|
||||
proc runTests*()=
|
||||
## The method that runs the tests. Invoke
|
||||
## after setting up all of the tests and
|
||||
## usually inside a "when isMainModule" block
|
||||
for suite in test_suites:
|
||||
for suite in testSuites:
|
||||
suite.setup()
|
||||
|
||||
styled_echo(styleBright,
|
||||
styledEcho(styleBright,
|
||||
fgYellow, "\n[Running]",
|
||||
fgWhite, " $1\n".format(suite.name))
|
||||
suite.run_tests()
|
||||
suite.runTests()
|
||||
|
||||
# Output red if tests didn't pass, green otherwise
|
||||
var color = fgGreen
|
||||
if suite.tests_passed != suite.num_tests:
|
||||
if suite.testsPassed != suite.numTests:
|
||||
color = fgRed
|
||||
|
||||
styled_echo(styleBright, color,
|
||||
"\n[", $suite.tests_passed, "/", $suite.num_tests, "]",
|
||||
styledEcho(styleBright, color,
|
||||
"\n[", $suite.testsPassed, "/", $suite.numTests, "]",
|
||||
fgWhite, " tests passed.\n")
|
||||
|
||||
|
|
|
|||
76
test.nim
76
test.nim
|
|
@ -1,69 +1,69 @@
|
|||
import einheit
|
||||
|
||||
test_suite UnitTests:
|
||||
testSuite UnitTests:
|
||||
var
|
||||
test_obj: int
|
||||
testObj: int
|
||||
|
||||
proc do_things()=
|
||||
proc doThings()=
|
||||
# This proc won't be invoked as a test
|
||||
self.test_obj = 400
|
||||
self.assert_true(self.test_obj == 400)
|
||||
self.testObj = 400
|
||||
self.assertTrue(self.testObj == 400)
|
||||
|
||||
method setup()=
|
||||
self.test_obj = 5
|
||||
self.test_obj = 90
|
||||
self.testObj = 5
|
||||
self.testObj = 90
|
||||
|
||||
method test_for_b()=
|
||||
method testForB()=
|
||||
var b = 0
|
||||
self.do_things()
|
||||
self.assert_true(4 == 4)
|
||||
self.doThings()
|
||||
self.assertTrue(4 == 4)
|
||||
|
||||
method test_for_c()=
|
||||
method testForC()=
|
||||
var c = 0
|
||||
# supposed to fail
|
||||
self.assert_equal(c, 1)
|
||||
self.assertEqual(c, 1)
|
||||
|
||||
|
||||
test_suite UnitTestsNew:
|
||||
testSuite UnitTestsNew:
|
||||
var
|
||||
test_obj: int
|
||||
testObj: int
|
||||
|
||||
method setup()=
|
||||
self.test_obj = 5
|
||||
self.test_obj = 90
|
||||
self.testObj = 5
|
||||
self.testObj = 90
|
||||
|
||||
method test_test_obj()=
|
||||
self.assert_true(self.test_obj == 90)
|
||||
method testTestObj()=
|
||||
self.assertTrue(self.testObj == 90)
|
||||
|
||||
method test_stuff()=
|
||||
self.assert_equal("Stuff", "Stuff")
|
||||
method testStuff()=
|
||||
self.assertEqual("Stuff", "Stuff")
|
||||
|
||||
method test_more()=
|
||||
self.assert_equal("String", "String")
|
||||
method testMore()=
|
||||
self.assertEqual("String", "String")
|
||||
|
||||
method test_more_more()=
|
||||
self.assert_false("String" != "String")
|
||||
method testMoreMore()=
|
||||
self.assertFalse("String" != "String")
|
||||
|
||||
|
||||
|
||||
# Inheritance!
|
||||
test_suite TestInherit of UnitTestsNew:
|
||||
testSuite TestInherit of UnitTestsNew:
|
||||
## This will call every test defined in UnitTestsNew
|
||||
|
||||
proc raises_os()=
|
||||
proc raisesOs()=
|
||||
# This proc won't be invoked as a test
|
||||
raise newException(OSError, "Oh no! OS malfunction!")
|
||||
|
||||
method test_raises()=
|
||||
method testRaises()=
|
||||
|
||||
# Two ways of asserting
|
||||
self.assert_raises OSError:
|
||||
self.raises_os()
|
||||
self.assertRaises OSError:
|
||||
self.raisesOs()
|
||||
|
||||
self.assert_raises(OSError, self.raises_os())
|
||||
self.assertRaises(OSError, self.raisesOs())
|
||||
|
||||
|
||||
test_suite MoreInheritance of TestInherit:
|
||||
testSuite MoreInheritance of TestInherit:
|
||||
|
||||
method setup()=
|
||||
# This must be called if overriding setup if you want
|
||||
|
|
@ -74,20 +74,20 @@ test_suite MoreInheritance of TestInherit:
|
|||
|
||||
# This will make one of the tests inherited from UnitTestsNew
|
||||
# fail. This is expected.
|
||||
self.test_obj = 12345
|
||||
self.testObj = 12345
|
||||
|
||||
method test_test_obj()=
|
||||
method testTestObj()=
|
||||
# This method is overwritten. To call the base method,
|
||||
# simply use
|
||||
# self.test_test_obj_UnitTestsNew()
|
||||
# self.testTestObj_UnitTestsNew()
|
||||
# However, currently this method will be run
|
||||
# IN ADDITION to the base class's method.
|
||||
# This one will pass, the other will fail
|
||||
self.assert_true(self.test_obj == 12345)
|
||||
self.assertTrue(self.testObj == 12345)
|
||||
|
||||
method test_new_obj()=
|
||||
self.assert_equal(self.test_obj, 12345)
|
||||
method testNewObj()=
|
||||
self.assertEqual(self.testObj, 12345)
|
||||
|
||||
|
||||
when isMainModule:
|
||||
run_tests()
|
||||
runTests()
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue