Feature/improve unit tests coverage

src/ast/query.rs

@@ -211,4 +211,243 @@ mod tests {
         let expr5: Expr<Fr, Queriable<Fr>> = Expr::Pow(Box::new(Expr::Const(a)), 2);
         assert_eq!(format!("{:?}", expr5), "(0xa)^2");
     }
+
+    #[test]
+    fn test_add_fmt() {
+        let a: Fr = 10.into();
+        let b: Fr = 20.into();
+
+        let expr2: Expr<Fr, Queriable<Fr>> = Expr::Const(a) + Expr::Const(b);
+        let expr2_vec: Expr<Fr, Queriable<Fr>> = Expr::Sum(vec![Expr::Const(a), Expr::Const(b)]);
+        assert_eq!(
+            format!("{:?}", expr2),
+            format!("{:?}", expr2_vec),
+            "(0xa + 0x14)"
+        );
+
+        let expr3: Expr<Fr, Queriable<Fr>> = Expr::Const(a) + Expr::Const(b) + Expr::Const(a);
+        let expr3_vec: Expr<Fr, Queriable<Fr>> =
+            Expr::Sum(vec![Expr::Const(a), Expr::Const(b), Expr::Const(a)]);
+        assert_eq!(
+            format!("{:?}", expr3),
+            format!("{:?}", expr3_vec),
+            "(0xa + 0x14 + 0xa)"
+        );
+    }
+
+    #[test]
+    fn test_sub_fmt() {
+        let a: Fr = 10.into();
+        let b: Fr = 20.into();
+
+        let expr2: Expr<Fr, Queriable<Fr>> = Expr::Const(a) - Expr::Const(b);
+        let expr2_vec: Expr<Fr, Queriable<Fr>> =
+            Expr::Sum(vec![Expr::Const(a), Expr::Const(b).neg()]);
+        assert_eq!(
+            format!("{:?}", expr2),
+            format!("{:?}", expr2_vec),
+            "(0xa + (-0x14))"
+        );
+
+        let expr3: Expr<Fr, Queriable<Fr>> = Expr::Const(a) - Expr::Const(b) - Expr::Const(a);
+        let expr3_vec: Expr<Fr, Queriable<Fr>> = Expr::Sum(vec![
+            Expr::Const(a),
+            Expr::Const(b).neg(),
+            Expr::Const(a).neg(),
+        ]);
+        assert_eq!(
+            format!("{:?}", expr3),
+            format!("{:?}", expr3_vec),
+            "(0xa + (-0x14) + (-0xa))"
+        );
+    }
+
+    #[test]
+    fn test_mul_fmt() {
+        let a: Fr = 10.into();
+        let b: Fr = 20.into();
+
+        let expr2: Expr<Fr, Queriable<Fr>> = Expr::Const(a) * Expr::Const(b);
+        let expr2_vec: Expr<Fr, Queriable<Fr>> = Expr::Mul(vec![Expr::Const(a), Expr::Const(b)]);
+        assert_eq!(
+            format!("{:?}", expr2),
+            format!("{:?}", expr2_vec),
+            "(0xa * 0x14)"
+        );
+
+        let expr3: Expr<Fr, Queriable<Fr>> = Expr::Const(a) * Expr::Const(b) * Expr::Const(a);
+        let expr3_vec: Expr<Fr, Queriable<Fr>> =
+            Expr::Mul(vec![Expr::Const(a), Expr::Const(b), Expr::Const(a)]);
+        assert_eq!(
+            format!("{:?}", expr3),
+            format!("{:?}", expr3_vec),
+            "(0xa * 0x14 * 0xa)"
+        );
+    }
+
+    #[test]
+    fn test_neg_fmt() {
+        let a: Fr = 10.into();
+
+        let expr1: Expr<Fr, Queriable<Fr>> = Expr::Const(a).neg();
+        let expr1_box: Expr<Fr, Queriable<Fr>> = Expr::Neg(Box::new(Expr::Const(a)));
+        assert_eq!(format!("{:?}", expr1), format!("{:?}", expr1_box), "(-0xa)");
+    }
+
+    #[test]
+    fn test_next_for_forward_signal() {
+        let forward_signal = ForwardSignal {
+            id: 0,
+            phase: 0,
+            annotation: "",
+        };
+        let queriable: Queriable<Fr> = Queriable::Forward(forward_signal, false);
+        let next_queriable = queriable.next();
+
+        assert_eq!(next_queriable, Queriable::Forward(forward_signal, true));
+    }
+
+    #[test]
+    #[should_panic(expected = "jarrl: cannot rotate next(forward)")]
+    fn test_next_for_forward_signal_panic() {
+        let forward_signal = ForwardSignal {
+            id: 0,
+            phase: 0,
+            annotation: "",
+        };
+        let queriable: Queriable<Fr> = Queriable::Forward(forward_signal, true);
+        let _ = queriable.next(); // This should panic
+    }
+
+    #[test]
+    fn test_next_for_shared_signal() {
+        let shared_signal = SharedSignal {
+            id: 0,
+            phase: 0,
+            annotation: "",
+        };
+        let queriable: Queriable<Fr> = Queriable::Shared(shared_signal, 0);
+        let next_queriable = queriable.next();
+
+        assert_eq!(next_queriable, Queriable::Shared(shared_signal, 1));
+    }
+
+    #[test]
+    fn test_next_for_fixed_signal() {
+        let fixed_signal = FixedSignal {
+            id: 0,
+            annotation: "",
+        };
+        let queriable: Queriable<Fr> = Queriable::Fixed(fixed_signal, 0);
+        let next_queriable = queriable.next();
+
+        assert_eq!(next_queriable, Queriable::Fixed(fixed_signal, 1));
+    }
+
+    #[test]
+    #[should_panic(expected = "can only next a forward, shared, fixed, or halo2 column")]
+    fn test_next_for_internal_signal_panic() {
+        let internal_signal = InternalSignal {
+            id: 0,
+            annotation: "",
+        };
+        let queriable: Queriable<Fr> = Queriable::Internal(internal_signal);
+        let _ = queriable.next(); // This should panic
+    }
+
+    #[test]
+    fn test_prev_for_shared_signal() {
+        let shared_signal = SharedSignal {
+            id: 0,
+            phase: 0,
+            annotation: "",
+        };
+        let queriable: Queriable<Fr> = Queriable::Shared(shared_signal, 1);
+        let prev_queriable = queriable.prev();
+
+        assert_eq!(prev_queriable, Queriable::Shared(shared_signal, 0));
+    }
+
+    #[test]
+    fn test_prev_for_fixed_signal() {
+        let fixed_signal = FixedSignal {
+            id: 0,
+            annotation: "",
+        };
+        let queriable: Queriable<Fr> = Queriable::Fixed(fixed_signal, 1);
+        let prev_queriable = queriable.prev();
+
+        assert_eq!(prev_queriable, Queriable::Fixed(fixed_signal, 0));
+    }
+
+    #[test]
+    #[should_panic(expected = "can only prev a shared or fixed column")]
+    fn test_prev_for_forward_signal_panic() {
+        let forward_signal = ForwardSignal {
+            id: 0,
+            phase: 0,
+            annotation: "",
+        };
+        let queriable: Queriable<Fr> = Queriable::Forward(forward_signal, true);
+        let _ = queriable.prev(); // This should panic
+    }
+
+    #[test]
+    #[should_panic(expected = "can only prev a shared or fixed column")]
+    fn test_prev_for_internal_signal_panic() {
+        let internal_signal = InternalSignal {
+            id: 0,
+            annotation: "",
+        };
+        let queriable: Queriable<Fr> = Queriable::Internal(internal_signal);
+        let _ = queriable.prev(); // This should panic
+    }
+
+    #[test]
+    fn test_rot_for_shared_signal() {
+        let shared_signal = SharedSignal {
+            id: 0,
+            phase: 0,
+            annotation: "",
+        };
+        let queriable: Queriable<Fr> = Queriable::Shared(shared_signal, 1);
+        let rot_queriable = queriable.rot(2);
+
+        assert_eq!(rot_queriable, Queriable::Shared(shared_signal, 3));
+    }
+
+    #[test]
+    fn test_rot_for_fixed_signal() {
+        let fixed_signal = FixedSignal {
+            id: 0,
+            annotation: "",
+        };
+        let queriable: Queriable<Fr> = Queriable::Fixed(fixed_signal, 1);
+        let rot_queriable = queriable.rot(2);
+
+        assert_eq!(rot_queriable, Queriable::Fixed(fixed_signal, 3));
+    }
+
+    #[test]
+    #[should_panic(expected = "can only rot a shared or fixed column")]
+    fn test_rot_for_forward_signal_panic() {
+        let forward_signal = ForwardSignal {
+            id: 0,
+            phase: 0,
+            annotation: "",
+        };
+        let queriable: Queriable<Fr> = Queriable::Forward(forward_signal, true);
+        let _ = queriable.rot(2); // This should panic
+    }
+
+    #[test]
+    #[should_panic(expected = "can only rot a shared or fixed column")]
+    fn test_rot_for_internal_signal_panic() {
+        let internal_signal = InternalSignal {
+            id: 0,
+            annotation: "",
+        };
+        let queriable: Queriable<Fr> = Queriable::Internal(internal_signal);
+        let _ = queriable.rot(2); // This should panic
+    }
 }

src/frontend/dsl/cb.rs

@@ -720,4 +720,51 @@ mod tests {
                 matches!(v[1], Expr::Const(c) if c == 40u64.field())) &&
             matches!(v[1], Expr::Const(c) if c == 10u64.field())));
     }
+
+    #[test]
+    fn test_constraint_from_queriable() {
+        // Create a Queriable instance and convert it to a Constraint
+        let queriable = Queriable::StepTypeNext(StepTypeHandler::new("test_step".to_owned()));
+        let constraint: Constraint<Fr> = Constraint::from(queriable);
+
+        assert_eq!(constraint.annotation, "test_step");
+        assert!(
+            matches!(constraint.expr, Expr::Query(Queriable::StepTypeNext(s)) if
+            matches!(s, StepTypeHandler {id: _id, annotation: "test_step"}))
+        );
+        assert!(matches!(constraint.typing, Typing::Boolean));
+    }
+
+    #[test]
+    fn test_constraint_from_expr() {
+        // Create an expression and convert it to a Constraint
+        let expr = <u64 as ToExpr<Fr, Queriable<Fr>>>::expr(&10) * 20u64.expr();
+        let constraint: Constraint<Fr> = Constraint::from(expr);
+
+        // returns "10 * 20"
+        assert!(matches!(constraint.expr, Expr::Mul(v) if v.len() == 2 &&
+            matches!(v[0], Expr::Const(c) if c == 10u64.field()) &&
+            matches!(v[1], Expr::Const(c) if c == 20u64.field())));
+        assert!(matches!(constraint.typing, Typing::Unknown));
+    }
+
+    #[test]
+    fn test_constraint_from_int() {
+        // Create an integer and convert it to a Constraint
+        let constraint: Constraint<Fr> = Constraint::from(10);
+
+        // returns "10"
+        assert!(matches!(constraint.expr, Expr::Const(c) if c == 10u64.field()));
+        assert!(matches!(constraint.typing, Typing::Unknown));
+    }
+
+    #[test]
+    fn test_constraint_from_bool() {
+        // Create a boolean and convert it to a Constraint
+        let constraint: Constraint<Fr> = Constraint::from(true);
+
+        assert_eq!(constraint.annotation, "0x1");
+        assert!(matches!(constraint.expr, Expr::Const(c) if c == 1u64.field()));
+        assert!(matches!(constraint.typing, Typing::Unknown));
+    }
 }