Generalized test functions

- created a test function to generate add/calyx_go_done transactions
from their corresponding source code

Author: fpham0701

src/diagnostic.rs

@@ -166,7 +166,7 @@ impl DiagnosticHandler {
 
 #[cfg(test)]
 mod tests {
-    use crate::typecheck::*;
+    use crate::{serialize::tests::create_calyx_go_down_transaction, typecheck::*};
 
     use super::*;
     use baa::BitVecValue;
@@ -198,86 +198,8 @@ mod tests {
 
     #[test]
     fn serialize_calyx_go_down_transaction() {
-        // Manually create the expected result of parsing `calyx_go_down`.
-        // Note that the order in which things are created will be different in the parser.
-
-        // 1) declare symbols
-        let mut symbols = SymbolTable::default();
-        let mut handler: DiagnosticHandler = DiagnosticHandler::new();
-        let ii = symbols.add_without_parent("ii".to_string(), Type::BitVec(32));
-        let oo = symbols.add_without_parent("oo".to_string(), Type::BitVec(32));
-        assert_eq!(symbols["oo"], symbols[oo]);
-
-        // declare Calyx struct
-        let dut_struct = symbols.add_struct(
-            "Calyx".to_string(),
-            vec![
-                Field::new("ii".to_string(), Dir::In, Type::BitVec(32)),
-                Field::new("go".to_string(), Dir::In, Type::BitVec(1)),
-                Field::new("done".to_string(), Dir::Out, Type::BitVec(1)),
-                Field::new("oo".to_string(), Dir::Out, Type::BitVec(32)),
-            ],
-        );
-
-        let dut = symbols.add_without_parent("dut".to_string(), Type::Struct(dut_struct));
-        let dut_ii = symbols.add_with_parent("ii".to_string(), dut);
-        let dut_go = symbols.add_with_parent("go".to_string(), dut);
-        let dut_done = symbols.add_with_parent("done".to_string(), dut);
-        let dut_oo = symbols.add_with_parent("oo".to_string(), dut);
-        assert_eq!(symbols["dut.oo"], symbols[dut_oo]);
-        assert_eq!(symbols["oo"], symbols[oo]);
-
-        // create fileid and read file
-        let input =
-            std::fs::read_to_string("tests/calyx_go_doneStruct.prot").expect("failed to load");
-        let calyx_fileid = handler.add_file("calyx_go_done.prot".to_string(), input);
-
-        // 2) create transaction
-        let mut calyx_go_done = Transaction::new("calyx_go_done".to_string());
-        calyx_go_done.args = vec![Arg::new(ii, Dir::In), Arg::new(oo, Dir::Out)];
-        calyx_go_done.type_args = vec![dut];
-
-        // 3) create expressions
-        let ii_expr = calyx_go_done.e(Expr::Sym(ii));
-        calyx_go_done.add_expr_loc(ii_expr, 153, 155, calyx_fileid);
-        let dut_oo_expr = calyx_go_done.e(Expr::Sym(dut_oo));
-        calyx_go_done.add_expr_loc(dut_oo_expr, 260, 266, calyx_fileid);
-        let one_expr = calyx_go_done.e(Expr::Const(BitVecValue::from_u64(1, 1)));
-        calyx_go_done.add_expr_loc(one_expr, 170, 171, calyx_fileid);
-        let zero_expr = calyx_go_done.e(Expr::Const(BitVecValue::from_u64(0, 1)));
-        calyx_go_done.add_expr_loc(zero_expr, 232, 233, calyx_fileid);
-        let dut_done_expr = calyx_go_done.e(Expr::Sym(dut_done));
-        calyx_go_done.add_expr_loc(dut_done_expr, 184, 192, calyx_fileid);
-        let cond_expr = calyx_go_done.e(Expr::Equal(dut_done_expr, one_expr));
-        calyx_go_done.add_expr_loc(cond_expr, 183, 198, calyx_fileid);
-        let not_expr = calyx_go_done.e(Expr::Not(cond_expr));
-        calyx_go_done.add_expr_loc(not_expr, 182, 198, calyx_fileid);
-
-        // 4) create statements
-        let while_body = vec![calyx_go_done.s(Stmt::Step)];
-        let wbody = calyx_go_done.s(Stmt::Block(while_body));
-
-        let dut_ii_assign = calyx_go_done.s(Stmt::Assign(dut_ii, ii_expr));
-        calyx_go_done.add_stmt_loc(dut_ii_assign, 143, 157, calyx_fileid);
-        let dut_go_assign = calyx_go_done.s(Stmt::Assign(dut_go, one_expr));
-        calyx_go_done.add_stmt_loc(dut_go_assign, 160, 172, calyx_fileid);
-        let dut_while = calyx_go_done.s(Stmt::While(not_expr, wbody));
-        calyx_go_done.add_stmt_loc(dut_while, 175, 219, calyx_fileid);
-        let dut_go_reassign = calyx_go_done.s(Stmt::Assign(dut_go, zero_expr));
-        calyx_go_done.add_stmt_loc(dut_go_reassign, 222, 234, calyx_fileid);
-        let dut_ii_dontcare = calyx_go_done.s(Stmt::Assign(dut_ii, calyx_go_done.expr_dont_care()));
-        calyx_go_done.add_stmt_loc(dut_ii_dontcare, 238, 250, calyx_fileid);
-        let oo_assign = calyx_go_done.s(Stmt::Assign(oo, dut_oo_expr));
-        calyx_go_done.add_stmt_loc(oo_assign, 254, 268, calyx_fileid);
-        let body = vec![
-            dut_ii_assign,
-            dut_go_assign,
-            dut_while,
-            dut_go_reassign,
-            dut_ii_dontcare,
-            oo_assign,
-        ];
-        calyx_go_done.body = calyx_go_done.s(Stmt::Block(body));
+        let mut handler = DiagnosticHandler::new();
+        let (calyx_go_done, symbols) = create_calyx_go_down_transaction(&mut handler);
         type_check(&calyx_go_done, &symbols, &mut handler);
     }
 }

src/serialize.rs

@@ -179,8 +179,7 @@ pub mod tests {
 
     use super::*;
 
-    #[test]
-    fn serialize_add_transaction() {
+    pub fn create_add_transaction(handler: &mut DiagnosticHandler) -> (Transaction, SymbolTable) {
         // Manually create the expected result of parsing `add.prot`.
         // Note that the order in which things are created will be different in the parser.
 
@@ -209,6 +208,10 @@ pub mod tests {
         assert_eq!(symbols["DUT.s"], symbols[dut_s]);
         assert_eq!(symbols["s"], symbols[s]);
 
+        // create fileid and read file
+        let input = std::fs::read_to_string("tests/addStruct.prot").expect("failed to load");
+        let add_fileid = handler.add_file("add.prot".to_string(), input);
+
         // 2) create transaction
         let mut add = Transaction::new("add".to_string());
         add.args = vec![
@@ -220,31 +223,47 @@ pub mod tests {
 
         // 3) create expressions
         let a_expr = add.e(Expr::Sym(a));
+        add.add_expr_loc(a_expr, 193, 194, add_fileid);
         let b_expr = add.e(Expr::Sym(b));
+        add.add_expr_loc(b_expr, 208, 209, add_fileid);
         let dut_s_expr = add.e(Expr::Sym(dut_s));
+        add.add_expr_loc(dut_s_expr, 271, 276, add_fileid);
 
         // 4) create statements
+        let a_assign = add.s(Stmt::Assign(dut_a, a_expr));
+        add.add_stmt_loc(a_assign, 184, 195, add_fileid);
+        let b_assign = add.s(Stmt::Assign(dut_b, b_expr));
+        add.add_stmt_loc(b_assign, 199, 210, add_fileid);
+        let step = add.s(Stmt::Step);
+        add.add_stmt_loc(step, 214, 221, add_fileid);
+        let fork = add.s(Stmt::Fork);
+        add.add_stmt_loc(fork, 225, 232, add_fileid);
+        let dut_a_assign = add.s(Stmt::Assign(dut_a, add.expr_dont_care()));
+        add.add_stmt_loc(dut_a_assign, 236, 247, add_fileid);
+        let dut_b_assign = add.s(Stmt::Assign(dut_b, add.expr_dont_care()));
+        add.add_stmt_loc(dut_b_assign, 251, 262, add_fileid);
+        let s_assign = add.s(Stmt::Assign(s, dut_s_expr));
+        add.add_stmt_loc(s_assign, 266, 277, add_fileid);
         let body = vec![
-            add.s(Stmt::Assign(dut_a, a_expr)),
-            add.s(Stmt::Assign(dut_b, b_expr)),
-            add.s(Stmt::Step),
-            add.s(Stmt::Fork),
-            add.s(Stmt::Assign(dut_a, add.expr_dont_care())),
-            add.s(Stmt::Assign(dut_b, add.expr_dont_care())),
-            add.s(Stmt::Assign(s, dut_s_expr)),
+            a_assign,
+            b_assign,
+            step,
+            fork,
+            dut_a_assign,
+            dut_b_assign,
+            s_assign,
         ];
         add.body = add.s(Stmt::Block(body));
 
-        println!("{}", serialize_to_string(&add, &symbols).unwrap());
+        (add, symbols)
     }
 
-    #[test]
-    fn serialize_calyx_go_down_transaction() {
+    pub fn create_calyx_go_down_transaction(
+        handler: &mut DiagnosticHandler,
+    ) -> (Transaction, SymbolTable) {
         // Manually create the expected result of parsing `calyx_go_down`.
         // Note that the order in which things are created will be different in the parser.
 
-        // TODO: create this into function that factors our the code to put src code into IR
-
         // 1) declare symbols
         let mut symbols = SymbolTable::default();
         let ii = symbols.add_without_parent("ii".to_string(), Type::BitVec(32));
@@ -256,7 +275,7 @@ pub mod tests {
             "Calyx".to_string(),
             vec![
                 Field::new("ii".to_string(), Dir::In, Type::BitVec(32)),
-                Field::new("go".to_string(), Dir::In, Type::BitVec(1)),
+                Field::new("go".to_string(), Dir::In, Type::BitVec(32)),
                 Field::new("done".to_string(), Dir::Out, Type::BitVec(1)),
                 Field::new("oo".to_string(), Dir::Out, Type::BitVec(32)),
             ],
@@ -270,30 +289,48 @@ pub mod tests {
         assert_eq!(symbols["dut.oo"], symbols[dut_oo]);
         assert_eq!(symbols["oo"], symbols[oo]);
 
+        // create fileid and read file
+        let input =
+            std::fs::read_to_string("tests/calyx_go_doneStruct.prot").expect("failed to load");
+        let calyx_fileid = handler.add_file("calyx_go_done.prot".to_string(), input);
+
         // 2) create transaction
         let mut calyx_go_done = Transaction::new("calyx_go_done".to_string());
         calyx_go_done.args = vec![Arg::new(ii, Dir::In), Arg::new(oo, Dir::Out)];
         calyx_go_done.type_args = vec![dut];
 
         // 3) create expressions
         let ii_expr = calyx_go_done.e(Expr::Sym(ii));
+        calyx_go_done.add_expr_loc(ii_expr, 153, 155, calyx_fileid);
         let dut_oo_expr = calyx_go_done.e(Expr::Sym(dut_oo));
+        calyx_go_done.add_expr_loc(dut_oo_expr, 260, 266, calyx_fileid);
         let one_expr = calyx_go_done.e(Expr::Const(BitVecValue::from_u64(1, 1)));
+        calyx_go_done.add_expr_loc(one_expr, 170, 171, calyx_fileid);
         let zero_expr = calyx_go_done.e(Expr::Const(BitVecValue::from_u64(0, 1)));
+        calyx_go_done.add_expr_loc(zero_expr, 232, 233, calyx_fileid);
         let dut_done_expr = calyx_go_done.e(Expr::Sym(dut_done));
+        calyx_go_done.add_expr_loc(dut_done_expr, 184, 192, calyx_fileid);
         let cond_expr = calyx_go_done.e(Expr::Equal(dut_done_expr, one_expr));
+        calyx_go_done.add_expr_loc(cond_expr, 183, 198, calyx_fileid);
         let not_expr = calyx_go_done.e(Expr::Not(cond_expr));
+        calyx_go_done.add_expr_loc(not_expr, 182, 198, calyx_fileid);
 
         // 4) create statements
         let while_body = vec![calyx_go_done.s(Stmt::Step)];
         let wbody = calyx_go_done.s(Stmt::Block(while_body));
 
         let dut_ii_assign = calyx_go_done.s(Stmt::Assign(dut_ii, ii_expr));
-        let dut_go_assign = calyx_go_done.s(Stmt::Assign(dut_go, one_expr));
+        calyx_go_done.add_stmt_loc(dut_ii_assign, 143, 157, calyx_fileid);
+        let dut_go_assign = calyx_go_done.s(Stmt::Assign(dut_go, one_expr)); // Should cause type mismatch error
+        calyx_go_done.add_stmt_loc(dut_go_assign, 160, 172, calyx_fileid);
         let dut_while = calyx_go_done.s(Stmt::While(not_expr, wbody));
-        let dut_go_reassign = calyx_go_done.s(Stmt::Assign(dut_go, zero_expr));
+        calyx_go_done.add_stmt_loc(dut_while, 175, 219, calyx_fileid);
+        let dut_go_reassign = calyx_go_done.s(Stmt::Assign(dut_go, zero_expr)); // Should cause type mismatch error
+        calyx_go_done.add_stmt_loc(dut_go_reassign, 222, 234, calyx_fileid);
         let dut_ii_dontcare = calyx_go_done.s(Stmt::Assign(dut_ii, calyx_go_done.expr_dont_care()));
+        calyx_go_done.add_stmt_loc(dut_ii_dontcare, 238, 250, calyx_fileid);
         let oo_assign = calyx_go_done.s(Stmt::Assign(oo, dut_oo_expr));
+        calyx_go_done.add_stmt_loc(oo_assign, 254, 268, calyx_fileid);
         let body = vec![
             dut_ii_assign,
             dut_go_assign,
@@ -303,6 +340,22 @@ pub mod tests {
             oo_assign,
         ];
         calyx_go_done.body = calyx_go_done.s(Stmt::Block(body));
+
+        (calyx_go_done, symbols)
+    }
+
+    #[test]
+    fn serialize_add_transaction() {
+        let mut handler = DiagnosticHandler::new();
+        let (add, symbols) = create_add_transaction(&mut handler);
+
+        println!("{}", serialize_to_string(&add, &symbols).unwrap());
+    }
+
+    #[test]
+    fn serialize_calyx_go_down_transaction() {
+        let mut handler = DiagnosticHandler::new();
+        let (calyx_go_done, symbols) = create_calyx_go_down_transaction(&mut handler);
         println!("{}", serialize_to_string(&calyx_go_done, &symbols).unwrap());
     }
 

src/typecheck.rs

@@ -142,96 +142,23 @@ pub fn type_check(tr: &Transaction, st: &SymbolTable, handler: &mut DiagnosticHa
     }
 }
 
+#[cfg(test)]
 mod tests {
-    use baa::BitVecValue;
+    use crate::serialize::tests::{create_add_transaction, create_calyx_go_down_transaction};
 
     use super::*;
 
     #[test]
-    fn serialize_calyx_go_down_transaction() {
-        // Manually create the expected result of parsing `calyx_go_down`.
-        // Note that the order in which things are created will be different in the parser.
-
-        // TODO: create this into function that factors our the code to put src code into IR
-
-        // 1) declare symbols
-        let mut symbols = SymbolTable::default();
-        let mut handler: DiagnosticHandler = DiagnosticHandler::new();
-
-        let ii = symbols.add_without_parent("ii".to_string(), Type::BitVec(32));
-        let oo = symbols.add_without_parent("oo".to_string(), Type::BitVec(32));
-        assert_eq!(symbols["oo"], symbols[oo]);
-
-        // declare Calyx struct
-        let dut_struct = symbols.add_struct(
-            "Calyx".to_string(),
-            vec![
-                Field::new("ii".to_string(), Dir::In, Type::BitVec(32)),
-                Field::new("go".to_string(), Dir::In, Type::BitVec(32)),
-                Field::new("done".to_string(), Dir::Out, Type::BitVec(1)),
-                Field::new("oo".to_string(), Dir::Out, Type::BitVec(32)),
-            ],
-        );
-
-        let dut = symbols.add_without_parent("dut".to_string(), Type::Struct(dut_struct));
-        let dut_ii = symbols.add_with_parent("ii".to_string(), dut);
-        let dut_go = symbols.add_with_parent("go".to_string(), dut);
-        let dut_done = symbols.add_with_parent("done".to_string(), dut);
-        let dut_oo = symbols.add_with_parent("oo".to_string(), dut);
-        assert_eq!(symbols["dut.oo"], symbols[dut_oo]);
-        assert_eq!(symbols["oo"], symbols[oo]);
-
-        // create fileid and read file
-        let input =
-            std::fs::read_to_string("tests/calyx_go_doneStruct.prot").expect("failed to load");
-        let calyx_fileid = handler.add_file("calyx_go_done.prot".to_string(), input);
-
-        // 2) create transaction
-        let mut calyx_go_done = Transaction::new("calyx_go_done".to_string());
-        calyx_go_done.args = vec![Arg::new(ii, Dir::In), Arg::new(oo, Dir::Out)];
-        calyx_go_done.type_args = vec![dut];
-
-        // 3) create expressions
-        let ii_expr = calyx_go_done.e(Expr::Sym(ii));
-        calyx_go_done.add_expr_loc(ii_expr, 153, 155, calyx_fileid);
-        let dut_oo_expr = calyx_go_done.e(Expr::Sym(dut_oo));
-        calyx_go_done.add_expr_loc(dut_oo_expr, 260, 266, calyx_fileid);
-        let one_expr = calyx_go_done.e(Expr::Const(BitVecValue::from_u64(1, 1)));
-        calyx_go_done.add_expr_loc(one_expr, 170, 171, calyx_fileid);
-        let zero_expr = calyx_go_done.e(Expr::Const(BitVecValue::from_u64(0, 1)));
-        calyx_go_done.add_expr_loc(zero_expr, 232, 233, calyx_fileid);
-        let dut_done_expr = calyx_go_done.e(Expr::Sym(dut_done));
-        calyx_go_done.add_expr_loc(dut_done_expr, 184, 192, calyx_fileid);
-        let cond_expr = calyx_go_done.e(Expr::Equal(dut_done_expr, one_expr));
-        calyx_go_done.add_expr_loc(cond_expr, 183, 198, calyx_fileid);
-        let not_expr = calyx_go_done.e(Expr::Not(cond_expr));
-        calyx_go_done.add_expr_loc(not_expr, 182, 198, calyx_fileid);
-
-        // 4) create statements
-        let while_body = vec![calyx_go_done.s(Stmt::Step)];
-        let wbody = calyx_go_done.s(Stmt::Block(while_body));
+    fn typecheck_add_transaction() {
+        let mut handler = DiagnosticHandler::new();
+        let (add, symbols) = create_add_transaction(&mut handler);
+        type_check(&add, &symbols, &mut handler);
+    }
 
-        let dut_ii_assign = calyx_go_done.s(Stmt::Assign(dut_ii, ii_expr));
-        calyx_go_done.add_stmt_loc(dut_ii_assign, 143, 157, calyx_fileid);
-        let dut_go_assign = calyx_go_done.s(Stmt::Assign(dut_go, one_expr));
-        calyx_go_done.add_stmt_loc(dut_go_assign, 160, 172, calyx_fileid);
-        let dut_while = calyx_go_done.s(Stmt::While(not_expr, wbody));
-        calyx_go_done.add_stmt_loc(dut_while, 175, 219, calyx_fileid);
-        let dut_go_reassign = calyx_go_done.s(Stmt::Assign(dut_go, zero_expr));
-        calyx_go_done.add_stmt_loc(dut_go_reassign, 222, 234, calyx_fileid);
-        let dut_ii_dontcare = calyx_go_done.s(Stmt::Assign(dut_ii, calyx_go_done.expr_dont_care()));
-        calyx_go_done.add_stmt_loc(dut_ii_dontcare, 238, 250, calyx_fileid);
-        let oo_assign = calyx_go_done.s(Stmt::Assign(oo, dut_oo_expr));
-        calyx_go_done.add_stmt_loc(oo_assign, 254, 268, calyx_fileid);
-        let body = vec![
-            dut_ii_assign,
-            dut_go_assign,
-            dut_while,
-            dut_go_reassign,
-            dut_ii_dontcare,
-            oo_assign,
-        ];
-        calyx_go_done.body = calyx_go_done.s(Stmt::Block(body));
+    #[test]
+    fn typecheck_calyx_go_down_transaction() {
+        let mut handler = DiagnosticHandler::new();
+        let (calyx_go_done, symbols) = create_calyx_go_down_transaction(&mut handler);
         type_check(&calyx_go_done, &symbols, &mut handler);
     }
 }