feat: add a way to specify expected revert code to forc-test

docs/book/src/testing/unit-testing.md

@@ -61,6 +61,15 @@ fn test_meaning_of_life() {
 }
 ```
 
+It is also possible to specify an expected revert code, like the following example.
+
+```sway
+#[test(should_revert = "18446744073709486084")]
+fn test_meaning_of_life() {
+    assert(6 * 6 == 42);
+}
+```
+
 Tests with `#[test(should_revert)]` considered to be passing if they are reverting.
 
 ## Calling Contracts

forc-pkg/src/pkg.rs

@@ -148,7 +148,7 @@ pub enum PkgEntryKind {
 /// The possible conditions for a test result to be considered "passing".
 #[derive(Debug, Clone)]
 pub enum TestPassCondition {
-    ShouldRevert,
+    ShouldRevert(Option<u64>),
     ShouldNotRevert,
 }
 
@@ -1949,18 +1949,35 @@ impl PkgTestEntry {
         let span = decl_ref.span();
         let test_function_decl = decl_engine.get_function(&decl_ref);
 
-        let test_args: HashSet<String> = test_function_decl
+        const FAILING_TEST_KEYWORD: &str = "should_revert";
+
+        let test_args: HashMap<String, Option<String>> = test_function_decl
             .attributes
             .get(&AttributeKind::Test)
             .expect("test declaration is missing test attribute")
             .iter()
-            .flat_map(|attr| attr.args.iter().map(|arg| arg.name.to_string()))
+            .flat_map(|attr| attr.args.iter())
+            .map(|arg| {
+                (
+                    arg.name.to_string(),
+                    arg.value
+                        .as_ref()
+                        .map(|val| val.span().as_str().to_string()),
+                )
+            })
             .collect();
 
         let pass_condition = if test_args.is_empty() {
             anyhow::Ok(TestPassCondition::ShouldNotRevert)
-        } else if test_args.get("should_revert").is_some() {
-            anyhow::Ok(TestPassCondition::ShouldRevert)
+        } else if let Some(args) = test_args.get(FAILING_TEST_KEYWORD) {
+            let expected_revert_code = args
+                .as_ref()
+                .map(|arg| {
+                    let arg_str = arg.replace('"', "");
+                    arg_str.parse::<u64>()
+                })
+                .transpose()?;
+            anyhow::Ok(TestPassCondition::ShouldRevert(expected_revert_code))
         } else {
             let test_name = &test_function_decl.name;
             bail!("Invalid test argument(s) for test: {test_name}.")

forc-test/src/lib.rs

@@ -491,9 +491,10 @@ impl TestResult {
     /// Whether or not the test passed.
     pub fn passed(&self) -> bool {
         match &self.condition {
-            TestPassCondition::ShouldRevert => {
-                matches!(self.state, vm::state::ProgramState::Revert(_))
-            }
+            TestPassCondition::ShouldRevert(revert_code) => match revert_code {
+                Some(revert_code) => self.state == vm::state::ProgramState::Revert(*revert_code),
+                None => matches!(self.state, vm::state::ProgramState::Revert(_)),
+            },
             TestPassCondition::ShouldNotRevert => {
                 !matches!(self.state, vm::state::ProgramState::Revert(_))
             }

test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/should_revert/src/lib.sw

@@ -4,3 +4,8 @@ library;
 fn should_revert_test() {
   assert(0 == 1)
 }
+
+#[test(should_revert = "18446744073709486084")]
+fn should_revert_test_with_exact_code() {
+  assert(0 == 1)
+}

test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/should_revert/test.toml

@@ -0,0 +1 @@
+category = "unit_tests_pass"