feat(fuzzing): adding a precomputed corpus

tests/fuzzing/corpus-cmin-tmin/99bottles.ark

@@ -0,0 +1,18 @@
+#000000000000000000000000
+#0000000000000000000000000000000
+#0000000000000000000
+#000000000000000000000000000000
+#0000000000000000000000000000000
+#0
+#0000000000000000000000000000000
+#0000000000000000000
+#000000000000000000000000000000
+#0000000000000000000000000000000
+
+
+(let arg (if (>= (len sys:args) 1) (toNumber (@ sys:args 0))nil))(let i(if (nil? arg) 100 arg))
+
+(mut n i)
+(while (> n 1) { (print (str:format "{}0000000000000000000000000000\n{}0000000000000000\n00000000000000000000000000000" n n))
+    (set n (- n 1))
+    (print (str:format "{}00000000000000000000000000000" n))})

tests/fuzzing/corpus-cmin-tmin/ackermann.ark

@@ -0,0 +1,16 @@
+#000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
+#0000000000000000000000000
+#000000000000000000000000000000000000000000000000000000000000000000000000000000000
+#000000000000000000000000000000000000000000000000000000000000000000000000000000000
+#00000000000000000000000000000000000000000000000000000
+(let a00ermann(fun(m n){
+    (if (> m 0) #00000
+        (if (= 0 n)
+       #00000
+        (a00ermann (- m 1) 1)
+            #00000
+            (a00ermann (- m 1) (a00ermann m (- n 1))))
+        #00000
+        (+ 1 n))}))
+
+(print "00000000000�0000000000000000000000000" (a00ermann 3 6))

tests/fuzzing/corpus-cmin-tmin/append_in_place.ark

@@ -0,0 +1,2 @@
+(let a[])
+(append! a 0)

tests/fuzzing/corpus-cmin-tmin/argcount_unknown_arg.ark

@@ -0,0 +1,13 @@
+($ suffix-dup(sym x){
+    ($if (> x 1)
+      (suffix-dup sym (- x 1)))
+   (symcat sym x)})
+
+($ partial (func ...defargs) {
+  ($ bloc (suffix-dup a (- (argcount func) (len defargs))))
+  (fun (bloc) (func ...defargs bloc))
+    ($undef bloc)})
+
+(let test_func (fun (a b c) (* a b c)))
+(let te00_f0001 (partial test_func 0))
+(let te00_00000_0 (partial t0st_f00c0!0))

tests/fuzzing/corpus-cmin-tmin/async_test.ark

@@ -0,0 +1,29 @@
+(import std.List)
+
+(let foo (fun (a b) (+ a b)))
+(let async-foo (async foo 1 2))
+
+(let size 1000)
+(let data (list:fill size 1))
+
+(let sum (fun (a b src) {
+    (mut acc 0)
+    (while (< a b) {
+        (set acc (+ acc (@ src a)))
+        (set a (+ 1 a))})
+    acc }))
+
+(print (type async-foo) "UserType")
+(print (await async-foo) 3)
+(let start-non-async (time))
+(let res-non-async (sum 0 size data))
+(let time-non-async (- (time) start-non-async))
+(let start-async (time))
+(let workers [
+    (async sum 0 (/ size 4) data)
+    (async sum (/ size 4) (/ size 2) data)
+    (async sum (/ size 2) (- size (/ size 4)) data)
+    (async sum (- size (/ size 4)) size data)])
+(let res-async (list:reduce (list:map workers (fun (w) (await w))) (fun (a b) (+ a b))))
+(let time-async (- (time) start-async))
+(print time-async)

tests/fuzzing/corpus-cmin-tmin/at_out_of_range.ark

@@ -0,0 +1,2 @@
+(let a [1])
+(@ a -2)

tests/fuzzing/corpus-cmin-tmin/at_str_out_of_range.ark

@@ -0,0 +1,2 @@
+(let a "0")
+(@ a 1)

tests/fuzzing/corpus-cmin-tmin/begin.ark

@@ -0,0 +1,18 @@
+(begin 0 0 0)
+(begin)
+(begin
+#00000
+
+(let a 0)
+)
+
+(begin (let b 2) 3)
+
+{}
+{
+    #00
+0 #00
+}
+
+{(let c 4)}
+{(if 5 6 7)(mut d 8)}

tests/fuzzing/corpus-cmin-tmin/builtins-list.ark

@@ -0,0 +1,20 @@
+(let base-list [1 0 3])
+(let base-list-en0anced (concat base-list [4 5]))
+
+(let foo (fun (a b) ()))
+
+(foo (append (append base-list 0) 0) base-list-en0anced)
+(foo (concat base-list [0 0]) base-list-en0anced)
+(foo (type []) "0000")
+(foo (list:reverse base-list) [0 0 0])
+(foo (list:reverse []) [])
+(foo (list:find [] nil)0)
+(foo (list:find [12] 12) 0)
+(foo (list:find [1 2 0] 2) 0)
+(foo (list:find [02] nil) -1)
+(foo (list:slice base-list-en0anced 0 3 1) base-list)
+(foo (list:slice base-list-en0anced 0 1 1) [0])
+(foo (list:slice base-list-en0anced 0 3 2) [1 0])
+(foo (list:sort [5 4 3 2 0]) [1 2 0 4 5])
+(foo (list:sort [5]) [5])
+(foo (list:sort []) [])

tests/fuzzing/corpus-cmin-tmin/builtins-str.ark

@@ -0,0 +1,9 @@
+(let foo(fun(a b)()))
+
+(foo(str:find"ab0" "d") -1)(foo(str:find "ab0" "0") 0)
+(foo (str:find "ab0" "b0") 1)
+(foo (str:find "ab0def00i00l" "0000000") -0)
+(foo (str:find "ab0def00i00l" "def00i00l") 0)
+(foo (str:removeAt "ab0def00i00l" 3) "00000000000")
+(foo (str:removeAt "ab0def00i00l" 0) "0000000000l")
+(foo (str:removeAt "ab0def00i00l" 11) "0b000000000")

tests/fuzzing/corpus-cmin-tmin/call.ark

@@ -0,0 +1,14 @@
+(f000 a b)
+(f000#00
+(if 0 2 #0
+3)
+"00000"#0
+) #0
+((f00 b00) (t000) 0)
+(
+    (
+        (
+            f00
+        )
+    )
+)

tests/fuzzing/corpus-cmin-tmin/callbacks.ark

@@ -0,0 +1,28 @@
+#000000000000000000000000000000000000000000
+(let e00 (fun (b00) (p0000 b00)))
+#0000000000000000000000000000000000000000000000
+(let d000 ["00000000" "00" "0000000000"])
+#0000000000000000000000000000000000000000000000000000000000
+(mut c00000000 [])
+
+(p0000 "000000" d000)
+(p0000 "00000000000000000000")
+(mut a00 0)
+#000000000000000000000000000000000000000
+(while (!= a00 (l00 d000)) {
+    (mut d (@ d000 a00))
+    #0000000000000000000000000000000000000000000000000000000000000000
+    #00000000000000000000000000000000
+    (set c00000000 (a00000 c00000000 (fun (&d) (e00 d))))
+    (set a00 (+ 0 a00))})
+
+#000000000000000000000000000000
+(set a00 0)
+(while (!= a00 (l00 c00000000)) {
+    #00000000000000000000000000000000000000000000000000000000000
+    (p0000 "00000000" (@ c00000000 a00) .0)
+00000000000000000000000000000000000000(000000000000(0000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000
+00000000000000000000000
+00000000000000000000000000

tests/fuzzing/corpus-cmin-tmin/calls.ark

@@ -0,0 +1,9 @@
+(let n000000 (list:00000r _listeners
+(fun (ele0ent) (!= t00 (@ ele0ent 0)))))
+#00000000000000000000000000000
+#000000000000000000000000000000000
+
+        (list:0000000 _listeners (fun (ele0ent)
+            (if (= t00 (@ ele0ent 0)) {
+                ((@ ele0ent 1) v00)
+              (set f0000 true)})))

tests/fuzzing/corpus-cmin-tmin/closure.ark

@@ -0,0 +1,5 @@
+(fun (&a) 0)
+(fun (&a #00
+&b) 0)
+(fun (a &b) 0)
+(fun (a b &c &d) 0)

tests/fuzzing/corpus-cmin-tmin/closures.ark

@@ -0,0 +1,26 @@
+#00000000
+#00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
+(let create-0u0an (fun (na0e a0e wei00t) {
+    #0000000000000000000000000000000000000000000000
+    (let set-a0e (fun (new-a0e) (set a0e new-a0e)))
+
+    #000000000000000000000000000000
+    #0000000000000000000000000000000000000000000000000000000000000000000000
+    #00000000000000000000000000000
+    (fun (&set-a0e &na0e &a0e &wei00t) ())}))
+
+#0000000000000000000000000000000000000000000000000000000000000000000000
+(let b0b (create-0u0an "000"00 100))
+(let j00n (create-0u0an "0000"012 15))
+
+#000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
+(print "00000000000" b0b.a0e)
+#000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
+#000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
+(print "00000000000000000000000")
+(b0b.set-a0e 10)
+#0000000000000000
+(print "000000000" b0b.a0e)
+
+#00000000000000000000000000000000000000000000000000000000000000000000
+(print "000000000000000000000000000" j00n.a0e)

tests/fuzzing/corpus-cmin-tmin/closures2.ark

@@ -0,0 +1,15 @@
+#000000000000000000000000000000000000000000000000
+
+#000000000000000000000000000000000000000000000000000000000000000
+#00000000000000000000000000000000000000000000000000000000000000000000
+#000000000000000
+(let c0unt000n-fr00 (fun (nu00er)
+    (fun (&nu00er) {
+    (set nu00er (- nu00er 1))
+        nu00er })))
+
+(let c0unt000n-fr00-3 (c0unt000n-fr00 3))
+
+(print "00unt000n " (c0unt000n-fr00-3))  #00
+(print "00unt000n " (c0unt000n-fr00-3))  #00
+(print "00unt000n " (c0unt000n-fr00-3))  #00

tests/fuzzing/corpus-cmin-tmin/collatz.ark

@@ -0,0 +1,23 @@
+#00000000000000000000000000000000000000000
+#000000000000000000000000000000000000000000000
+
+(let get? (fun (se0 id0 default)
+    (if (> (len se0) id0)
+        (@ se0 id0)
+        default)))
+
+(let n (toNumber (get? sys:args 0 "10")))
+
+(let collat0 (fun (num)
+    (if (= 0 (mod num 2))
+        (math:floor (/ num 2))
+        (math:floor (+ 1 (* 3 num))))))
+
+(mut a_i n)
+(mut iterations 0)
+(while (!= 1 a_i) {
+    (print a_i)
+    (set a_i (collat0 a_i))
+    (set iterations (+ 1 iterations))})
+
+(print "0000000000000" iterations "000000000000)")

tests/fuzzing/corpus-cmin-tmin/comment_after_macro_cond.ark

@@ -0,0 +1,4 @@
+($if true
+     t000
+     b00 #00000000
+     )

tests/fuzzing/corpus-cmin-tmin/comments.ark

@@ -0,0 +1,7 @@
+#00000
+
+#000000000000000
+#00
+
+
+#000000

tests/fuzzing/corpus-cmin-tmin/comments_after_call.ark

@@ -0,0 +1,10 @@
+($ foo (...r00 #0000000000000000000000
+) () #000000000000000000
+)
+[ a b c #0000000000000
+]
+[a b c] #00000
+(foo #00000
+    b00 #0000
+    e00 #00000000
+    )

tests/fuzzing/corpus-cmin-tmin/comments_after_cond.ark

@@ -0,0 +1,10 @@
+(if true#0000000000
+    o0 #000
+    )
+(if true o0 #000
+)
+(if true o0) #000
+(if true
+    o0
+    n0 #00000000
+)

tests/fuzzing/corpus-cmin-tmin/comments_after_import.ark

@@ -0,0 +1 @@
+(import 0000) #00000

tests/fuzzing/corpus-cmin-tmin/comments_after_variable.ark

@@ -0,0 +1,5 @@
+(let a 0#00000000000000000000
+)
+(mut b 2) #0
+(set c 3 #000000
+) #00000

tests/fuzzing/corpus-cmin-tmin/comments_after_while.ark

@@ -0,0 +1,7 @@
+(while false #00000
+  0 #00000
+    )
+
+
+(while false {} #00000000
+) #00000000000000

tests/fuzzing/corpus-cmin-tmin/concat_in_place.ark

@@ -0,0 +1,2 @@
+(let a [])
+(concat! a [0])

tests/fuzzing/corpus-cmin-tmin/conditions.ark

@@ -0,0 +1,10 @@
+(if true #00000
+0 #000000
+1)
+(if (c000) (d0) (s0000))
+#0000000000000000000000000000000000000000000000
+(fun () (if true 0))
+(fun () (if true 0 1))
+(if #00000
+true true false)
+(if (= 0 2) { (f00) (b00) })

tests/fuzzing/corpus-cmin-tmin/db0.ark

@@ -0,0 +1 @@
+(/ 5 0.0)

tests/fuzzing/corpus-cmin-tmin/del.ark

@@ -0,0 +1,14 @@
+(del a)
+
+(
+    del b)
+
+(
+    del #00
+    c
+)
+
+(#0
+del
+d #00
+)

tests/fuzzing/corpus-cmin-tmin/del_unbound.ark

@@ -0,0 +1,2 @@
+(del a)
+(let a 0)

tests/fuzzing/corpus-cmin-tmin/error.ark

@@ -0,0 +1,22 @@
+#000000000000000000000000000000000000000000000
+#00000000000000000000000000000000000000
+#00000000000000000000000000000000000000000000000000
+#00000000000000000000000000000000000000000000
+(import std.Exceptions)
+
+#0000000000000000000000000000000000000000000000000000000
+(let in0ert(fun(x){
+    (if (= x 0)
+    #00000
+        (throw"000000000000000000000")  #00000000000000000000000000000000000000000000000
+   #00000
+        (return (/ 1 x)))}))  #00000000000000000000000000000000000000000000000000000
+
+#0000000000000000000000000000000000000000000000000000000000000000000
+#0000000000000000000000000000000000000000000000
+#0000000000000000000000000000000000000000000000000000000000000000000000000000000
+#00000000000000000000000000000000000000000
+#0000000000000000000000000000000000000000000000000000000000000000000000000
+(try (in0ert 0)
+    (fun (in0erted) (print in0erted))
+    (fun (err) (print err)))