Add coverage tests for much of solc-expressions

crates/pyrometer/tests/no_killed_ctxs.rs

@@ -2,6 +2,14 @@ use std::env;
 mod helpers;
 use helpers::*;
 
+#[test]
+fn test_assign() {
+    let manifest_dir = env::var("CARGO_MANIFEST_DIR").unwrap();
+    let path_str = format!("{manifest_dir}/tests/test_data/assign.sol");
+    let sol = include_str!("./test_data/assign.sol");
+    assert_no_ctx_killed(path_str, sol);
+}
+
 #[test]
 fn test_bitwise() {
     let manifest_dir = env::var("CARGO_MANIFEST_DIR").unwrap();
@@ -10,6 +18,14 @@ fn test_bitwise() {
     assert_no_ctx_killed(path_str, sol);
 }
 
+#[test]
+fn test_binop() {
+    let manifest_dir = env::var("CARGO_MANIFEST_DIR").unwrap();
+    let path_str = format!("{manifest_dir}/tests/test_data/bin_op.sol");
+    let sol = include_str!("./test_data/bin_op.sol");
+    assert_no_ctx_killed(path_str, sol);
+}
+
 #[test]
 fn test_cast() {
     let manifest_dir = env::var("CARGO_MANIFEST_DIR").unwrap();
@@ -18,6 +34,21 @@ fn test_cast() {
     assert_no_ctx_killed(path_str, sol);
 }
 
+#[test]
+fn test_condop() {
+    let manifest_dir = env::var("CARGO_MANIFEST_DIR").unwrap();
+    let path_str = format!("{manifest_dir}/tests/test_data/cond_op.sol");
+    assert_no_parse_errors(path_str);
+}
+
+#[test]
+fn test_delete() {
+    let manifest_dir = env::var("CARGO_MANIFEST_DIR").unwrap();
+    let path_str = format!("{manifest_dir}/tests/test_data/delete.sol");
+    let sol = include_str!("./test_data/delete.sol");
+    assert_no_ctx_killed(path_str, sol);
+}
+
 #[test]
 fn test_dyn_types() {
     let manifest_dir = env::var("CARGO_MANIFEST_DIR").unwrap();
@@ -42,6 +73,14 @@ fn test_function_calls() {
     assert_no_ctx_killed(path_str, sol);
 }
 
+#[test]
+fn test_literals() {
+    let manifest_dir = env::var("CARGO_MANIFEST_DIR").unwrap();
+    let path_str = format!("{manifest_dir}/tests/test_data/literals.sol");
+    let sol = include_str!("./test_data/literals.sol");
+    assert_no_ctx_killed(path_str, sol);
+}
+
 #[test]
 fn test_logical() {
     let manifest_dir = env::var("CARGO_MANIFEST_DIR").unwrap();
@@ -82,6 +121,13 @@ fn test_require() {
     assert_no_ctx_killed(path_str, sol);
 }
 
+#[test]
+fn test_require_with_killed() {
+    let manifest_dir = env::var("CARGO_MANIFEST_DIR").unwrap();
+    let path_str = format!("{manifest_dir}/tests/test_data/require_with_killed.sol");
+    assert_no_parse_errors(path_str);
+}
+
 #[test]
 fn test_using() {
     let manifest_dir = env::var("CARGO_MANIFEST_DIR").unwrap();
@@ -184,3 +230,11 @@ fn test_repros() {
         assert_no_parse_errors(path_str);
     }
 }
+
+#[test]
+fn test_variable() {
+    let manifest_dir = env::var("CARGO_MANIFEST_DIR").unwrap();
+    let path_str = format!("{manifest_dir}/tests/test_data/variable.sol");
+    let sol = include_str!("./test_data/variable.sol");
+    assert_no_ctx_killed(path_str, sol);
+}

crates/pyrometer/tests/test_data/assign.sol

@@ -0,0 +1,20 @@
+pragma solidity ^0.8.0;
+
+contract Assign {
+
+    function doAssignment() public {
+        // Multi-value LHS (tuple)
+        (uint x, uint y) = (uint16(1), 2);
+
+        // Single value RHS
+        uint z = 3;
+
+        (x, y) = (z, z);
+
+        // uint[2] memory a = [uint(1), uint(2)];
+        // uint[2] memory b = [uint(3), uint(4)];
+
+
+        // (a, b) = (b, a);
+    }
+}

crates/pyrometer/tests/test_data/bin_op.sol

@@ -0,0 +1,10 @@
+pragma solidity ^0.8.0;
+
+contract BinOp {
+
+    function testBinOp(int y) public {
+        int x = 1;
+        int z = 5 + x;
+        int a = x * y;
+    }
+}

crates/pyrometer/tests/test_data/cmp.sol

@@ -0,0 +1,10 @@
+pragma solidity ^0.8.0;
+
+contract Cmp {
+
+    function testCmp(int x) public {
+        uint a = 5;
+        bool b = (5 < 6) || (5 == 6 && 0 < 1); // Correct the tuple comparison
+
+    }
+}

crates/pyrometer/tests/test_data/cond_op.sol

@@ -0,0 +1,53 @@
+pragma solidity ^0.8.0;
+
+contract CondOp {
+
+    function if_both_possible(uint x) public returns (uint) {
+        if (x > 100) {
+            return 1;
+        } else {
+            return 2;
+        }
+    }
+
+    function if_first_possible() public returns (uint) {
+        uint x = 101;
+        if (x > 100) {
+            return 1;
+        } else {
+            return 2;
+        }
+    }
+
+    function if_second_possible() public returns (uint) {
+        uint x = 99;
+        if (x > 100) {
+            return 1;
+        } else {
+            return 2;
+        }
+    }
+
+    function if_neither_possible(uint x) public returns (uint) {
+        if (x > 100) {
+            require(x < 100); // not possible
+            return 1;
+        } else {
+            require(x > 100); // not possible
+            return 2;
+        }
+        return 0;
+    }
+
+
+    function ternaryParam(uint x) public returns (uint) {
+        uint y = x > 2 ? 1 : 2;
+        return y;
+    }
+
+    function ternaryLiteral() public returns (uint) {
+        uint y = 1 > 2 ? 1 : 2;
+        "pyro::variable::y::range::[2,2]";
+        return y;
+    }
+}