Merge pull request #34 from ryukinix/refactor-tests

refactor tests + write pratt parser tests

Author: ryukinix

.github/workflows/main.yml

@@ -1,10 +1,9 @@
-
 name: CI
 
 on: [pull_request]
 
 jobs:
-  build:
+  tests:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2

Makefile

@@ -29,10 +29,13 @@ docker-run: docker-build
 	docker run --rm -it --network=host $(DOCKER_IMG)
 
 docker-check: docker-build
-	docker run --rm -t --entrypoint=ros $(DOCKER_IMG) run -s lisp-inference/test -l run-test.lisp
+	docker run --rm -t --entrypoint=ros $(DOCKER_IMG) run -l run-test.lisp
 
 docker-publish: docker-build
 	docker tag $(DOCKER_IMG) $(PUBLIC_IMG)
 	docker push $(PUBLIC_IMG)
 
+deploy: docker-publish
+	ssh starfox bash /home/lerax/Deploy/logic.sh
+
 .PHONY: check docker-build

lisp-inference.asd

@@ -38,12 +38,18 @@
   :pathname "web"
   :components ((:file "webapp")))
 
-(asdf:defsystem #:lisp-inference/test
-  :description "Lisp Inference Test Suit"
+(asdf:defsystem #:lisp-inference/tests
+  :description "Lisp Inference Tests"
   :author "Manoel Vilela <[email protected]>"
   :license "BSD"
   :version "0.2.0"
   :serial t
   :pathname "t"
   :depends-on (:lisp-inference :rove)
-  :components ((:file "test")))
+  :components ((:file "tests")
+               (:file "test-equivalence-rules")
+               (:file "test-inference-rules")
+               (:file "test-infix-parsing")
+               (:file "test-pratt"))
+  :perform (test-op (o c)
+                    (symbol-call :rove :run c)))

run-test.lisp

@@ -1,6 +1,6 @@
 (load "fix-quicklisp")
-(ql:quickload :lisp-inference/test :silent t)
+(ql:quickload :lisp-inference/tests :silent t)
 (setf rove:*enable-colors* t)
-(if (rove:run* "lisp-inference/test")
+(if (rove:run :lisp-inference/tests)
     (sb-ext:exit :code 0)
     (sb-ext:exit :code 1))

t/test-equivalence-rules.lisp

@@ -0,0 +1,22 @@
+(in-package #:lisp-inference/tests/test-equivalence-rules)
+
+(deftest test-equivalence-rules
+  (testing "== Equivalence rules!"
+    (ok (equal (de-morgan '(^ p q))
+               '(~ (v (~ p) (~ q))))
+        "Equivalence: DE-MORGAN 1")
+    (ok (equal (de-morgan '(~ (v p q)))
+               '(^ (~ p) (~ q)))
+        "Equivalence: DE-MORGAN 2")
+
+    (ok (equal (de-morgan '(~ (^ (~ p) (~ q))))
+               '(v p q))
+        "Equivalence: DE-MORGAN 3")
+
+    (ok (equal (double-negation '(~ (~ p)))
+               'p)
+        "Equivalence: DOUBLE-NEGATION 1")
+
+    (ok (equal (double-negation 'p)
+               'p)
+        "Equivalence: DOUBLE-NEGATION 2")))

t/test-inference-rules.lisp

@@ -0,0 +1,40 @@
+(in-package #:lisp-inference/tests/test-inference-rules)
+
+
+(deftest test-inference-rules
+  (testing "== Inference rules!"
+    (ok (equal (modus-ponens '(^ (=> p q) p))
+               'q)
+        "Inference: MODUS-PONENS")
+
+    (ok (equal (modus-tollens '(^ (=> p q) (~ p)))
+               '(~ q))
+        "Inference: MODUS-TOLLENS")
+
+    (ok (equal (syllogism-disjunctive '(^ (v p q) (~ p)))
+               'q)
+        "Inference: SYLLOGISM-DISJUNCTIVE")
+
+    (ok (equal (syllogism-hypothetical '(^ (=> x y) (=> y z)))
+               '(=> X Z))
+        "Inference: SYLLOGISM-HYPOTHETICAL")
+
+    (ok (equal (addiction 'p 'q)
+               '(v p q))
+        "Inference: ADDICTION")
+
+    (ok (equal (conjunction '(=> p q) 'p)
+               '(^ (=> P Q) P))
+        "Inference: CONJUNCTION")
+
+    (ok (equal (absorption '(=> r (^ x y)))
+               '(=> R (^ R (^ X Y))))
+        "Inference: ABSORPTION")
+
+    (ok (equal (simplification-first '(^ p q))
+               'p)
+        "Inference: SIMPLIFICATION FIRST")
+
+    (ok (equal (simplification-second '(^ r s))
+               's)
+        "Inference: SIMPLIFICATION SECOND")))

t/test-infix-parsing.lisp

@@ -0,0 +1,15 @@
+(in-package #:lisp-inference/tests/test-infix-parsing)
+
+;; deprecated in favor of pratt parser
+(deftest test-infix-parsing
+  (testing "== Infix Parsing"
+    (ok (equal (infix-to-prefix '(~ (p v q)))
+               '(~ (v p q))))
+
+    (ok (equal (infix-to-prefix '(p => q))
+               '(=> p q)))
+
+    (ok (equal (infix-to-prefix '((p v q) <=> ((~ p) ^ (~ q))))
+               '(<=> (v p q)
+                    (^ (~ p)
+                       (~ q)))))))

t/test-pratt.lisp

@@ -0,0 +1,25 @@
+(in-package #:lisp-inference/tests/test-pratt)
+
+(deftest test-pratt
+  (testing "== Pratt Parser"
+    (ok (equal (parse-logic "p v q")
+               '(v p q)))
+
+    (ok (equal (parse-logic "(p v q)")
+               '(v p q)))
+
+    (ok (equal (parse-logic "p => q ^ r")
+               '(=> p (^ q r))))
+
+    (ok (equal (parse-logic "(p => q) ^ r")
+               '(^ (=> p q) r)))
+
+    (ok (equal (parse-logic "p -> ~ q")
+               '(-> p (~ q))))
+
+    (ok (equal (parse-logic "p [+] (r => s)")
+               '([+] p (=> r s))))
+
+    (ok (equal (parse-logic "~p")
+               '(~ p)))
+    ))

t/test.lisp

@@ -0,0 +1,26 @@
+(defpackage #:lisp-inference/tests/test-equivalence-rules
+  (:use #:cl
+        #:lisp-inference
+        #:rove))
+
+(defpackage #:lisp-inference/tests/test-inference-rules
+  (:use #:cl
+        #:lisp-inference
+        #:rove))
+
+(defpackage #:lisp-inference/tests/test-infix-parsing
+  (:use #:cl
+        #:lisp-inference
+        #:rove))
+
+(defpackage #:lisp-inference/tests/test-pratt
+  (:use #:cl
+        #:lisp-inference
+        #:rove))
+
+(defpackage #:lisp-inference/tests
+  (:use #:cl)
+  (:import-from #:lisp-inference/tests/test-equivalence-rules)
+  (:import-from #:lisp-inference/tests/test-inference-rules)
+  (:import-from #:lisp-inference/tests/test-infix-parsing)
+  (:import-from #:lisp-inference/tests/test-pratt))