feat: test gen mut ident

Author: simon-something

crates/forge/src/mutation/mutators/mod.rs

@@ -19,6 +19,7 @@ pub trait Mutator {
     fn is_applicable(&self, ctxt: &MutationContext<'_>) -> bool;
 }
 
+#[derive(Debug)]
 pub struct MutationContext<'a> {
     pub span: Span,
     /// The expression to mutate

crates/forge/src/mutation/mutators/tests/assignement_mutator_test.rs

@@ -2,6 +2,7 @@ use crate::mutation::{
     mutant::{Mutant, MutationType},
     mutators::{assignement_mutator::AssignmentMutator, MutationContext, Mutator},
     visitor::AssignVarTypes,
+    Session,
 };
 use solar_parse::{
     ast::{
@@ -11,43 +12,35 @@ use solar_parse::{
     interface::BytePos,
 };
 
-use num_bigint::BigInt;
-use std::path::PathBuf;
-
-use crate::mutation::Session;
+use super::*;
 
 fn create_span(start: u32, end: u32) -> Span {
     Span::new(BytePos(start), BytePos(end))
 }
 
-fn create_ident<'ident>(ident: String) -> ExprKind<'ident> {
-    ExprKind::Ident(Ident::from_str(&ident))
-}
-
 #[test]
 fn test_is_applicable_for_assign_expr() {
-    let sess = Session::builder().with_silent_emitter(None).build();
-
-    let _ = sess.enter(|| -> solar_parse::interface::Result<()> {
-        let arena = Arena::new();
-        let span = create_span(10, 20);
-
-        // x = 23
-        let left = arena.alloc(Expr { kind: create_ident("x".into()), span });
+    let arena = Arena::new();
+    let span = create_span(10, 20);
 
-        let mut val = Lit { span, symbol: Symbol::DUMMY, kind: LitKind::Number(23.into()) };
+    // x = 23
+    let left = arena.alloc(Expr {
+        kind: ExprKind::Ident(Ident { name: Symbol::DUMMY, span }), /* we use dummy symbol to
+                                                                     * avoid having to enter a
+                                                                     * session */
+        span,
+    });
 
-        let right = arena.alloc(Expr { kind: ExprKind::Lit(&mut val, None), span });
+    let mut val = Lit { span, symbol: Symbol::DUMMY, kind: LitKind::Number(23.into()) };
 
-        let expr = arena.alloc(Expr { kind: ExprKind::Assign(left, None, right), span });
+    let right = arena.alloc(Expr { kind: ExprKind::Lit(&mut val, None), span });
 
-        let context = MutationContext { expr: Some(expr), var_definition: None, span };
+    let expr = arena.alloc(Expr { kind: ExprKind::Assign(left, None, right), span });
 
-        let mutator = AssignmentMutator;
-        assert!(mutator.is_applicable(&context));
+    let context = MutationContext { expr: Some(expr), var_definition: None, span };
 
-        Ok(())
-    });
+    let mutator = AssignmentMutator;
+    assert!(mutator.is_applicable(&context));
 }
 
 #[test]
@@ -79,7 +72,6 @@ fn test_is_applicable_for_var_definition() {
 
 #[test]
 fn test_is_not_applicable_no_initializer() {
-    let arena = Arena::new();
     let span = create_span(10, 20);
 
     let var_def = VariableDefinition {
@@ -99,3 +91,108 @@ fn test_is_not_applicable_no_initializer() {
     let mutator = AssignmentMutator;
     assert!(!mutator.is_applicable(&context));
 }
+
+#[test]
+fn test_generate_bool_mutants() {
+    let arena = Arena::new();
+    let span = create_span(10, 20);
+
+    let sess = Session::builder().with_silent_emitter(None).build();
+
+    let _ = sess.enter(|| -> solar_parse::interface::Result<()> {
+        let mut val = Lit { span, symbol: Symbol::default(), kind: LitKind::Bool(true) };
+
+        let lit = arena.alloc(Expr { kind: ExprKind::Lit(&mut val, None), span });
+
+        let context = MutationContext { expr: Some(lit), var_definition: None, span };
+
+        let mutator = AssignmentMutator;
+        let mutants = mutator.generate_mutants(&context).unwrap();
+
+        assert_eq!(mutants.len(), 1);
+
+        if let MutationType::Assignment(AssignVarTypes::Literal(LitKind::Bool(val))) =
+            &mutants[0].mutation
+        {
+            assert_eq!(*val, false);
+        } else {
+            panic!("Expected boolean mutation");
+        }
+        Ok(())
+    });
+}
+
+#[test]
+fn test_generate_number_mutants() {
+    let arena = Arena::new();
+    let span = create_span(10, 20);
+
+    let mut val = Lit { span, symbol: Symbol::default(), kind: LitKind::Number(42.into()) };
+
+    let lit = arena.alloc(Expr { kind: ExprKind::Lit(&mut val, None), span });
+
+    let context = MutationContext { expr: Some(lit), var_definition: None, span };
+
+    let mutator = AssignmentMutator;
+    let mutants = mutator.generate_mutants(&context).unwrap();
+
+    assert_eq!(mutants.len(), 2);
+
+    // First mutant should set to zero
+    if let MutationType::Assignment(AssignVarTypes::Literal(LitKind::Number(val))) =
+        &mutants[0].mutation
+    {
+        assert_eq!(*val, num_bigint::BigInt::ZERO);
+    } else {
+        panic!("Expected number mutation to zero");
+    }
+
+    // Second mutant should negate the value
+    if let MutationType::Assignment(AssignVarTypes::Literal(LitKind::Number(val))) =
+        &mutants[1].mutation
+    {
+        assert_eq!(*val, -num_bigint::BigInt::from(42));
+    } else {
+        panic!("Expected negated number mutation");
+    }
+}
+
+#[test]
+fn test_generate_identifier_mutants() {
+    let arena = Arena::new();
+    let span = create_span(10, 20);
+
+    let sess = Session::builder().with_silent_emitter(None).build();
+
+    let _ = sess.enter(|| -> solar_parse::interface::Result<()> {
+        let expr = arena.alloc(Expr {
+            kind: ExprKind::Ident(Ident { name: Symbol::intern("varia"), span }),
+            span,
+        });
+
+        let context = MutationContext { expr: Some(expr), var_definition: None, span };
+
+        let mutator = AssignmentMutator;
+        let mutants = mutator.generate_mutants(&context).unwrap();
+
+        assert_eq!(mutants.len(), 2);
+
+        // First mutant should set to zero
+        if let MutationType::Assignment(AssignVarTypes::Literal(LitKind::Number(val))) =
+            &mutants[0].mutation
+        {
+            assert_eq!(*val, num_bigint::BigInt::ZERO);
+        } else {
+            panic!("Expected number mutation to zero");
+        }
+
+        // Second mutant should negate the identifier
+        if let MutationType::Assignment(AssignVarTypes::Identifier(val)) = &mutants[1].mutation {
+            assert_eq!(val, "-variable");
+        } else {
+            panic!("Expected negated identifier mutation");
+        }
+
+        Ok(())
+    });
+}