simon/beowulf
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Full mexpr parsing working, number parsing working

Browse source
This commit is contained in:
Simon Brooke 2019-08-15 16:35:46 +01:00
parent b4091f28dc
commit 0321401c2a
7 changed files with 316 additions and 46 deletions
Download patch file Download diff file Expand all files Collapse all files

6
test/beowulf/core_test.clj
View file

@ -2,6 +2,6 @@
(:require [clojure.test :refer :all]
[beowulf.core :refer :all]))
(deftest a-test
(testing "FIXME, I fail."
(is (= 0 1))))
;; (deftest a-test
;; (testing "FIXME, I fail."
;; (is (= 0 1))))

67
test/beowulf/mexpr_test.clj Normal file
View file

@ -0,0 +1,67 @@
(ns beowulf.mexpr-test
(:require [clojure.test :refer :all]
[beowulf.read :refer [parse simplify generate]]
[beowulf.print :refer :all]))
;; These tests are taken generally from the examples on page 10 of
;; Lisp 1.5 Programmers Manual:
;; ## Examples
;; M-expressions S-expressions
;; x X
;; car CAR
;; car[x] (CAR X)
;; T (QUOTE T)
;; ff[car [x]] (FF (CAR X))
;; [atom[x]->x; T->ff[car[x]]] (COND ((ATOM X) X)
;; ((QUOTE T)(FF (CAR X))))
;; label[ff;λ[[x];[atom[x]->x; T->ff[car[x]]]]] (LABEL FF (LAMBDA (X) (COND
;; ((ATOM X) X)
;; ((QUOTE T)(FF (CAR X))))))
(deftest variable-tests
(testing "Variable translation"
(let [expected "X"
actual (prin (generate (simplify (parse "x"))))]
(is (= actual expected)))
(let [expected "CAR"
actual (prin (generate (simplify (parse "car"))))]
(is (= actual expected)))
))
(deftest literal-tests
(testing "Literal translation"
;; in the context of an M-expression, an upper case letter
;; or string represents a Lisp literal, and should be quoted.
;; Wrapping in a function call puts us into mexpr contest;
;; "T" would be interpreted as a sexpr, which would not be
;; quoted.
(let [expected "(ATOM (QUOTE T))"
actual (prin (generate (simplify (parse "atom[T]"))))]
(is (= actual expected)))
;; I'm not clear how `car[(A B C)]` should be translated, but
;; I suspect as (CAR (LIST 'A 'B 'C)).
))
(deftest fncall-tests
(testing "Function calls"
(let [expected "(CAR X)"
actual (prin (generate (simplify (parse "car[x]"))))]
(is (= actual expected)))
(let [expected "(FF (CAR X))"
actual (prin (generate (simplify (parse "ff[car[x]]"))))]
(is (= actual expected)))))
(deftest conditional-tests
(testing "Conditional expressions"
(let [expected "(COND ((ATOM X) X) ((QUOTE T) (FF (CAR X))))"
actual (prin (generate (simplify (parse "[atom[x]->x; T->ff[car[x]]]"))))]
(is (= actual expected)))
(let [expected "(LABEL FF (LAMBDA (X) (COND ((ATOM X) X) ((QUOTE T) (FF (CAR X))))))"
actual (prin
(generate
(simplify
(parse "label[ff;λ[[x];[atom[x]->x; T->ff[car[x]]]]]"))))]
(is (= actual expected)))))

8
test/beowulf/read_test.clj
View file

@ -2,9 +2,7 @@
(:require [clojure.test :refer :all]
[beowulf.core :refer :all]))
(deftest a-test
(testing "FIXME, I fail."
(is (= 0 1))))
;; (deftest a-test
;; (testing "FIXME, I fail."
;; (is (= 0 1))))
(deftest parser-tests
(testing "symbols"

76
test/beowulf/sexpr_test.clj Normal file
View file

@ -0,0 +1,76 @@
(ns beowulf.sexpr-test
(:require [clojure.math.numeric-tower :refer [abs]]
[clojure.test :refer :all]
[beowulf.read :refer [parse simplify generate]]
[beowulf.print :refer :all]))
;; broadly, sexprs should be homoiconic
(deftest atom-tests
(testing "Reading atoms"
(let [expected 'A
actual (generate (simplify (parse (str expected))))]
(is (= actual expected)))
(let [expected 'APPLE
actual (generate (simplify (parse (str expected))))]
(is (= actual expected)))
(let [expected 'PART2
actual (generate (simplify (parse (str expected))))]
(is (= actual expected)))
(let [expected 'EXTRALONGSTRINGOFLETTERS
actual (generate (simplify (parse (str expected))))]
(is (= actual expected)))
(let [expected 'A4B66XYZ2
actual (generate (simplify (parse (str expected))))]
(is (= actual expected)))))
(deftest number-tests
(testing "Reading octal numbers"
(let [expected 1
actual (generate (simplify (parse "1Q")))]
(is (= actual expected)))
(let [expected -1
actual (generate (simplify (parse "-1Q")))]
(is (= actual expected)))
(let [expected 8
actual (generate (simplify (parse "1Q1")))]
(is (= actual expected)))
(let [expected -8
actual (generate (simplify (parse "-1Q1")))]
(is (= actual expected)))
(let [expected 128
actual (generate (simplify (parse "2Q2")))]
(is (= actual expected)))
(let [expected 2093056
actual (generate (simplify (parse "777Q4")))]
(is (= actual expected))))
(testing "Reading decimal numbers - broadly should be homiconic"
(let [expected 7
actual (generate (simplify (parse "7")))]
(is (= actual expected)))
(let [expected -7
actual (generate (simplify (parse "-7")))]
(is (= actual expected)))
(let [expected 3.141592
actual (generate (simplify (parse "3.141592")))]
(is (= actual expected)))
(let [expected 1234567890
actual (generate (simplify (parse "1234567890")))]
(is (= actual expected)))
(let [expected -45.23
actual (generate (simplify (parse "-45.23")))]
(is (= actual expected))))
(testing "Reading scientific notation")
(let [expected 2/5
actual (generate (simplify (parse "4E-1")))]
(is (< (abs (- actual expected)) 0.0001)))
(let [expected 60
actual (generate (simplify (parse "6E1")))]
(is (< (abs (- actual expected)) 0.0001)))
(let [expected 60
actual (generate (simplify (parse "600.00E-1")))]
(is (< (abs (- actual expected)) 0.0001)))
(let [expected 60
actual (generate (simplify (parse "0.6E2")))]
(is (< (abs (- actual expected)) 0.0001))))