Added misc tests to increase test coverage

test/helper.janet

@@ -14,9 +14,12 @@
   (++ num-tests-run)
   (when x (++ num-tests-passed))
   (def str (string e))
+  (def frame (last (debug/stack (fiber/current))))
+  (def line-info (string/format "%s:%d"
+                              (frame :source) (frame :source-line)))
   (if x
-    (when is-verbose (eprintf "\e[32m✔\e[0m %s: %v" (describe e) x))
+    (when is-verbose (eprintf "\e[32m✔\e[0m %s: %s: %v" line-info (describe e) x))
-    (eprintf "\e[31m✘\e[0m %s: %v" (describe e) x))
+    (eprintf "\e[31m✘\e[0m %s: %s: %v" line-info (describe e) x))
   x)
 
 (defmacro assert-error

test/suite-array.janet

@@ -46,5 +46,36 @@
 (assert (deep= (array/remove @[1 2 3 4 5] 2 200) @[1 2]) "array/remove 3")
 (assert (deep= (array/remove @[1 2 3 4 5] -3 200) @[1 2 3]) "array/remove 4")
 
+
+# array/peek
+(assert (nil? (array/peek @[])) "array/peek empty")
+
+# array/fill
+(assert (deep= (array/fill @[1 1] 2) @[2 2]) "array/fill 1")
+
+# array/concat
+(assert (deep= (array/concat @[1 2] @[3 4] 5 6) @[1 2 3 4 5 6]) "array/concat 1")
+(def a @[1 2])
+(assert (deep= (array/concat a a) @[1 2 1 2]) "array/concat self")
+
+# array/insert
+(assert (deep= (array/insert @[:a :a :a :a] 2 :b :b) @[:a :a :b :b :a :a]) "array/insert 1")
+(assert (deep= (array/insert @[:a :b] -1 :c :d) @[:a :b :c :d]) "array/insert 2")
+
+# array/remove
+(assert-error "removal index 3 out of range [0,2]" (array/remove @[1 2] 3))
+(assert-error "expected non-negative integer for argument n, got -1" (array/remove @[1 2] 1 -1))
+
+# array/pop
+(assert (= (array/pop @[1]) 1) "array/pop 1")
+(assert (= (array/pop @[]) nil) "array/pop empty")
+
+# Code coverage
+(def a @[1])
+(array/pop a)
+(array/trim a)
+(array/ensure @[1 1] 6 2)
+
+
 (end-suite)
 

test/suite-buffer.janet

@@ -27,8 +27,11 @@
 (buffer/bit-set b 100)
 (buffer/bit-clear b 100)
 (assert (zero? (sum b)) "buffer bit set and clear")
+(assert (= false (buffer/bit b 101)) "bit get false")
 (buffer/bit-toggle b 101)
+(assert (= true (buffer/bit b 101)) "bit get true")
 (assert (= 32 (sum b)) "buffer bit set and clear")
+(assert-error "invalid bit index 1000" (buffer/bit-toggle b 1000))
 
 (def b2 @"hello world")
 
@@ -41,6 +44,17 @@
 (buffer/blit b2 "abcdefg" 5 6)
 (assert (= (string b2) "joytogjoyto") "buffer/blit 3")
 
+# buffer/push
+
+(assert (deep= (buffer/push @"AA" @"BB") @"AABB") "buffer/push buffer")
+(assert (deep= (buffer/push @"AA" 66 66) @"AABB") "buffer/push int")
+(def b @"AA")
+(assert (deep= (buffer/push b b) @"AAAA") "buffer/push buffer self")
+
+# buffer/push-byte
+(assert (deep= (buffer/push-byte @"AA" 66) @"AAB") "buffer/push-byte")
+(assert-error "bad slot #1, expected 32 bit signed integer" (buffer/push-byte @"AA" :flap))
+
 # Buffer push word
 # e755f9830
 (def b3 @"")
@@ -51,6 +65,7 @@
 (buffer/push-word b3 0xFFFFFFFF 0x1100)
 (assert (= 8 (length b3)) "buffer/push-word 3")
 (assert (= "\xFF\xFF\xFF\xFF\0\x11\0\0" (string b3)) "buffer/push-word 4")
+(assert-error "cannot convert 0.5 to machine word" (buffer/push-word @"" 0.5))
 
 # Buffer push string
 # 175925207

test/suite-corelib.janet

@@ -28,6 +28,13 @@
 # d6967a5
 (assert (= 4 (blshift 1 2)) "left shift")
 (assert (= 1 (brshift 4 2)) "right shift")
+# unsigned shift
+(assert (= 32768 (brushift 0x80000000 16)) "right shift unsigned 1")
+(assert (= -32768 (brshift 0x80000000 16)) "right shift unsigned 2")
+# non-immediate forms
+(assert (= 32768 (brushift 0x80000000 (+ 0 16))) "right shift unsigned non-immediate")
+(assert (= -32768 (brshift 0x80000000 (+ 0 16))) "right shift non-immediate")
+(assert (= 32768 (blshift 1 (+ 0 15))) "left shift non-immediate")
 # 7e46ead
 (assert (< 1 2 3 4 5 6) "less than integers")
 (assert (< 1.0 2.0 3.0 4.0 5.0 6.0) "less than reals")
@@ -116,5 +123,19 @@
   (assert (= (string (module/expand-path "hello" ":sys:/:all:.janet"))
              ".janet/.janet/hello.janet") "module/expand-path 1"))
 
+# int?
+(assert (int? 1) "int? 1")
+(assert (int? -1) "int? -1")
+(assert (not (int? true)) "int? true")
+(assert (not (int? 3.14)) "int? 3.14")
+(assert (not (int? 8589934592)) "int? 8589934592")
+
+# memcmp
+(assert (= (memcmp "123helloabcd" "1234helloabc" 5 3 4) 0) "memcmp 1")
+(assert (< (memcmp "123hellaabcd" "1234helloabc" 5 3 4) 0) "memcmp 2")
+(assert (> (memcmp "123helloabcd" "1234hellaabc" 5 3 4) 0) "memcmp 3")
+(assert-error "invalid offset-a: 1" (memcmp "a" "b" 1 1 0))
+(assert-error "invalid offset-b: 1" (memcmp "a" "b" 1 0 1))
+
 (end-suite)
 

test/suite-inttypes.janet

@@ -228,5 +228,31 @@
     (assert (= c (compare x y))
             (string/format "compare polymorphic %q %q %d" x y c))))
 
+# marshal
+(def m1 (u64 3141592654))
+(def m2 (unmarshal (marshal m1)))
+(assert (= m1 m2) "marshal/unmarshal")
+
+# compare u64/u64
+(assert (= (compare (u64 1) (u64 2)) -1) "compare 1")
+(assert (= (compare (u64 1) (u64 1))  0) "compare 2")
+(assert (= (compare (u64 2) (u64 1)) +1) "compare 3")
+
+# compare i64/i64
+(assert (= (compare (i64 -1) (i64 +1)) -1) "compare 4")
+(assert (= (compare (i64 +1) (i64 +1))  0) "compare 5")
+(assert (= (compare (i64 +1) (i64 -1)) +1) "compare 6")
+
+# compare u64/i64
+(assert (= (compare (u64 1) (i64 2)) -1) "compare 7")
+(assert (= (compare (u64 1) (i64 -1)) +1) "compare 8")
+(assert (= (compare (u64 -1) (i64 -1)) +1) "compare 9")
+
+# compare i64/u64
+(assert (= (compare (i64 1) (u64 2)) -1) "compare 10")
+(assert (= (compare (i64 -1) (u64 1)) -1) "compare 11")
+(assert (= (compare (i64 -1) (u64 -1)) -1) "compare 12")
+
+
 (end-suite)
 

test/suite-io.janet

@@ -68,5 +68,15 @@
           "trace to custom err function")
   (assert (deep= @"trace (dummy 1 2 3)\n" b) "trace buffer correct"))
 
+
+# xprintf
+(def b @"")
+(defn to-b [a] (buffer/push b a))
+(xprintf to-b "123")
+(assert (deep= b @"123\n") "xprintf to buffer")
+
+
+(assert-error "cannot print to 3" (xprintf 3 "123"))
+
 (end-suite)
 

test/suite-parse.janet

@@ -165,5 +165,28 @@
 (loop [v :iterate (parser/produce p2)])
 (parser/state p2)
 
+# parser delimiter errors
+(defn test-error [delim fmt]
+  (def p (parser/new))
+  (parser/consume p delim)
+  (parser/eof p)
+  (def msg (string/format fmt delim))
+  (assert (= (parser/error p) msg) "delimiter error"))
+(each c [ "(" "{" "[" "\"" "``" ]
+  (test-error c "unexpected end of source, %s opened at line 1, column 1"))
+
+# parser/insert
+(def p (parser/new))
+(parser/consume p "(")
+(parser/insert p "hello")
+(parser/consume p ")")
+(assert (= (parser/produce p) ["hello"]))
+
+(def p (parser/new))
+(parser/consume p `("hel`)
+(parser/insert p `lo`)
+(parser/consume p `")`)
+(assert (= (parser/produce p) ["hello"]))
+
 (end-suite)
 

test/suite-struct.janet

@@ -78,5 +78,17 @@
 (assert (struct/getproto (struct/with-proto {:a 1} :b 2 :c nil))
         "missing struct proto")
 
+# struct/with-proto
+(assert-error "expected odd number of arguments" (struct/with-proto {} :a))
+
+# struct/to-table
+(def s (struct/with-proto {:a 1 :b 2} :name "john" ))
+(def t1 (struct/to-table s true))
+(def t2 (struct/to-table s false))
+(assert (deep= t1 @{:name "john"}) "struct/to-table 1")
+(assert (deep= t2 @{:name "john"}) "struct/to-table 2")
+(assert (deep= (getproto t1) @{:a 1 :b 2}) "struct/to-table 3")
+(assert (deep= (getproto t2) nil) "struct/to-table 4")
+
 (end-suite)