Tests: Coverage Expansion and Refinement

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

@@ -0,0 +1,62 @@
+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,78 @@
+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,54 @@
+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");
+}

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

@@ -0,0 +1,65 @@
+mod assert;
+
+#[test]
+fn test_zip_two_lists() {
+    assert::pass(
+        r#"
+        z = zip([1, 2], [3, 4])
+        assert_eq(z, [(1, 3), (2, 4)])
+    "#,
+    );
+}
+
+#[test]
+fn test_zip_mixed_types() {
+    assert::pass(
+        r#"
+        z = zip([1, 2], "ab", (3, 4))
+        assert_eq(z, [(1, "a", 3), (2, "b", 4)])
+    "#,
+    );
+}
+
+#[test]
+fn test_zip_uneven() {
+    assert::pass(
+        r#"
+        z = zip([1, 2, 3], [4, 5])
+        assert_eq(z, [(1, 4), (2, 5)])
+
+        z = zip([1, 2], [3, 4, 5])
+        assert_eq(z, [(1, 3), (2, 4)])
+    "#,
+    );
+}
+
+#[test]
+fn test_zip_empty() {
+    assert::pass(
+        r#"
+        assert_eq(zip(), [])
+        assert_eq(zip([]), [])
+        assert_eq(zip([], [1, 2]), [])
+    "#,
+    );
+}
+
+#[test]
+fn test_zip_sets_dicts() {
+    // Sets and Dicts are unordered, so we can't guarantee the order of zipped elements
+    // But we can check the length and that the elements are valid
+    assert::pass(
+        r#"
+        s = {1, 2, 3}
+        d = {'a': 1, 'b': 2}
+        z = zip(s, d)
+        assert_eq(len(z), 2) # min len of 3 and 2 is 2
+    "#,
+    );
+}
+
+#[test]
+fn test_zip_errors() {
+    assert::fail("zip(1)", "'int' object is not iterable");
+    assert::fail("zip([1], 1)", "'int' object is not iterable");
+}