Added basic unit test framework, started adding tests for stdlib

andybest · andybest · commit 38b35ea567cf · 2017-07-13T16:58:29.000+01:00
diff --git a/Sources/SLisp/Repl.swift b/Sources/SLisp/Repl.swift
@@ -65,7 +65,6 @@ public class Repl {
                 do {
                     let form = try Reader.read(input)
                     let (lt, e) = try parser.eval(form, environment: environment)
-                    environment = e
                     rv = lt
                 } catch let LispError.runtime(msg:message) {
                     return "Runtime Error: \(message)"
diff --git a/Sources/SLispCore/Errors.swift b/Sources/SLispCore/Errors.swift
@@ -36,5 +36,6 @@ public enum LispError: Error {
 }
 
 public enum StandardErrors: String {
-    case invalidArgumentException
+    case invalidArgumentError
+    case runtimeError
 }
diff --git a/Sources/SLispCore/Namespace.swift b/Sources/SLispCore/Namespace.swift
@@ -54,7 +54,12 @@ extension Parser {
     func getValue(_ name: String, withEnvironment env: Environment) throws -> LispType {
         var targetNamespace: String?
         var binding:   String
-
+        
+        // Special symbol that returns the current namespace
+        if name == "*ns*" {
+            return .symbol(env.namespace.name)
+        }
+        
         // Split the input on the first forward slash to separate by
         let bindingComponents = name.characters.split(maxSplits: 1, omittingEmptySubsequences: false) {
             $0 == "/"
diff --git a/Sources/SLispCore/Parser.swift b/Sources/SLispCore/Parser.swift
@@ -230,7 +230,7 @@ public class Parser {
                         }
                         
                         let (_, e) = try eval(doForm, environment: envs.last!)
-                        envs.append(e)
+                        //envs.append(e)
                     }
                     
                     // TCO
@@ -542,7 +542,7 @@ public class Parser {
             for (index, doForm) in tryBody!.enumerated() {
                 let (form, _) = try eval(doForm, environment: env)
                 
-                if index == 1 {
+                if index == tryBody!.count - 1 {
                     returnForm = (form, env)
                 }
             }
@@ -555,8 +555,12 @@ public class Parser {
             
             // Eval catch body
             if catchBody != nil {
-                for catchForm in catchBody! {
-                    let (_, _) = try eval(catchForm, environment: env)
+                for (index, catchForm) in catchBody!.enumerated() {
+                    let (form, _) = try eval(catchForm, environment: env)
+                    
+                    if index == catchBody!.count - 1 {
+                        returnForm = (form, env)
+                    }
                 }
             }
         } catch {
@@ -660,7 +664,7 @@ public class Parser {
                         
                         for val in lispBody {
                             let (lt, e) = try eval(val, environment: envs.last!)
-                            envs.append(e)
+                            //envs.append(e)
                             mutableForm = lt
                         }
                     } else {
diff --git a/Sources/SLispCore/builtins/Core+CollectionOperations.swift b/Sources/SLispCore/builtins/Core+CollectionOperations.swift
@@ -249,6 +249,50 @@ extension Core {
         }
         
         
+        // MARK: take
+        addBuiltin("take", docstring: """
+        take
+        (coll n)
+            Returns the first n items of the collection
+        """) { args, parser, env throws in
+            try self.checkArgCount(funcName: "take", args: args, expectedNumArgs: 2)
+            
+            guard case let .number(.integer(num)) = args[1] else {
+                throw LispError.runtime(msg: "'take' expects the second argument to be an integer")
+            }
+            
+            if case let .list(list) = args[0] {
+                return .list(Array(list.prefix(num)))
+            } else if case let .string(str) = args[0] {
+                return .string(String(str.prefix(num)))
+            }
+            
+            throw LispError.general(msg: "'take' expects an argument that is a list or a string")
+        }
+        
+        
+        // MARK: drop
+        addBuiltin("drop", docstring: """
+        drop
+        (coll n)
+            Drops the first n items of the collection
+        """) { args, parser, env throws in
+            try self.checkArgCount(funcName: "drop", args: args, expectedNumArgs: 2)
+            
+            guard case let .number(.integer(num)) = args[1] else {
+                throw LispError.runtime(msg: "'drop' expects the second argument to be an integer")
+            }
+            
+            if case let .list(list) = args[0] {
+                return .list(Array(list.dropFirst(num)))
+            } else if case let .string(str) = args[0] {
+                return .string(String(str.dropFirst(num)))
+            }
+            
+            throw LispError.general(msg: "'drop' expects an argument that is a list or a string")
+        }
+        
+        
         // MARK: at
         addBuiltin("at", docstring: """
         at
diff --git a/install.sh b/install.sh
@@ -3,10 +3,10 @@
 INSTALL_ROOT=/usr/local/opt/slisp
 
 swift build -c release -Xswiftc -static-stdlib
-pushd .build/release
+pushd .build/release > /dev/null
 mkdir -p $INSTALL_ROOT
 mkdir -p $INSTALL_ROOT/bin
 cp SLisp $INSTALL_ROOT/bin
-popd
+popd > /dev/null
 
 cp -R stdlib $INSTALL_ROOT
diff --git a/run.sh b/run.sh
@@ -1,5 +1,5 @@
 #!/bin/sh
 
-pushd ./.build/debug
+pushd ./.build/debug > /dev/null
 ./SLisp
-popd
+popd > /dev/null
diff --git a/runTests.sh b/runTests.sh
@@ -0,0 +1,6 @@
+#!/bin/sh
+
+./install.sh
+pushd stdlibTests > /dev/null
+slisp test-suite.sl
+popd > /dev/null
diff --git a/stdlib/core/core.sl b/stdlib/core/core.sl
@@ -61,7 +61,7 @@
         (while (< collidx (count coll))
             (let (item (at coll collidx))
                 (if (f item)
-                    (set! processed (concat processed item))))
+                    (set! processed (concat processed (list item)))))
             (set! collidx (+ collidx 1)))
         processed))
 
diff --git a/stdlib/test.sl b/stdlib/test.sl
@@ -74,3 +74,67 @@
     (print (color-text :blue "Blue text"))
     (print (color-text :magenta "Magenta text"))
     (print (color-text :cyan "Cyan text")))
+
+
+;; Test function
+
+(defmacro deftest
+    #((name & body)
+        (concat `(defn ~(symbol (str "test-" name))) body)))
+
+
+;; Test runner
+
+(defn get-tests
+    (ns-list)
+    (filter #((x)
+        (let (name (first x)
+              val (second x))
+              (&& (== (take (str name) 5) "test-") (function? val))))
+        ns-list))
+
+(defn run-test-file
+    (path)
+    (let (file-contents (read-string (str "(do " (slurp path) " *ns* )"))
+          file-ns (eval file-contents)
+          ns-contents (list-ns file-ns)
+          tests (get-tests ns-contents))
+          (print (str "Running test file " path))
+
+          ; Run each test
+          (let (test-results (map #((t) (run-test (second t) (drop (str (first t)) 5))) tests)
+                test-count (count tests)
+                pass-count (count (filter #((x) x) test-results))
+                fail-count (count (filter #((x) (! x)) test-results)))
+
+                (print "Test file completed")
+                (when pass-count 
+                    (print (color-text :green (str "\t" pass-count " tests passed"))))
+                (when fail-count
+                    (print (color-text :red (str "\t" fail-count " tests failed"))))
+                
+                (== fail-count 0))))
+
+(defn run-test-suite
+    (& testFiles)
+    (print "Running test suite")
+    (let (results (map run-test-file testFiles)
+          failed-test-files (filter #((x) (! x)) results))
+          (if (> (count failed-test-files) 0)
+                (do
+                    (print (color-text :red "Test suite failed"))
+                    (exit 1))
+                (do
+                    (print (color-text :green "Test suite passed"))
+                    (exit 0)))))
+
+(defn run-test
+    (test test-name)
+    (print (str "Running test: " test-name))
+    (try
+        (test)
+        (print (color-text :green "\tPASS"))
+        true
+    (catch e
+        (print (color-text :red "\tFAIL"))
+        false)))
diff --git a/stdlibTests/core/core.sl b/stdlibTests/core/core.sl
@@ -0,0 +1,74 @@
+; MIT License
+;
+; Copyright (c) 2016 Andy Best
+;
+; 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.
+
+(ns core-tests
+    (:refer core.test))
+
+(deftest map-applies-function-to-items ()
+    (let (test-input '(1 2 3 4 5 6)
+          add-fn #((x) (+ x 1)))
+
+          (assertEqual 
+            (map add-fn test-input)
+            '(2 3 4 5 6 7))))
+
+(deftest reduce-reduces-values ()
+    (let (test-input '(1 2 3 4 5)
+          add-fn #((x y) (+ x y)))
+
+          (assertEqual
+            (reduce add-fn 0 test-input)
+            15)))
+
+(deftest filter-filters-values ()
+    (let (test-input '(1 2 3 4 5 6 7 8 9 10)
+          test-fn #((x) (== (mod x 2) 0)))
+
+          (assertEqual
+            (filter test-fn test-input)
+            '(2 4 6 8 10))))
+
+(deftest second-returns-second-item ()
+    (assertEqual
+        (second '(1 2 3 4))
+        2))
+
+(deftest reverse-reverses-list ()
+    (assertEqual
+        (reverse '(1 2 3 4))
+        '(4 3 2 1)))
+
+(deftest reverse-reverses-string ()
+    (assertEqual
+        (reverse "Hello")
+        "olleH"))
+
+
+(deftest less-than-or-equal ()
+    (assert (<= 2 10))
+    (assert (<= 2 2))
+    (assert (! (<= 10 2))))
+
+(deftest greater-than-or-equal ()
+    (assert (>= 10 2))
+    (assert (>= 10 10))
+    (assert (! (>= 10 20))))
diff --git a/stdlibTests/test-suite.sl b/stdlibTests/test-suite.sl
@@ -0,0 +1,27 @@
+; MIT License
+;
+; Copyright (c) 2016 Andy Best
+;
+; 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.
+
+(ns stdlib-testsuite
+    (:refer core.test))
+
+(run-test-suite
+    "core/core.sl")

Original file line number	Diff line number	Diff line change
`@@ -36,5 +36,6 @@ public enum LispError: Error {`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`public enum StandardErrors: String {`
`39`		`- case invalidArgumentException`
	`39`	`+ case invalidArgumentError`
	`40`	`+ case runtimeError`
`40`	`41`	`}`
Original file line number	Diff line number	Diff line change
`@@ -230,7 +230,7 @@ public class Parser {`
`230`	`230`	`}`
`231`	`231`
`232`	`232`	`let (_, e) = try eval(doForm, environment: envs.last!)`
`233`		`- envs.append(e)`
	`233`	`+ //envs.append(e)`
`234`	`234`	`}`
`235`	`235`
`236`	`236`	`// TCO`
`@@ -542,7 +542,7 @@ public class Parser {`
`542`	`542`	`for (index, doForm) in tryBody!.enumerated() {`
`543`	`543`	`let (form, _) = try eval(doForm, environment: env)`
`544`	`544`
`545`		`- if index == 1 {`
	`545`	`+ if index == tryBody!.count - 1 {`
`546`	`546`	`returnForm = (form, env)`
`547`	`547`	`}`
`548`	`548`	`}`
`@@ -555,8 +555,12 @@ public class Parser {`
`555`	`555`
`556`	`556`	`// Eval catch body`
`557`	`557`	`if catchBody != nil {`
`558`		`- for catchForm in catchBody! {`
`559`		`- let (_, _) = try eval(catchForm, environment: env)`
	`558`	`+ for (index, catchForm) in catchBody!.enumerated() {`
	`559`	`+ let (form, _) = try eval(catchForm, environment: env)`
	`560`	`+`
	`561`	`+ if index == catchBody!.count - 1 {`
	`562`	`+ returnForm = (form, env)`
	`563`	`+ }`
`560`	`564`	`}`
`561`	`565`	`}`
`562`	`566`	`} catch {`
`@@ -660,7 +664,7 @@ public class Parser {`
`660`	`664`
`661`	`665`	`for val in lispBody {`
`662`	`666`	`let (lt, e) = try eval(val, environment: envs.last!)`
`663`		`- envs.append(e)`
	`667`	`+ //envs.append(e)`
`664`	`668`	`mutableForm = lt`
`665`	`669`	`}`
`666`	`670`	`} else {`