Introduce stdlib specs

These specs are written in Lit itself. While the test runner is not great and we don't have imports yet, it is enough to test the language in a real world scenario.

As the language evolves, it will be rewritten in more idiomatic ways

Author: MatheusRich

spec/stdlib/array.lit

@@ -0,0 +1,239 @@
+type TestRunner {
+  init {
+    self.tests = []
+    self.current_group = nil
+  }
+
+  fn test { |name, block|
+    self.tests.push({ name: name, block: block })
+  }
+
+  fn describe { |group_name, group_block|
+    self.current_group = group_name
+    group_block(self)
+    self
+  }
+
+  fn run {
+    let start_time = clock()
+    var failed_tests = []
+    var tests_without_assertions = []
+
+    self.tests.each(fn { |t|
+      let result = t[:block](Should())
+
+      if result && result[:ok] == false {
+        print("F")
+        failed_tests.push({ name: "{self.current_group} {t[:name]}", message: result[:message] })
+      } else {
+        if result {
+          print(".")
+        } else {
+          print("?")
+          tests_without_assertions.push(t[:name])
+        }
+      }
+    })
+
+    println()
+
+    failed_tests.each(fn { |f|
+      println()
+      println("{f[:name]}:")
+      println("  {f[:message]}")
+    })
+    let end_time = clock()
+    let elapsed = end_time - start_time
+    var total_time = ""
+    if elapsed < 1 {
+      total_time = "{elapsed * 1000}ms"
+    } else {
+      total_time = "{elapsed}s"
+    }
+
+    println()
+    println("Finished in {total_time}")
+    print("{self.tests.size()} examples, {failed_tests.size()} failures")
+    if tests_without_assertions.size() > 0 {
+      println(", {tests_without_assertions.size()} without assertions")
+    } else {
+      println()
+    }
+
+    let status = if failed_tests.is_empty?() do 0 else do 1
+    exit(status)
+  }
+}
+
+type Should {
+  init {
+    self.negated = false
+  }
+
+  fn not {
+    let s = Should()
+    s.negated = !self.negated
+    return s
+  }
+
+  fn eq { |actual, expected|
+    let ok = actual == expected
+
+    if self.negated {
+      if ok {
+        return self.fail("Did not expect {expected}, but got {actual}")
+      }
+    } else {
+      if !ok {
+        return self.fail("Expected {expected}, got {actual}")
+      }
+    }
+
+    return self.pass()
+  }
+
+  fn greater_than { |actual, value|
+    let ok = actual > value
+
+    if self.negated {
+      if ok {
+        return self.fail("Expected {actual} to not be greater than {value}")
+      }
+    } else {
+      if !ok {
+        return self.fail("Expected {actual} to be greater than {value}")
+      }
+    }
+
+    return self.pass()
+  }
+
+  fn greater_than_or_equal { |actual, value|
+    let ok = actual >= value
+
+    if self.negated {
+      if ok {
+        return self.fail("Expected {actual} to not be >= {value}")
+      }
+    } else {
+      if !ok {
+        return self.fail("Expected {actual} to be >= {value}")
+      }
+    }
+
+    self.pass()
+  }
+
+  fn less_than { |actual, value|
+    let ok = actual < value
+
+    if self.negated {
+      if ok {
+        return self.fail("Expected {actual} to not be less than {value}")
+      }
+    } else {
+      if !ok {
+        return self.fail("Expected {actual} to be less than {value}")
+      }
+    }
+
+    self.pass()
+  }
+
+  fn less_than_or_equal { |actual, value|
+    let ok = actual <= value
+
+    if self.negated {
+      if ok {
+        return self.fail("Expected {actual} to not be <= {value}")
+      }
+    } else {
+      if !ok {
+        return self.fail("Expected {actual} to be <= {value}")
+      }
+    }
+
+    self.pass()
+  }
+
+  fn include { |actual, item|
+    let ok = actual.includes?(item)
+
+    if self.negated {
+      if ok {
+        return self.fail("Expected {actual} to not include {item}")
+      }
+    } else {
+      if !ok {
+        return self.fail("Expected {actual} to include {item}")
+      }
+    }
+
+    self.pass()
+  }
+
+  fn have_size { |actual, expected_size|
+    let len = actual.size()
+    let ok = len == expected_size
+
+    if self.negated {
+      if ok {
+        return self.fail("Expected size to not be {expected_size}, but got {len}")
+      }
+    } else {
+      if !ok {
+        return self.fail("Expected size {expected_size}, got {len}")
+      }
+    }
+
+    self.pass()
+  }
+
+  fn be_empty { |actual|
+    let ok = actual.size() == 0
+
+    if self.negated {
+      if ok {
+        return self.fail("Expected {inspect(actual)} not to be empty")
+      }
+    } else {
+      if !ok {
+        return self.fail("Expected {inspect(actual)} to be empty")
+      }
+    }
+
+    self.pass()
+  }
+
+  fn be_of_type { |actual, expected_type|
+    let t = typeof(actual)
+    let ok = t == expected_type
+
+    if self.negated {
+      if ok {
+        return self.fail("Expected {actual} to not be of type {expected_type}")
+      }
+    } else {
+      if !ok {
+        return self.fail("Expected {actual} to be of type {expected_type}, but got {t}")
+      }
+    }
+
+    self.pass()
+  }
+
+  fn pass do {ok: true, message: ""}
+  fn fail do {ok: false, message: it}
+}
+
+
+TestRunner().
+  describe("Lit Array", fn { |t|
+    t.test("is_empty? when array is empty", fn { |should|
+      [].is_empty?() |> should.eq(true)
+    })
+    t.test("is_empty? when array is not empty", fn { |should|
+      [1].is_empty?() |> should.eq(false)
+    })
+  }).
+  run()

spec/stdlib_spec.cr

@@ -0,0 +1,15 @@
+require "./spec_helper"
+
+describe "stdlib tests", tags: "e2e" do
+  test_files = Dir.glob("spec/stdlib/**/*.lit").sort!
+
+  test_files.each do |file|
+    it "interprets #{file} correctly" do
+      status, output = run_lit(file)
+
+      unless status.success?
+        fail "Failed spec:\n#{output}"
+      end
+    end
+  end
+end