Add transfer ef tests

eth2/state_processing/src/per_block_processing.rs

@@ -469,7 +469,7 @@ pub fn process_transfers<T: EthSpec>(
     spec: &ChainSpec,
 ) -> Result<(), Error> {
     verify!(
-        transfers.len() as u64 <= spec.max_transfers,
+        transfers.len() as u64 >= spec.max_transfers,
         Invalid::MaxTransfersExceed
     );
 

tests/ef_tests/src/cases.rs

@@ -8,6 +8,7 @@ mod bls_g2_uncompressed;
 mod bls_priv_to_pub;
 mod bls_sign_msg;
 mod operations_deposit;
+mod operations_transfer;
 mod ssz_generic;
 mod ssz_static;
 
@@ -18,6 +19,7 @@ pub use bls_g2_uncompressed::*;
 pub use bls_priv_to_pub::*;
 pub use bls_sign_msg::*;
 pub use operations_deposit::*;
+pub use operations_transfer::*;
 pub use ssz_generic::*;
 pub use ssz_static::*;
 

tests/ef_tests/src/cases/operations_transfer.rs

@@ -0,0 +1,35 @@
+use super::*;
+use crate::case_result::compare_beacon_state_results_without_caches;
+use serde_derive::Deserialize;
+use state_processing::per_block_processing::process_transfers;
+use types::{BeaconState, EthSpec, Transfer};
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct OperationsTransfer<E: EthSpec> {
+    pub description: String,
+    #[serde(bound = "E: EthSpec")]
+    pub pre: BeaconState<E>,
+    pub transfer: Transfer,
+    #[serde(bound = "E: EthSpec")]
+    pub post: Option<BeaconState<E>>,
+}
+
+impl<E: EthSpec> YamlDecode for OperationsTransfer<E> {
+    fn yaml_decode(yaml: &String) -> Result<Self, Error> {
+        Ok(serde_yaml::from_str(&yaml.as_str()).unwrap())
+    }
+}
+
+impl<E: EthSpec> Case for OperationsTransfer<E> {
+    fn result(&self, _case_index: usize) -> Result<(), Error> {
+        let mut state = self.pre.clone();
+        let transfer = self.transfer.clone();
+        let mut expected = self.post.clone();
+
+        let result = process_transfers(&mut state, &[transfer], &E::spec());
+
+        let mut result = result.and_then(|_| Ok(state));
+
+        compare_beacon_state_results_without_caches(&mut result, &mut expected)
+    }
+}

tests/ef_tests/src/doc.rs

@@ -57,6 +57,12 @@ impl Doc {
             ("operations", "deposit", "minimal") => {
                 run_test::<OperationsDeposit<MinimalEthSpec>>(self)
             }
+            ("operations", "transfer", "mainnet") => {
+                run_test::<OperationsTransfer<MainnetEthSpec>>(self)
+            }
+            ("operations", "transfer", "minimal") => {
+                run_test::<OperationsTransfer<MinimalEthSpec>>(self)
+            }
             (runner, handler, config) => panic!(
                 "No implementation for runner: \"{}\", handler: \"{}\", config: \"{}\"",
                 runner, handler, config

tests/ef_tests/tests/tests.rs

@@ -14,7 +14,7 @@ fn yaml_files_in_test_dir(dir: &Path) -> Vec<PathBuf> {
         "Unable to locate test files. Did you init git submoules?"
     );
 
-    WalkDir::new(base_path)
+    let mut paths: Vec<PathBuf> = WalkDir::new(base_path)
         .into_iter()
         .filter_map(|e| e.ok())
         .filter_map(|entry| {
@@ -28,7 +28,13 @@ fn yaml_files_in_test_dir(dir: &Path) -> Vec<PathBuf> {
                 None
             }
         })
-        .collect()
+        .collect();
+
+    // Reverse the file order. Assuming files come in lexicographical order, doing it in
+    // reverse means we get the "minimal" tests before the "mainnet" tests. This makes life
+    // easier for debugging.
+    paths.reverse();
+    paths
 }
 
 #[test]
@@ -55,6 +61,19 @@ fn ssz_static() {
 #[cfg(not(feature = "fake_crypto"))]
 fn operations_deposit() {
     yaml_files_in_test_dir(&Path::new("operations").join("deposit"))
+        .into_par_iter()
+        .for_each(|file| {
+            Doc::assert_tests_pass(file);
+        });
+}
+
+// No transfers are permitted in phase 0.
+/*
+#[test]
+#[should_panic]
+#[cfg(not(feature = "fake_crypto"))]
+fn operations_transfer() {
+    yaml_files_in_test_dir(&Path::new("operations").join("transfer"))
         // .into_par_iter()
         .into_iter()
         .rev()
@@ -62,6 +81,7 @@ fn operations_deposit() {
             Doc::assert_tests_pass(file);
         });
 }
+*/
 
 #[test]
 #[cfg(not(feature = "fake_crypto"))]