Implemented detailed state eqs in ef_tests

tests/ef_tests/src/case_result.rs

@@ -1,5 +1,7 @@
 use super::*;
+use compare_fields::CompareFields;
 use std::fmt::Debug;
+use types::BeaconState;
 
 pub const MAX_VALUE_STRING_LEN: usize = 500;
 
@@ -20,6 +22,55 @@ impl CaseResult {
     }
 }
 
+/// Same as `compare_result_detailed`, however it drops the caches on both states before
+/// comparison.
+pub fn compare_beacon_state_results_without_caches<T: EthSpec, E: Debug>(
+    result: &mut Result<BeaconState<T>, E>,
+    expected: &mut Option<BeaconState<T>>,
+) -> Result<(), Error> {
+    match (result.as_mut(), expected.as_mut()) {
+        (Ok(ref mut result), Some(ref mut expected)) => {
+            result.drop_all_caches();
+            expected.drop_all_caches();
+        }
+        _ => (),
+    };
+
+    compare_result_detailed(&result, &expected)
+}
+
+/// Same as `compare_result`, however utilizes the `CompareFields` trait to give a list of
+/// mismatching fields when `Ok(result) != Some(expected)`.
+pub fn compare_result_detailed<T, E>(
+    result: &Result<T, E>,
+    expected: &Option<T>,
+) -> Result<(), Error>
+where
+    T: PartialEq<T> + Debug + CompareFields,
+    E: Debug,
+{
+    match (result, expected) {
+        (Ok(result), Some(expected)) => {
+            let mismatching_fields: Vec<String> = expected
+                .compare_fields(result)
+                .into_iter()
+                .filter(|c| !c.equal)
+                .map(|c| c.field_name)
+                .collect();
+
+            if !mismatching_fields.is_empty() {
+                Err(Error::NotEqual(format!(
+                    "Result mismatch. Fields not equal: {:?}",
+                    mismatching_fields
+                )))
+            } else {
+                Ok(())
+            }
+        }
+        _ => compare_result(result, expected),
+    }
+}
+
 /// Compares `result` with `expected`.
 ///
 /// If `expected.is_none()` then `result` is expected to be `Err`. Otherwise, `T` in `result` and

tests/ef_tests/src/cases/operations_deposit.rs

@@ -1,5 +1,5 @@
 use super::*;
-use crate::case_result::compare_result;
+use crate::case_result::compare_beacon_state_results_without_caches;
 use serde_derive::Deserialize;
 use state_processing::per_block_processing::process_deposits;
 use types::{BeaconState, Deposit, EthSpec};
@@ -24,9 +24,11 @@ impl<E: EthSpec> Case for OperationsDeposit<E> {
     fn result(&self) -> Result<(), Error> {
         let mut state = self.pre.clone();
         let deposit = self.deposit.clone();
+        let mut expected = self.post.clone();
 
-        let result = process_deposits(&mut state, &[deposit], &E::spec()).and_then(|_| Ok(state));
+        let mut result =
+            process_deposits(&mut state, &[deposit], &E::spec()).and_then(|_| Ok(state));
 
-        compare_result(&result, &self.post)
+        compare_beacon_state_results_without_caches(&mut result, &mut expected)
     }
 }