diff --git a/tooling/nargo_cli/build.rs b/tooling/nargo_cli/build.rs
index 43c277ba03e..f2da161267d 100644
--- a/tooling/nargo_cli/build.rs
+++ b/tooling/nargo_cli/build.rs
@@ -64,392 +64,291 @@ const IGNORED_BRILLIG_TESTS: [&str; 11] = [
 const IGNORED_NEW_FEATURE_TESTS: [&str; 3] =
     ["macros", "wildcard_type", "type_definition_annotation"];
 
-fn generate_execution_success_tests(test_file: &mut File, test_data_dir: &Path) {
-    let test_sub_dir = "execution_success";
+fn read_test_cases(
+    test_data_dir: &Path,
+    test_sub_dir: &str,
+) -> impl Iterator<Item = (String, PathBuf)> {
     let test_data_dir = test_data_dir.join(test_sub_dir);
-
     let test_case_dirs =
         fs::read_dir(test_data_dir).unwrap().flatten().filter(|c| c.path().is_dir());
 
-    for test_dir in test_case_dirs {
+    test_case_dirs.into_iter().map(|dir| {
         let test_name =
-            test_dir.file_name().into_string().expect("Directory can't be converted to string");
+            dir.file_name().into_string().expect("Directory can't be converted to string");
         if test_name.contains('-') {
             panic!(
                 "Invalid test directory: {test_name}. Cannot include `-`, please convert to `_`"
             );
-        };
-        let test_dir = &test_dir.path();
-
-        let brillig_ignored =
-            if IGNORED_BRILLIG_TESTS.contains(&test_name.as_str()) { "\n#[ignore]" } else { "" };
-        let new_features_ignored = if IGNORED_NEW_FEATURE_TESTS.contains(&test_name.as_str()) {
-            "\n#[ignore]"
-        } else {
-            ""
-        };
-
-        write!(
-            test_file,
-            r#"
-#[test]{new_features_ignored}
-fn execution_success_legacy_{test_name}() {{
-    let test_program_dir = PathBuf::from("{test_dir}");
-
-    let mut cmd = Command::cargo_bin("nargo").unwrap();
-    cmd.arg("--program-dir").arg(test_program_dir);
-    cmd.arg("execute").arg("--force").arg("--use-legacy");
-
-    cmd.assert().success();
-}}
+        }
+        (test_name, dir.path())
+    })
+}
 
+fn generate_test_case(
+    test_file: &mut File,
+    test_type: &str,
+    test_name: &str,
+    test_dir: &std::path::Display,
+    test_content: &str,
+) {
+    write!(
+        test_file,
+        r#"
 #[test]
-fn execution_success_{test_name}() {{
+fn {test_type}_{test_name}() {{
     let test_program_dir = PathBuf::from("{test_dir}");
 
-    let mut cmd = Command::cargo_bin("nargo").unwrap();
-    cmd.arg("--program-dir").arg(test_program_dir);
-    cmd.arg("execute").arg("--force");
-
-    cmd.assert().success();
+    let mut nargo = Command::cargo_bin("nargo").unwrap();
+    nargo.arg("--program-dir").arg(test_program_dir);
+    {test_content}
 }}
+"#
+    )
+    .expect("Could not write templated test file.");
+}
 
-#[test]{brillig_ignored}
-fn execution_success_{test_name}_brillig() {{
-    let test_program_dir = PathBuf::from("{test_dir}");
-
-    let mut cmd = Command::cargo_bin("nargo").unwrap();
-    cmd.arg("--program-dir").arg(test_program_dir);
-    cmd.arg("execute").arg("--force").arg("--force-brillig");
+fn generate_execution_success_tests(test_file: &mut File, test_data_dir: &Path) {
+    let test_type = "execution_success";
+    let test_cases = read_test_cases(test_data_dir, test_type);
+    for (test_name, test_dir) in test_cases {
+        let test_dir = test_dir.display();
 
-    cmd.assert().success();
-}}
-            "#,
-            test_dir = test_dir.display(),
-        )
-        .expect("Could not write templated test file.");
+        generate_test_case(
+            test_file,
+            test_type,
+            &test_name,
+            &test_dir,
+            r#"
+                nargo.arg("execute").arg("--force");
+            
+                nargo.assert().success();"#,
+        );
+
+        if !IGNORED_NEW_FEATURE_TESTS.contains(&test_name.as_str()) {
+            generate_test_case(
+                test_file,
+                test_type,
+                &format!("legacy_{test_name}"),
+                &test_dir,
+                r#"
+                nargo.arg("execute").arg("--force").arg("--use-legacy");
+            
+                nargo.assert().success();"#,
+            );
+        }
+
+        if !IGNORED_BRILLIG_TESTS.contains(&test_name.as_str()) {
+            generate_test_case(
+                test_file,
+                test_type,
+                &format!("{test_name}_brillig"),
+                &test_dir,
+                r#"
+                nargo.arg("execute").arg("--force").arg("--force-brillig");
+            
+                nargo.assert().success();"#,
+            );
+        }
     }
 }
 
 fn generate_execution_failure_tests(test_file: &mut File, test_data_dir: &Path) {
-    let test_sub_dir = "execution_failure";
-    let test_data_dir = test_data_dir.join(test_sub_dir);
-
-    let test_case_dirs =
-        fs::read_dir(test_data_dir).unwrap().flatten().filter(|c| c.path().is_dir());
-
-    for test_dir in test_case_dirs {
-        let test_name =
-            test_dir.file_name().into_string().expect("Directory can't be converted to string");
-        if test_name.contains('-') {
-            panic!(
-                "Invalid test directory: {test_name}. Cannot include `-`, please convert to `_`"
-            );
-        };
-        let test_dir = &test_dir.path();
+    let test_type = "execution_failure";
+    let test_cases = read_test_cases(test_data_dir, test_type);
+    for (test_name, test_dir) in test_cases {
+        let test_dir = test_dir.display();
 
-        write!(
+        generate_test_case(
             test_file,
+            test_type,
+            &test_name,
+            &test_dir,
             r#"
-#[test]
-fn execution_failure_legacy_{test_name}() {{
-    let test_program_dir = PathBuf::from("{test_dir}");
-
-    let mut cmd = Command::cargo_bin("nargo").unwrap();
-    cmd.arg("--program-dir").arg(test_program_dir);
-    cmd.arg("execute").arg("--force").arg("--use-legacy");
-
-    cmd.assert().failure().stderr(predicate::str::contains("The application panicked (crashed).").not());
-}}
-
-#[test]
-fn execution_failure_{test_name}() {{
-    let test_program_dir = PathBuf::from("{test_dir}");
-
-    let mut cmd = Command::cargo_bin("nargo").unwrap();
-    cmd.arg("--program-dir").arg(test_program_dir);
-    cmd.arg("execute").arg("--force");
+                nargo.arg("execute").arg("--force");
+            
+                nargo.assert().failure().stderr(predicate::str::contains("The application panicked (crashed).").not());"#,
+        );
 
-    cmd.assert().failure().stderr(predicate::str::contains("The application panicked (crashed).").not());
-}}
-            "#,
-            test_dir = test_dir.display(),
-        )
-        .expect("Could not write templated test file.");
+        generate_test_case(
+            test_file,
+            test_type,
+            &format!("legacy_{test_name}"),
+            &test_dir,
+            r#"
+                nargo.arg("execute").arg("--force").arg("--use-legacy");
+            
+                nargo.assert().failure().stderr(predicate::str::contains("The application panicked (crashed).").not());"#,
+        );
     }
 }
 
 fn generate_noir_test_success_tests(test_file: &mut File, test_data_dir: &Path) {
-    let test_sub_dir = "noir_test_success";
-    let test_data_dir = test_data_dir.join(test_sub_dir);
-
-    let test_case_dirs =
-        fs::read_dir(test_data_dir).unwrap().flatten().filter(|c| c.path().is_dir());
+    let test_type = "noir_test_success";
+    let test_cases = read_test_cases(test_data_dir, "noir_test_success");
+    for (test_name, test_dir) in test_cases {
+        let test_dir = test_dir.display();
 
-    for test_dir in test_case_dirs {
-        let test_name =
-            test_dir.file_name().into_string().expect("Directory can't be converted to string");
-        if test_name.contains('-') {
-            panic!(
-                "Invalid test directory: {test_name}. Cannot include `-`, please convert to `_`"
-            );
-        };
-        let test_dir = &test_dir.path();
-
-        write!(
+        generate_test_case(
             test_file,
+            test_type,
+            &test_name,
+            &test_dir,
             r#"
-#[test]
-fn noir_test_success_legacy_{test_name}() {{
-    let test_program_dir = PathBuf::from("{test_dir}");
+        nargo.arg("test");
+        
+        nargo.assert().success();"#,
+        );
 
-    let mut cmd = Command::cargo_bin("nargo").unwrap();
-    cmd.arg("--program-dir").arg(test_program_dir);
-    cmd.arg("test").arg("--use-legacy");
-
-    cmd.assert().success();
-}}
-
-#[test]
-fn noir_test_success_{test_name}() {{
-    let test_program_dir = PathBuf::from("{test_dir}");
-
-    let mut cmd = Command::cargo_bin("nargo").unwrap();
-    cmd.arg("--program-dir").arg(test_program_dir);
-    cmd.arg("test");
-
-    cmd.assert().success();
-}}
-            "#,
-            test_dir = test_dir.display(),
-        )
-        .expect("Could not write templated test file.");
+        generate_test_case(
+            test_file,
+            test_type,
+            &format!("legacy_{test_name}"),
+            &test_dir,
+            r#"
+        nargo.arg("test").arg("--use-legacy");
+        
+        nargo.assert().success();"#,
+        );
     }
 }
 
 fn generate_noir_test_failure_tests(test_file: &mut File, test_data_dir: &Path) {
-    let test_sub_dir = "noir_test_failure";
-    let test_data_dir = test_data_dir.join(test_sub_dir);
-
-    let test_case_dirs =
-        fs::read_dir(test_data_dir).unwrap().flatten().filter(|c| c.path().is_dir());
-
-    for test_dir in test_case_dirs {
-        let test_name =
-            test_dir.file_name().into_string().expect("Directory can't be converted to string");
-        if test_name.contains('-') {
-            panic!(
-                "Invalid test directory: {test_name}. Cannot include `-`, please convert to `_`"
-            );
-        };
-        let test_dir = &test_dir.path();
-
-        write!(
+    let test_type = "noir_test_failure";
+    let test_cases = read_test_cases(test_data_dir, test_type);
+    for (test_name, test_dir) in test_cases {
+        let test_dir = test_dir.display();
+        generate_test_case(
             test_file,
+            test_type,
+            &test_name,
+            &test_dir,
             r#"
-#[test]
-fn noir_test_failure_legacy_{test_name}() {{
-    let test_program_dir = PathBuf::from("{test_dir}");
-
-    let mut cmd = Command::cargo_bin("nargo").unwrap();
-    cmd.arg("--program-dir").arg(test_program_dir);
-    cmd.arg("test").arg("--use-legacy");
-
-    cmd.assert().failure();
-}}
-
-#[test]
-fn noir_test_failure_{test_name}() {{
-    let test_program_dir = PathBuf::from("{test_dir}");
-
-    let mut cmd = Command::cargo_bin("nargo").unwrap();
-    cmd.arg("--program-dir").arg(test_program_dir);
-    cmd.arg("test");
+        nargo.arg("test");
+        
+        nargo.assert().failure();"#,
+        );
 
-    cmd.assert().failure();
-}}
-            "#,
-            test_dir = test_dir.display(),
-        )
-        .expect("Could not write templated test file.");
+        generate_test_case(
+            test_file,
+            test_type,
+            &format!("legacy_{test_name}"),
+            &test_dir,
+            r#"
+        nargo.arg("test").arg("--use-legacy");
+        
+        nargo.assert().failure();"#,
+        );
     }
 }
 
 fn generate_compile_success_empty_tests(test_file: &mut File, test_data_dir: &Path) {
-    let test_sub_dir = "compile_success_empty";
-    let test_data_dir = test_data_dir.join(test_sub_dir);
-
-    let test_case_dirs =
-        fs::read_dir(test_data_dir).unwrap().flatten().filter(|c| c.path().is_dir());
-
-    for test_dir in test_case_dirs {
-        let test_name =
-            test_dir.file_name().into_string().expect("Directory can't be converted to string");
-        if test_name.contains('-') {
-            panic!(
-                "Invalid test directory: {test_name}. Cannot include `-`, please convert to `_`"
-            );
-        };
-        let test_dir = &test_dir.path();
-
-        let new_feature_ignored = if IGNORED_NEW_FEATURE_TESTS.contains(&test_name.as_str()) {
-            "\n#[ignore]"
-        } else {
-            ""
-        };
-
-        write!(
+    let test_type = "compile_success_empty";
+    let test_cases = read_test_cases(test_data_dir, test_type);
+    for (test_name, test_dir) in test_cases {
+        let test_dir = test_dir.display();
+
+        let assert_zero_opcodes = r#"
+        let output = nargo.output().expect("Failed to execute command");
+
+        if !output.status.success() {{
+            panic!("`nargo info` failed with: {}", String::from_utf8(output.stderr).unwrap_or_default());
+        }}
+    
+        // `compile_success_empty` tests should be able to compile down to an empty circuit.
+        let json: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap_or_else(|e| {{
+            panic!("JSON was not well-formatted {:?}\n\n{:?}", e, std::str::from_utf8(&output.stdout))
+        }});
+        let num_opcodes = &json["programs"][0]["functions"][0]["acir_opcodes"];
+        assert_eq!(num_opcodes.as_u64().expect("number of opcodes should fit in a u64"), 0);
+        "#;
+
+        generate_test_case(
             test_file,
-            r#"
-#[test]{new_feature_ignored}
-fn compile_success_empty_legacy_{test_name}() {{
-    let test_program_dir = PathBuf::from("{test_dir}");
-    let mut cmd = Command::cargo_bin("nargo").unwrap();
-    cmd.arg("--program-dir").arg(test_program_dir);
-    cmd.arg("info");
-    cmd.arg("--json");
-    cmd.arg("--force");
-    cmd.arg("--use-legacy");
-
-    let output = cmd.output().expect("Failed to execute command");
-
-    if !output.status.success() {{
-        panic!("`nargo info` failed with: {{}}", String::from_utf8(output.stderr).unwrap_or_default());
-    }}
-
-    // `compile_success_empty` tests should be able to compile down to an empty circuit.
-    let json: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap_or_else(|e| {{
-        panic!("JSON was not well-formatted {{:?}}\n\n{{:?}}", e, std::str::from_utf8(&output.stdout))
-    }});
-    let num_opcodes = &json["programs"][0]["functions"][0]["acir_opcodes"];
-    assert_eq!(num_opcodes.as_u64().expect("number of opcodes should fit in a u64"), 0);
-}}
-
-#[test]
-fn compile_success_empty_{test_name}() {{
-    let test_program_dir = PathBuf::from("{test_dir}");
-    let mut cmd = Command::cargo_bin("nargo").unwrap();
-    cmd.arg("--program-dir").arg(test_program_dir);
-    cmd.arg("info");
-    cmd.arg("--json");
-    cmd.arg("--force");
-
-    let output = cmd.output().expect("Failed to execute command");
-
-    if !output.status.success() {{
-        panic!("`nargo info` failed with: {{}}", String::from_utf8(output.stderr).unwrap_or_default());
-    }}
-
-    // `compile_success_empty` tests should be able to compile down to an empty circuit.
-    let json: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap_or_else(|e| {{
-        panic!("JSON was not well-formatted {{:?}}\n\n{{:?}}", e, std::str::from_utf8(&output.stdout))
-    }});
-    let num_opcodes = &json["programs"][0]["functions"][0]["acir_opcodes"];
-    assert_eq!(num_opcodes.as_u64().expect("number of opcodes should fit in a u64"), 0);
-}}
-            "#,
-            test_dir = test_dir.display(),
-        )
-        .expect("Could not write templated test file.");
+            test_type,
+            &test_name,
+            &test_dir,
+            &format!(
+                r#"
+                nargo.arg("info").arg("--json").arg("--force");
+                
+                {assert_zero_opcodes}"#,
+            ),
+        );
+
+        if !IGNORED_NEW_FEATURE_TESTS.contains(&test_name.as_str()) {
+            generate_test_case(
+                test_file,
+                test_type,
+                &format!("legacy_{test_name}"),
+                &test_dir,
+                &format!(
+                    r#"
+                nargo.arg("info").arg("--json").arg("--force").arg("--use-legacy");
+                
+                {assert_zero_opcodes}"#,
+                ),
+            );
+        }
     }
 }
 
 fn generate_compile_success_contract_tests(test_file: &mut File, test_data_dir: &Path) {
-    let test_sub_dir = "compile_success_contract";
-    let test_data_dir = test_data_dir.join(test_sub_dir);
-
-    let test_case_dirs =
-        fs::read_dir(test_data_dir).unwrap().flatten().filter(|c| c.path().is_dir());
-
-    for test_dir in test_case_dirs {
-        let test_name =
-            test_dir.file_name().into_string().expect("Directory can't be converted to string");
-        if test_name.contains('-') {
-            panic!(
-                "Invalid test directory: {test_name}. Cannot include `-`, please convert to `_`"
-            );
-        };
-        let test_dir = &test_dir.path();
+    let test_type = "compile_success_contract";
+    let test_cases = read_test_cases(test_data_dir, test_type);
+    for (test_name, test_dir) in test_cases {
+        let test_dir = test_dir.display();
 
-        write!(
+        generate_test_case(
             test_file,
+            test_type,
+            &test_name,
+            &test_dir,
             r#"
-#[test]
-fn compile_success_contract_legacy_{test_name}() {{
-    let test_program_dir = PathBuf::from("{test_dir}");
-
-    let mut cmd = Command::cargo_bin("nargo").unwrap();
-    cmd.arg("--program-dir").arg(test_program_dir);
-    cmd.arg("compile").arg("--force").arg("--use-legacy");
+        nargo.arg("compile").arg("--force");
+        
+        nargo.assert().success();"#,
+        );
 
-    cmd.assert().success();
-}}
-#[test]
-fn compile_success_contract_{test_name}() {{
-    let test_program_dir = PathBuf::from("{test_dir}");
-
-    let mut cmd = Command::cargo_bin("nargo").unwrap();
-    cmd.arg("--program-dir").arg(test_program_dir);
-    cmd.arg("compile").arg("--force");
-
-    cmd.assert().success();
-}}
-            "#,
-            test_dir = test_dir.display(),
-        )
-        .expect("Could not write templated test file.");
+        generate_test_case(
+            test_file,
+            test_type,
+            &format!("legacy_{test_name}"),
+            &test_dir,
+            r#"
+        nargo.arg("compile").arg("--force").arg("--use-legacy");
+        
+        nargo.assert().success();"#,
+        );
     }
 }
 
 fn generate_compile_failure_tests(test_file: &mut File, test_data_dir: &Path) {
-    let test_sub_dir = "compile_failure";
-    let test_data_dir = test_data_dir.join(test_sub_dir);
-
-    let test_case_dirs =
-        fs::read_dir(test_data_dir).unwrap().flatten().filter(|c| c.path().is_dir());
+    let test_type = "compile_failure";
+    let test_cases = read_test_cases(test_data_dir, test_type);
+    for (test_name, test_dir) in test_cases {
+        let test_dir = test_dir.display();
 
-    for test_dir in test_case_dirs {
-        let test_name =
-            test_dir.file_name().into_string().expect("Directory can't be converted to string");
-        if test_name.contains('-') {
-            panic!(
-                "Invalid test directory: {test_name}. Cannot include `-`, please convert to `_`"
-            );
-        };
-        let test_dir = &test_dir.path();
-
-        let new_feature_ignored = if IGNORED_NEW_FEATURE_TESTS.contains(&test_name.as_str()) {
-            "\n#[ignore]"
-        } else {
-            ""
-        };
-
-        write!(
+        generate_test_case(
             test_file,
-            r#"
-#[test]{new_feature_ignored}
-fn compile_failure_legacy_{test_name}() {{
-    let test_program_dir = PathBuf::from("{test_dir}");
-
-    let mut cmd = Command::cargo_bin("nargo").unwrap();
-    cmd.arg("--program-dir").arg(test_program_dir);
-    cmd.arg("compile").arg("--force").arg("--use-legacy");
-
-    cmd.assert().failure().stderr(predicate::str::contains("The application panicked (crashed).").not());
-}}
-#[test]
-fn compile_failure_{test_name}() {{
-    let test_program_dir = PathBuf::from("{test_dir}");
-
-    let mut cmd = Command::cargo_bin("nargo").unwrap();
-    cmd.arg("--program-dir").arg(test_program_dir);
-    cmd.arg("compile").arg("--force");
-
-    cmd.assert().failure().stderr(predicate::str::contains("The application panicked (crashed).").not());
-}}
-            "#,
-            test_dir = test_dir.display(),
-        )
-        .expect("Could not write templated test file.");
+            test_type,
+            &test_name,
+            &test_dir,
+            r#"nargo.arg("compile").arg("--force");
+        
+        nargo.assert().failure().stderr(predicate::str::contains("The application panicked (crashed).").not());"#,
+        );
+
+        if !IGNORED_NEW_FEATURE_TESTS.contains(&test_name.as_str()) {
+            generate_test_case(
+                test_file,
+                test_type,
+                &format!("legacy_{test_name}"),
+                &test_dir,
+                r#"
+            nargo.arg("compile").arg("--force").arg("--use-legacy");
+            
+            nargo.assert().failure().stderr(predicate::str::contains("The application panicked (crashed).").not());"#,
+            );
+        }
     }
 }