feat: creating a new testing library, now part of the library instead of the tests part

Author: SuperFola

String.ark

@@ -135,15 +135,15 @@
     (let _pattern_sz (len _pattern))
 
     (while (!= -1 _idx) {
+        (mut _first_segment (str:slice _out 0 _idx))
         (mut _next_segment (str:slice _out (+ _idx _pattern_sz) (- (len _out) (+ _idx _pattern_sz))))
         (set _out (+
-            (str:slice _out 0 _idx)
+            _first_segment
             _new
             _next_segment))
         (set _idx (str:find _next_segment _pattern))
         (if (!= -1 _idx)
-            (set _idx (+ _idx _pattern_sz)))
-    })
+            (set _idx (+ _idx (len _first_segment) (len _new))))})
     _out }))
 
 # @brief Join a list of elements with a given string delimiter

Testing.ark

@@ -0,0 +1,58 @@
+(let _runner (fun (_name _callable) {
+    (mut _passed 0)
+    (mut _failed 0)
+    (mut _failures [])
+
+    (let _start_time (time))
+    # run test
+    (_callable)
+    (let _end_time (time))
+
+    # no newline, yet
+    (puts _name)
+    (if (> _passed 0)
+        (puts (str:format " - {} ✅" _passed)))
+    (if (> _failed 0)
+        (puts (str:format ", {} ❌" _failed)))
+
+    (puts (str:format " in {:2.3f}ms\n" (* 1000 (- _end_time _start_time))))
+
+    (mut _i 0)
+    (let _failures_count (len _failures))
+    (while (< _i _failures_count) {
+        (print "\t" (@ _failures _i))
+        (set _i (+ 1 _i))})
+
+    [_passed _failed]}))
+
+(let _report_error (fun (_lhs _rhs _lhs_repr _rhs_repr) {
+    (set _failed (+ 1 _failed))
+    (append! _failures (str:format "{} was not equal to {}" _lhs_repr _rhs_repr))
+    (let _rhs_start (+ (len _lhs_repr) (len " was not equal to ")))
+    (let _lhs_align (len _lhs_repr))
+    (let _rhs_align (len _rhs_repr))
+    (append! _failures (str:format (+ "{: <" (toString _rhs_start) "}{:~<" (toString _rhs_align) "} {}") "|" "\\" _lhs))
+    (append! _failures (str:format (+ "{:~<" (toString _lhs_align) "} {}") "\\" _rhs))}))
+
+(let _report_success (fun () (set _passed (+ 1 _passed))))
+
+($ test:expect (_cond) {
+    (if (!= true _cond)
+        {
+            (set _failed (+ 1 _failed))
+            (append! _failures (str:format "{} was not true but {}" ($repr _cond) _cond))        }
+        (_report_success))})
+
+($ test:eq (_lhs _rhs) {
+    (if (= _lhs _rhs)
+        (_report_success)
+        (_report_error _lhs _rhs ($repr _lhs) ($repr _rhs)))})
+
+($ test:neq (_lhs _rhs) {
+    (if (!= _lhs _rhs)
+        (_report_success)
+        (_report_error _lhs _rhs ($repr _lhs) ($repr _rhs)))})
+
+($ test:suite (_name _body) {
+    (let (symcat _name "-output") (_runner ($repr _name) (fun () {_body})))
+    (let (symcat _name "-status") (= 0 (@ (symcat _name "-output") 1)))})

tests/events-tests.ark

@@ -1,40 +1,30 @@
-(import tests-tools)
-
 (import std.Events)
+(import std.Testing)
 
-(let events-tests (fun () {
-    (mut tests 0)
-    (let start-time (time))
-
-    (let em (events:manager:make))
+(let em (events:manager:make))
 
+(test:suite events {
     # _check_valid tests
-    (set tests (assert-eq true (em._check_valid (fun () ())) "check_valid" tests))
-    (set tests (assert-eq false (em._check_valid 4) "check_valid" tests))
+    (test:expect (em._check_valid (fun () ())))
+    (test:expect (not (em._check_valid 4)))
 
     # on tests
     (em.on "myType" 4)
-    (set tests (assert-eq [] em._listeners "listeners empty" tests))
+    (test:eq [] em._listeners)
     (em.on "myType" (fun (_) ()))
-    (set tests (assert-neq [] em._listeners "listeners with one element" tests))
+    (test:neq [] em._listeners)
 
     # emit tests
-    (set tests (assert-eq false (em.emit "emitType") "emit" tests))
+    (test:expect (not (em.emit "emitType")))
     (em.on "emitType" (fun (_) ()))
-    (set tests (assert-eq true (em.emit "emitType") "emit" tests))
+    (test:expect (em.emit "emitType"))
 
     # emitWith tests
-    (set tests (assert-eq false (em.emitWith 1 "emitWithType") "emitWith" tests))
+    (test:expect (not (em.emitWith 1 "emitWithType")))
     (em.on "emitWithType" (fun (_) ()))
-    (set tests (assert-eq true (em.emitWith 2 "emitWithType") "emitWith" tests))
+    (test:expect (em.emitWith 2 "emitWithType"))
 
     # removeListenersOfType
-    (set tests (assert-eq false (em.removeListenersOfType "removeType") "removeListenersOfType" tests))
+    (test:expect (not (em.removeListenersOfType "removeType")))
     (em.on "removeType" (fun (_) ()))
-    (set tests (assert-eq true (em.removeListenersOfType "removeType") "removeListenersOfType" tests))
-
-    (recap "Events tests passed" tests (- (time) start-time))
-
-    tests }))
-
-(let passed-events (events-tests))
+    (test:expect (em.removeListenersOfType "removeType"))})

tests/exceptions-tests.ark

@@ -1,26 +1,12 @@
-(import tests-tools)
-
 (import std.Exceptions)
+(import std.Testing)
 
-(let exceptions-tests (fun () {
-    (mut tests 0)
-    (let start-time (time))
-
-    (let invert (fun (x) {
-        (if (= x 0)
-            (throw "cannot divide by zero")
-            (return (/ 1 x)))}))
+(let invert (fun (x)
+    (if (= x 0)
+        (throw "cannot divide by zero")
+        (return (/ 1 x)))))
 
+(test:suite exceptions {
     (try (invert 0)
-        (fun (inverted) (assert-val false "Exception test" tests))
-        (fun (err) (set tests (assert-eq err "cannot divide by zero" "Exception test" tests))))
-
-    (try (invert 2)
-        (fun (inverted) (set tests (assert-eq inverted 0.5 "Exception test" tests)))
-        (fun (err) (assert-val false "Exception test" tests)))
-
-    (recap "Exceptions tests passed" tests (- (time) start-time))
-
-    tests }))
-
-(let passed-exceptions (exceptions-tests))
+        (fun (inverted) (test:expect false))
+        (fun (err) (test:expect (= err "cannot divide by zero"))))})

tests/functional-tests.ark

@@ -1,23 +1,13 @@
-(import tests-tools)
-
 (import std.Functional)
+(import std.Testing)
 
-(let functional-tests (fun () {
-    (mut tests 0)
-    (let start-time (time))
-
-    (let foo (fun (x) (+ x 3)))
-    (let egg (fun (y) (* y 2)))
-    (let bar (fun (x y) (- x y)))
+(let foo (fun (x) (+ x 3)))
+(let egg (fun (y) (* y 2)))
+(let bar (fun (x y) (- x y)))
 
-    (set tests (assert-eq ((compose foo egg) 5) (foo (egg 5)) "compose" tests))
-    (set tests (assert-eq ((compose egg egg) 5) (egg (egg 5)) "compose" tests))
+(test:suite functional {
+    (test:eq ((compose foo egg) 5) (foo (egg 5)))
+    (test:eq ((compose egg egg) 5) (egg (egg 5)))
     # no need to test left and right because they were already tested by the exceptions tests (throw, return)
-    (set tests (assert-eq ((flip bar 5) 6) (bar 6 5) "flip" tests))
-    (set tests (assert-eq ((flip bar 6) 5) (bar 5 6) "flip" tests))
-
-    (recap "Functional tests passed" tests (- (time) start-time))
-
-    tests }))
-
-(let passed-functional (functional-tests))
+    (test:eq ((flip bar 5) 6) (bar 6 5))
+    (test:eq ((flip bar 6) 5) (bar 5 6))})

tests/lazy-tests.ark

@@ -1,24 +1,15 @@
-(import tests-tools)
-
 (import std.Lazy)
+(import std.Testing)
 
-(let lazy-tests (fun () {
-    (mut tests 0)
-    (let start-time (time))
-
-    (let calculate_the_sun_weight (fun () (begin (sys:sleep 50) 42)))
-    (let memo (lazy:eval calculate_the_sun_weight))
+(let calculate_the_sun_weight (fun () (begin (sys:sleep 50) 42)))
+(let memo (lazy:eval calculate_the_sun_weight))
 
+(test:suite lazy {
     (mut timer-0 (time))
-    (set tests (assert-eq (memo) 42 "memoize the sun weight" tests))
-    (set tests (assert-gt (- (time) timer-0) 0.05 "lazy:eval ran the function for the first time" tests))
+    (test:eq 42 (memo))
+    # test execution time, should be long because the function wasn't memoized yet
+    (test:expect (> (- (time) timer-0) 0.050))
 
     (set timer-0 (time))
-    (set tests (assert-eq (memo) 42 "the memoized value hasn't changed" tests))
-    (set tests (assert-lt (- (time) timer-0) 0.005 "lazy:eval returned the memoized value" tests))
-
-    (recap "Lazy tests passed" tests (- (time) start-time))
-
-    tests }))
-
-(let passed-lazy (lazy-tests))
+    (test:eq 42 (memo))
+    (test:expect (< (- (time) timer-0) 0.050))})

tests/list-tests.ark

@@ -1,82 +1,72 @@
-(import tests-tools)
-
 (import std.List)
 (import std.Math :even)
+(import std.Testing)
 
-(let list-tests (fun () {
-    (mut tests 0)
-    (let start-time (time))
-
-    (let a [1 2 3])
-    (let b [4 5 6])
-    (let zipped [[1 5] [2 6] [3 7] [4 8]])
+(let a [1 2 3])
+(let b [4 5 6])
+(let zipped [[1 5] [2 6] [3 7] [4 8]])
 
+(test:suite list {
     (list:forEach a (fun (e) {
         # just assert we have something, basically it's just a while + @
-        (set tests (assert-neq e nil "forEach" tests))}))
-
-    (set tests (assert-eq (list:product b) (* 4 5 6) "product" tests))
-    (set tests (assert-eq (list:product []) 1 "product" tests))
-
-    (set tests (assert-eq (list:sum b) (+ 4 5 6) "sum" tests))
-    (set tests (assert-eq (list:sum []) 0 "sum" tests))
-
-    (set tests (assert-eq (list:drop a 0) [1 2 3] "drop" tests))
-    (set tests (assert-eq (list:drop a 1) [2 3] "drop" tests))
-    (set tests (assert-eq (list:drop a 2) [3] "drop" tests))
+        (test:neq e nil)}))
 
-    (set tests (assert-eq (list:dropWhile a (fun (c) (< c 0))) [1 2 3] "dropWhile" tests))
-    (set tests (assert-eq (list:dropWhile a (fun (c) (< c 2))) [2 3] "dropWhile" tests))
-    (set tests (assert-eq (list:dropWhile a (fun (c) (< c 5))) [] "dropWhile" tests))
+    (test:eq (list:product b) (* 4 5 6))
+    (test:eq (list:product []) 1)
 
-    (set tests (assert-eq (list:filter a math:even) [2] "filter" tests))
-    (set tests (assert-eq (list:filter a (fun (e) (> e 100))) [] "filter" tests))
-    (set tests (assert-eq (list:filter [] (fun (e) (> e 100))) [] "filter" tests))
+    (test:eq (list:sum b) (+ 4 5 6))
+    (test:eq (list:sum []) 0)
 
-    (set tests (assert-eq (list:map b (fun (e) (* e e))) [16 25 36] "map" tests))
-    (set tests (assert-eq (list:map [] (fun (e) (* e e))) [] "map" tests))
+    (test:eq (list:drop a 0) [1 2 3])
+    (test:eq (list:drop a 1) [2 3])
+    (test:eq (list:drop a 2) [3])
 
-    (set tests (assert-eq (list:reduce a (fun (x y) (- x y))) -4 "reduce" tests))
+    (test:eq (list:dropWhile a (fun (c) (< c 0))) [1 2 3])
+    (test:eq (list:dropWhile a (fun (c) (< c 2))) [2 3])
+    (test:eq (list:dropWhile a (fun (c) (< c 5))) [])
 
-    (set tests (assert-eq (list:flatten []) [] "flatten" tests))
-    (set tests (assert-eq (list:flatten [[]]) [] "flatten" tests))
-    (set tests (assert-eq (list:flatten [[1]]) [1] "flatten" tests))
-    (set tests (assert-eq (list:flatten zipped) [1 5 2 6 3 7 4 8] "flatten" tests))
+    (test:eq (list:filter a math:even) [2])
+    (test:eq (list:filter a (fun (e) (> e 100))) [])
+    (test:eq (list:filter [] (fun (e) (> e 100))) [])
 
-    (set tests (assert-eq (list:flatMap [] (fun (a) [a a])) [] "flatMap" tests))
-    (set tests (assert-eq (list:flatMap a (fun (a) (* 2 a))) [2 4 6] "flatMap" tests))
-    (set tests (assert-eq (list:flatMap a (fun (a) [a a])) [1 1 2 2 3 3] "flatMap" tests))
+    (test:eq (list:map b (fun (e) (* e e))) [16 25 36])
+    (test:eq (list:map [] (fun (e) (* e e))) [])
 
-    (set tests (assert-eq (list:take a 1) [1] "take" tests))
-    (set tests (assert-eq (list:take a 100) a "take" tests))
+    (test:eq (list:reduce a (fun (x y) (- x y))) -4)
 
-    (set tests (assert-eq (list:takeWhile a (fun (c) (< c 0))) [] "takeWhile" tests))
-    (set tests (assert-eq (list:takeWhile a (fun (c) (< c 2))) [1] "takeWhile" tests))
-    (set tests (assert-eq (list:takeWhile a (fun (c) (< c 3))) [1 2] "takeWhile" tests))
-    (set tests (assert-eq (list:takeWhile a (fun (c) (< c 5))) [1 2 3] "takeWhile" tests))
+    (test:eq (list:flatten []) [])
+    (test:eq (list:flatten [[]]) [])
+    (test:eq (list:flatten [[1]]) [1])
+    (test:eq (list:flatten zipped) [1 5 2 6 3 7 4 8])
 
-    (set tests (assert-eq (list:unzip zipped) [[1 2 3 4] [5 6 7 8]] "unzip" tests))
-    (set tests (assert-eq (list:unzip []) [[] []] "unzip" tests))
+    (test:eq (list:flatMap [] (fun (a) [a a])) [])
+    (test:eq (list:flatMap a (fun (a) (* 2 a))) [2 4 6])
+    (test:eq (list:flatMap a (fun (a) [a a])) [1 1 2 2 3 3])
 
-    (set tests (assert-eq (list:zip a b) [[1 4] [2 5] [3 6]] "zip" tests))
-    (set tests (assert-eq (list:zip [] []) [] "zip" tests))
+    (test:eq (list:take a 1) [1])
+    (test:eq (list:take a 100) a)
 
-    (set tests (assert-eq (list:foldLeft [] 0 (fun (x y) (+ x y))) 0 "foldLeft" tests))
-    (set tests (assert-eq (list:foldLeft ["1" "2" "3"] "" (fun (x y) (+ x y))) "123" "foldLeft" tests))
-    (set tests (assert-eq (list:foldLeft a 0 (fun (x y) (+ x y))) 6 "foldLeft" tests))
+    (test:eq (list:takeWhile a (fun (c) (< c 0))) [])
+    (test:eq (list:takeWhile a (fun (c) (< c 2))) [1])
+    (test:eq (list:takeWhile a (fun (c) (< c 3))) [1 2])
+    (test:eq (list:takeWhile a (fun (c) (< c 5))) [1 2 3])
 
-    (set tests (assert-eq a [1 2 3] "unmodified list" tests))
-    (set tests (assert-eq b [4 5 6] "unmodified list" tests))
+    (test:eq (list:unzip zipped) [[1 2 3 4] [5 6 7 8]])
+    (test:eq (list:unzip []) [[] []])
 
-    (set tests (assert-eq (list:forAll a (fun (e) (< e 4))) true "list:forAll" tests))
-    (set tests (assert-eq (list:forAll a (fun (e) (< e 2))) false "list:forAll" tests))
-    (set tests (assert-eq (list:forAll [] (fun (e) (= e 2))) true "list:forAll" tests))
-    (set tests (assert-eq (list:any a (fun (e) (< e 2))) true "list:any" tests))
-    (set tests (assert-eq (list:any a (fun (e) (> e 8))) false "list:any" tests))
-    (set tests (assert-eq (list:any [] (fun (e) (= e 8))) false "list:any" tests))
+    (test:eq (list:zip a b) [[1 4] [2 5] [3 6]])
+    (test:eq (list:zip [] []) [])
 
-    (recap "List tests passed" tests (- (time) start-time))
+    (test:eq (list:foldLeft [] 0 (fun (x y) (+ x y))) 0)
+    (test:eq (list:foldLeft ["1" "2" "3"] "" (fun (x y) (+ x y))) "123")
+    (test:eq (list:foldLeft a 0 (fun (x y) (+ x y))) 6)
 
-    tests }))
+    (test:eq a [1 2 3])
+    (test:eq b [4 5 6])
 
-(let passed-list (list-tests))
+    (test:expect (list:forAll a (fun (e) (< e 4))))
+    (test:expect (not (list:forAll a (fun (e) (< e 2)))))
+    (test:expect (list:forAll [] (fun (e) (= e 2))))
+    (test:expect (list:any a (fun (e) (< e 2))))
+    (test:expect (not (list:any a (fun (e) (> e 8)))))
+    (test:expect (not (list:any [] (fun (e) (= e 8)))))})