Tests: Coverage Expansion and Refinement

implants/lib/eldritchv2/eldritch-core/tests/enumerate_coverage.rs

@@ -0,0 +1,65 @@
+mod assert;
+
+#[test]
+fn test_enumerate_list() {
+    assert::pass(
+        r#"
+        e = enumerate(['a', 'b'])
+        assert_eq(e, [(0, 'a'), (1, 'b')])
+    "#,
+    );
+}
+
+#[test]
+fn test_enumerate_start() {
+    assert::pass(
+        r#"
+        e = enumerate(['a', 'b'], 10)
+        assert_eq(e, [(10, 'a'), (11, 'b')])
+    "#,
+    );
+}
+
+#[test]
+fn test_enumerate_string() {
+    assert::pass(
+        r#"
+        e = enumerate("ab")
+        assert_eq(e, [(0, "a"), (1, "b")])
+    "#,
+    );
+}
+
+#[test]
+fn test_enumerate_empty() {
+    assert::pass(
+        r#"
+        assert_eq(enumerate([]), [])
+        assert_eq(enumerate(""), [])
+    "#,
+    );
+}
+
+#[test]
+fn test_enumerate_errors() {
+    assert::fail("enumerate()", "enumerate() takes at least one argument");
+    assert::fail(
+        "enumerate([1], 'a')",
+        "enumerate() start must be an integer",
+    );
+    assert::fail("enumerate(1)", "Type '\"int\"' is not iterable");
+}
+
+#[test]
+fn test_enumerate_set() {
+    // Sets are unordered, so we check existence of tuples
+    assert::pass(
+        r#"
+        s = {1}
+        e = enumerate(s)
+        assert_eq(len(e), 1)
+        assert_eq(e[0][0], 0)
+        assert_eq(e[0][1], 1)
+    "#,
+    );
+}

implants/lib/eldritchv2/eldritch-core/tests/range_coverage.rs

@@ -0,0 +1,90 @@
+mod assert;
+
+#[test]
+fn test_range_one_arg() {
+    assert::pass(
+        r#"
+        r = range(5)
+        assert_eq(r, [0, 1, 2, 3, 4])
+        assert_eq(len(r), 5)
+    "#,
+    );
+}
+
+#[test]
+fn test_range_two_args() {
+    assert::pass(
+        r#"
+        r = range(1, 6)
+        assert_eq(r, [1, 2, 3, 4, 5])
+        assert_eq(len(r), 5)
+    "#,
+    );
+}
+
+#[test]
+fn test_range_three_args() {
+    assert::pass(
+        r#"
+        r = range(0, 10, 2)
+        assert_eq(r, [0, 2, 4, 6, 8])
+        assert_eq(len(r), 5)
+    "#,
+    );
+}
+
+#[test]
+fn test_range_negative_step() {
+    assert::pass(
+        r#"
+        r = range(5, 0, -1)
+        assert_eq(r, [5, 4, 3, 2, 1])
+        assert_eq(len(r), 5)
+    "#,
+    );
+}
+
+#[test]
+fn test_range_zero_step() {
+    assert::fail(
+        r#"
+        range(0, 10, 0)
+    "#,
+        "ValueError: range() arg 3 must not be zero",
+    );
+}
+
+#[test]
+fn test_range_empty() {
+    assert::pass(
+        r#"
+        r = range(0)
+        assert_eq(r, [])
+        r = range(10, 0)
+        assert_eq(r, [])
+        r = range(0, 10, -1)
+        assert_eq(r, [])
+    "#,
+    );
+}
+
+#[test]
+fn test_range_types() {
+    assert::fail(
+        "range('a')",
+        "TypeError: range expects 1-3 integer arguments",
+    );
+    assert::fail(
+        "range(1, 'b')",
+        "TypeError: range expects 1-3 integer arguments",
+    );
+    assert::fail(
+        "range(1, 2, 'c')",
+        "TypeError: range expects 1-3 integer arguments",
+    );
+    assert::fail("range()", "TypeError: range expects 1-3 integer arguments");
+    assert::fail(
+        "range(1, 2, 3, 4)",
+        "TypeError: range expects 1-3 integer arguments",
+    );
+}

implants/lib/eldritchv2/eldritch-core/tests/reversed_coverage.rs

@@ -0,0 +1,57 @@
+mod assert;
+
+#[test]
+fn test_reversed_list() {
+    assert::pass(
+        r#"
+        r = reversed([1, 2, 3])
+        assert_eq(r, [3, 2, 1])
+    "#,
+    );
+}
+
+#[test]
+fn test_reversed_tuple() {
+    assert::pass(
+        r#"
+        r = reversed((1, 2, 3))
+        assert_eq(r, [3, 2, 1])
+    "#,
+    );
+}
+
+#[test]
+fn test_reversed_string() {
+    assert::pass(
+        r#"
+        r = reversed("abc")
+        assert_eq(r, ["c", "b", "a"])
+    "#,
+    );
+}
+
+#[test]
+fn test_reversed_empty() {
+    assert::pass(
+        r#"
+        assert_eq(reversed([]), [])
+        assert_eq(reversed(()), [])
+        assert_eq(reversed(""), [])
+    "#,
+    );
+}
+
+#[test]
+fn test_reversed_errors() {
+    assert::fail(
+        "reversed()",
+        "reversed() takes exactly one argument (0 given)",
+    );
+    assert::fail(
+        "reversed(1, 2)",
+        "reversed() takes exactly one argument (2 given)",
+    );
+    assert::fail("reversed(1)", "'int' object is not reversible");
+    assert::fail("reversed({'a': 1})", "'dict' object is not reversible");
+    assert::fail("reversed({1, 2})", "'set' object is not reversible");
+}