feat: assign mutator tests

Author: simon-something

crates/forge/src/mutation/mod.rs

@@ -29,17 +29,8 @@ pub struct MutationHandler {
 }
 
 impl MutationHandler {
-    pub fn new(
-        contract_to_mutate: PathBuf,
-        config: Arc<foundry_config::Config>,
-    ) -> Self {
-        Self {
-            contract_to_mutate,
-            src: Arc::default(),
-            mutations: vec![],
-            config,
-            temp_dir: None,
-        }
+    pub fn new(contract_to_mutate: PathBuf, config: Arc<foundry_config::Config>) -> Self {
+        Self { contract_to_mutate, src: Arc::default(), mutations: vec![], config, temp_dir: None }
     }
 
     /// Keep the source contract in memory (in the hashmap), as we'll use it to create the mutants
@@ -65,8 +56,8 @@ impl MutationHandler {
                 })?;
 
             let ast = parser.parse_file().map_err(|e| e.emit())?;
-            
-            let mut mutant_visitor = MutantVisitor { mutation_to_conduct: Vec::new()};
+
+            let mut mutant_visitor = MutantVisitor { mutation_to_conduct: Vec::new() };
             mutant_visitor.visit_source_unit(&ast);
             self.mutations.extend(mutant_visitor.mutation_to_conduct);
 
@@ -162,16 +153,12 @@ impl MutationHandler {
             let ty = entry.file_type()?;
 
             if ty.is_dir() {
-                Self::copy_dir_except(
-                    entry.path(),
-                    dst.as_ref().join(entry.file_name()),
-                    except,
-                )?;
+                Self::copy_dir_except(entry.path(), dst.as_ref().join(entry.file_name()), except)?;
             } else if entry.file_name() != except.file_name().unwrap_or_default() {
-                    // std::os::unix::fs::symlink(entry.path(),
-                    // &dst.as_ref().join(entry.file_name()))?; // and for windows, would be
-                    // std::os::windows::fs::symlink_file
-                    std::fs::copy(entry.path(), dst.as_ref().join(entry.file_name()))?;
+                // std::os::unix::fs::symlink(entry.path(),
+                // &dst.as_ref().join(entry.file_name()))?; // and for windows, would be
+                // std::os::windows::fs::symlink_file
+                std::fs::copy(entry.path(), dst.as_ref().join(entry.file_name()))?;
             }
         }
         Ok(())

crates/forge/src/mutation/mutant.rs

@@ -1,9 +1,8 @@
 // Generate mutants then run tests (reuse the whole unit test flow for now, including compilation to
 // select mutants) Use Solar:
-use solar_parse::ast::{BinOpKind, LitKind, Span, UnOpKind};
-use std::path::PathBuf ;
-use std::fmt::Display;
 use super::visitor::AssignVarTypes;
+use solar_parse::ast::{BinOpKind, LitKind, Span, UnOpKind};
+use std::{fmt::Display, path::PathBuf};
 
 /// Wraps an unary operator mutated, to easily store pre/post-fix op swaps
 #[derive(Debug)]
@@ -58,9 +57,8 @@ pub enum MutationType {
     // /// For a if(x) condition x:
     // /// replace x with true; replace x with false
     // This mutation is not used anymore, as we mutate the condition as an expression,
-    // which will creates true/false mutant as well as more complex conditions (eg if(foo++ > --bar)
-    // ) IfStatementMutation,
-
+    // which will creates true/false mutant as well as more complex conditions (eg if(foo++ >
+    // --bar) ) IfStatementMutation,
     /// For a require(x) condition:
     /// replace x with true; replace x with false
     // Same as for IfStatementMutation, the expression inside the require is mutated as an
@@ -104,19 +102,15 @@ impl MutationType {
             Self::ElimDelegate => "ElimDelegate".to_string(),
             Self::FunctionCall => "FunctionCall".to_string(),
             Self::Require => "Require".to_string(),
-            Self::SwapArgumentsFunction => {
-                "SwapArgumentsFunction".to_string()
-            }
-            Self::SwapArgumentsOperator => {
-                "SwapArgumentsOperator".to_string()
-            }
+            Self::SwapArgumentsFunction => "SwapArgumentsFunction".to_string(),
+            Self::SwapArgumentsOperator => "SwapArgumentsOperator".to_string(),
             Self::UnaryOperator(mutated) => {
                 // avoid operator in tmp dir name
                 format!("{}_{:?}", "UnaryOperator", mutated.resulting_op_kind)
             }
         }
     }
-} 
+}
 
 impl Display for MutationType {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
@@ -167,4 +161,4 @@ impl Mutant {
             self.mutation.get_name()
         )
     }
-}
+}

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

@@ -27,9 +27,9 @@ impl Mutator for AssignmentMutator {
             AssignVarTypes::Literal(lit) => match lit {
                 LitKind::Bool(val) => Ok(vec![Mutant {
                     span,
-                    mutation: MutationType::Assignment(AssignVarTypes::Literal(
-                        LitKind::Bool(!val),
-                    )),
+                    mutation: MutationType::Assignment(AssignVarTypes::Literal(LitKind::Bool(
+                        !val,
+                    ))),
                     path: PathBuf::default(),
                 }]),
                 LitKind::Number(val) => Ok(vec![
@@ -52,24 +52,22 @@ impl Mutator for AssignmentMutator {
                     eyre::bail!("AssignementMutator: unexpected literal kind: {:?}", lit)
                 }
             },
-            AssignVarTypes::Identifier(ident) => {
-                Ok(vec![
-                    Mutant {
-                        span,
-                        mutation: MutationType::Assignment(AssignVarTypes::Literal(
-                            LitKind::Number(num_bigint::BigInt::ZERO),
-                        )),
-                        path: PathBuf::default(),
-                    },
-                    Mutant {
-                        span,
-                        mutation: MutationType::Assignment(AssignVarTypes::Identifier(
-                            format!("-{ident}"),
-                        )),
-                        path: PathBuf::default(),
-                    },
-                ])
-            }
+            AssignVarTypes::Identifier(ident) => Ok(vec![
+                Mutant {
+                    span,
+                    mutation: MutationType::Assignment(AssignVarTypes::Literal(LitKind::Number(
+                        num_bigint::BigInt::ZERO,
+                    ))),
+                    path: PathBuf::default(),
+                },
+                Mutant {
+                    span,
+                    mutation: MutationType::Assignment(AssignVarTypes::Identifier(format!(
+                        "-{ident}"
+                    ))),
+                    path: PathBuf::default(),
+                },
+            ]),
         }
     }
 

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

@@ -3,8 +3,7 @@ use crate::mutation::mutant::{Mutant, MutationType};
 
 use eyre::Result;
 use solar_parse::ast::ExprKind;
-use std::path::PathBuf;
-use std::fmt::Display;
+use std::{fmt::Display, path::PathBuf};
 
 pub struct ElimDelegateMutator;
 
@@ -27,12 +26,13 @@ impl Mutator for ElimDelegateMutator {
             .and_then(|callee| match &callee.kind {
                 ExprKind::Member(_, ident) => Some(ident),
                 _ => None,
-            }).is_some_and(|ident| ident.to_string() == "delegatecall")
+            })
+            .is_some_and(|ident| ident.to_string() == "delegatecall")
     }
 }
 
 impl Display for ElimDelegateMutator {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "")
     }
-}
+}

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

@@ -60,10 +60,9 @@ impl<'a> MutationContextBuilder<'a> {
     pub fn build(self) -> Result<MutationContext<'a>, &'static str> {
         let span = self.span.ok_or("Span is required for MutationContext")?;
 
-        Ok(MutationContext {
-            span,
-            expr: self.expr,
-            var_definition: self.var_definition,
-        })
+        Ok(MutationContext { span, expr: self.expr, var_definition: self.var_definition })
     }
 }
+
+#[cfg(test)]
+mod tests;

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

@@ -0,0 +1,101 @@
+use crate::mutation::{
+    mutant::{Mutant, MutationType},
+    mutators::{assignement_mutator::AssignmentMutator, MutationContext, Mutator},
+    visitor::AssignVarTypes,
+};
+use solar_parse::{
+    ast::{
+        Arena, ElementaryType, Expr, ExprKind, Ident, Lit, LitKind, Span, Symbol, Type, TypeKind,
+        VariableDefinition,
+    },
+    interface::BytePos,
+};
+
+use num_bigint::BigInt;
+use std::path::PathBuf;
+
+use crate::mutation::Session;
+
+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 mut val = Lit { span, symbol: Symbol::DUMMY, kind: LitKind::Number(23.into()) };
+
+        let right = arena.alloc(Expr { kind: ExprKind::Lit(&mut val, None), span });
+
+        let expr = arena.alloc(Expr { kind: ExprKind::Assign(left, None, right), span });
+
+        let context = MutationContext { expr: Some(expr), var_definition: None, span };
+
+        let mutator = AssignmentMutator;
+        assert!(mutator.is_applicable(&context));
+
+        Ok(())
+    });
+}
+
+#[test]
+fn test_is_applicable_for_var_definition() {
+    let arena = Arena::new();
+    let span = create_span(10, 20);
+
+    let lit = arena.alloc(Lit { span, symbol: Symbol::DUMMY, kind: LitKind::Number(23.into()) });
+
+    let init = arena.alloc(Expr { kind: ExprKind::Lit(lit, None), span });
+
+    let var_def = VariableDefinition {
+        name: None,
+        initializer: Some(init),
+        span,
+        ty: Type { kind: TypeKind::Elementary(ElementaryType::Bool), span },
+        visibility: None,
+        mutability: None,
+        data_location: None,
+        override_: None,
+        indexed: false,
+    };
+
+    let context = MutationContext { expr: None, var_definition: Some(&var_def), span };
+
+    let mutator = AssignmentMutator;
+    assert!(mutator.is_applicable(&context));
+}
+
+#[test]
+fn test_is_not_applicable_no_initializer() {
+    let arena = Arena::new();
+    let span = create_span(10, 20);
+
+    let var_def = VariableDefinition {
+        name: None,
+        initializer: None,
+        span,
+        ty: Type { kind: TypeKind::Elementary(ElementaryType::Bool), span },
+        visibility: None,
+        mutability: None,
+        data_location: None,
+        override_: None,
+        indexed: false,
+    };
+
+    let context = MutationContext { expr: None, var_definition: Some(&var_def), span };
+
+    let mutator = AssignmentMutator;
+    assert!(!mutator.is_applicable(&context));
+}

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

@@ -0,0 +1,34 @@
+use crate::mutation::{
+    mutant::{Mutant, MutationType},
+    mutators::{assignement_mutator::AssignmentMutator, MutationContext, Mutator},
+    visitor::AssignVarTypes,
+};
+use solar_parse::{
+    ast::{Arena, Expr, ExprKind, Ident, Lit, LitKind, Span, Symbol},
+    interface::BytePos,
+};
+
+use num_bigint::BigInt;
+use std::path::PathBuf;
+
+use crate::mutation::Session;
+
+// Create a span for test use
+pub fn create_span(start: u32, end: u32) -> Span {
+    Span::new(BytePos(start), BytePos(end))
+}
+
+// Create identifier with given name
+pub fn create_ident(name: &str) -> Ident {
+    Ident::from_str(name)
+}
+
+// Create number literal
+pub fn create_number_lit(value: u32, span: Span) -> Lit {
+    Lit { span, symbol: Symbol::DUMMY, kind: LitKind::Number(value.into()) }
+}
+
+// Create boolean literal
+pub fn create_bool_lit(value: bool, span: Span) -> Lit {
+    Lit { span, symbol: Symbol::DUMMY, kind: LitKind::Bool(value) }
+}

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

@@ -0,0 +1,2 @@
+mod assignement_mutator_test;
+mod ast_helper;