Added system.program_results for controlling the exit code of the program under normal circumstances

Implemented operators like +=, -=, etc for ordinals, floats and string

Programs using the UnitTest module will now report the number of failed tests as the exit code of test runs (0 for successful run)

3 files changed, 55 insertions, 11 deletions

diff --git a/lib/nimbase.h b/lib/nimbase.h
index cc0419f55..11278ccd2 100755
--- a/lib/nimbase.h
+++ b/lib/nimbase.h
@@ -331,6 +331,8 @@ typedef long long int NI64;
 typedef unsigned int NU32;
 #endif
 
+extern NI nim_program_result;
+
 typedef float NF32;
 typedef double NF64;
 typedef double NF;
diff --git a/lib/pure/unittest.nim b/lib/pure/unittest.nim
index 87c2b6ed7..6fee618b9 100644
--- a/lib/pure/unittest.nim
+++ b/lib/pure/unittest.nim
@@ -20,12 +20,14 @@ import
   macros, terminal

 

 type

-  TestStatus* = enum OK, FAILED

-  # ETestFailed* = object of ESynch

-

+  TTestStatus* = enum OK, FAILED

+  TOutputLevel* = enum PRINT_ALL, PRINT_FAILURES, PRINT_NONE

+  

 var 

   # XXX: These better be thread-local

   AbortOnError* = false

+  OutputLevel* = PRINT_ALL

+  

   checkpoints: seq[string] = @[]

 

 template TestSetupIMPL*: stmt = nil

@@ -36,20 +38,25 @@ proc shouldRun(testName: string): bool =
 

 template suite*(name: expr, body: stmt): stmt =

   block:

-    template setup(setupBody: stmt): stmt =

+    template setup*(setupBody: stmt): stmt =

       template TestSetupIMPL: stmt = setupBody

 

-    template teardown(teardownBody: stmt): stmt =

+    template teardown*(teardownBody: stmt): stmt =

       template TestTeardownIMPL: stmt = teardownBody

 

     body

 

-proc printStatus*(s: TestStatus, name: string) =

-  var color = (if s == OK: fgGreen else: fgRed)

-  styledEcho styleBright, color, "[", $s, "] ", fgWhite, name, "\n"

+proc testDone(name: string, s: TTestStatus) =

+  if s == FAILED:

+    program_result += 1

+

+  if OutputLevel != PRINT_NONE and (OutputLevel == PRINT_ALL or s == FAILED):

+    var color = (if s == OK: fgGreen else: fgRed)

+    styledEcho styleBright, color, "[", $s, "] ", fgWhite, name, "\n"

   

 template test*(name: expr, body: stmt): stmt =

-  bind shouldRun, checkPoints

+  bind shouldRun, checkpoints, testDone

+

   if shouldRun(name):

     checkpoints = @[]

     var TestStatusIMPL = OK

@@ -60,7 +67,7 @@ template test*(name: expr, body: stmt): stmt =
 

     finally:

       TestTeardownIMPL()

-      printStatus(TestStatusIMPL, name)

+      testDone name, TestStatusIMPL

 

 proc checkpoint*(msg: string) =

   checkpoints.add(msg)

@@ -85,6 +92,8 @@ macro check*(conditions: stmt): stmt =
  

     result = getAst(rewrite(e, e.lineinfo, e.toStrLit))

   

+  echo conditions.lispRepr

+

   case conditions.kind

   of nnkCall, nnkCommand, nnkMacroStmt:

     case conditions[1].kind

@@ -124,7 +133,7 @@ macro check*(conditions: stmt): stmt =
       result = standardRewrite(conditions[1])

 

   else:

-    error conditions.lineinfo & ": Malformed check statement"

+    error conditions.lineinfo & ": Malformed check statement:"

 

 template require*(conditions: stmt): stmt =

   block:

diff --git a/lib/system.nim b/lib/system.nim
index 8657efe2a..00555fa45 100755
--- a/lib/system.nim
+++ b/lib/system.nim
@@ -402,6 +402,9 @@ proc `+` *(x, y: int32): int32 {.magic: "AddI", noSideEffect.}
 proc `+` *(x, y: int64): int64 {.magic: "AddI64", noSideEffect.}
   ## Binary `+` operator for an integer.
 
+proc `+=`*[T](x, y: ordinal[T]) {.magic: "Inc", noSideEffect.}
+  ## Increments an ordinal
+
 proc `-` *(x, y: int): int {.magic: "SubI", noSideEffect.}
 proc `-` *(x, y: int8): int8 {.magic: "SubI", noSideEffect.}
 proc `-` *(x, y: int16): int16 {.magic: "SubI", noSideEffect.}
@@ -409,6 +412,9 @@ proc `-` *(x, y: int32): int32 {.magic: "SubI", noSideEffect.}
 proc `-` *(x, y: int64): int64 {.magic: "SubI64", noSideEffect.}
   ## Binary `-` operator for an integer.
 
+proc `-=`*[T](x, y: ordinal[T]) {.magic: "Dec", noSideEffect.}
+  ## Decrements an ordinal
+  
 proc `*` *(x, y: int): int {.magic: "MulI", noSideEffect.}
 proc `*` *(x, y: int8): int8 {.magic: "MulI", noSideEffect.}
 proc `*` *(x, y: int16): int16 {.magic: "MulI", noSideEffect.}
@@ -416,6 +422,10 @@ proc `*` *(x, y: int32): int32 {.magic: "MulI", noSideEffect.}
 proc `*` *(x, y: int64): int64 {.magic: "MulI64", noSideEffect.}
   ## Binary `*` operator for an integer.
 
+proc `*=`*[T](x: var ordinal[T], y: ordinal[T]) {.inline noSideEffect.} =
+  ## Binary `*=` operator for oridinals
+  x = x * y
+
 proc `div` *(x, y: int): int {.magic: "DivI", noSideEffect.}
 proc `div` *(x, y: int8): int8 {.magic: "DivI", noSideEffect.}
 proc `div` *(x, y: int16): int16 {.magic: "DivI", noSideEffect.}
@@ -569,6 +579,22 @@ proc `*` *(x, y: float): float {.magic: "MulF64", noSideEffect.}
 proc `/` *(x, y: float): float {.magic: "DivF64", noSideEffect.}
   ## computes the floating point division
 
+proc `+=` *(x: var float, y:float) {.inline noSideEffect.} =
+  ## Increments in placee a floating point number
+  x = x + y
+
+proc `-=` *(x: var float, y:float) {.inline noSideEffect.} =
+  ## Decrements in place a floating point number
+  x = x - y
+
+proc `*=` *(x: var float, y:float) {.inline noSideEffect.} =
+  ## Multiplies in place a floating point number
+  x = x * y
+
+proc `/=` *(x: var float, y:float) {.inline noSideEffect.} =
+  ## Divides in place a floating point number
+  x = x / y
+
 proc `==` *(x, y: float): bool {.magic: "EqF64", noSideEffect.}
 proc `<=` *(x, y: float): bool {.magic: "LeF64", noSideEffect.}
 proc `<`  *(x, y: float): bool {.magic: "LtF64", noSideEffect.}
@@ -717,6 +743,8 @@ proc `&` * (x: char, y: string): string {.
 proc add*(x: var string, y: char) {.magic: "AppendStrCh", noSideEffect.}
 proc add*(x: var string, y: string) {.magic: "AppendStrStr", noSideEffect.}
 
+proc `&=`* (x: var string, y: string) {.magic: "AppendStrStr", noSideEffect.}
+
 type
   TEndian* = enum ## is a type describing the endianness of a processor.
     littleEndian, bigEndian
@@ -1541,6 +1569,11 @@ const
     ## is the value that should be passed to ``quit`` to indicate
     ## failure.
 
+var program_result* {.exportc: "nim_$1".} = QuitSuccess
+  ## modify this varialbe to specify the exit code of the program
+  ## under normal circumstances. when the program is terminated
+  ## prematurelly using ``quit``, this value is ignored.
+
 proc quit*(errorcode: int = QuitSuccess) {.
   magic: "Exit", importc: "exit", noDecl, noReturn.}
   ## stops the program immediately; before stopping the program the