Make tests generic across an EthSpec

eth2/types/src/attestation_data_and_custody_bit.rs

@@ -2,14 +2,25 @@ use super::AttestationData;
 use crate::test_utils::TestRandom;
 
 use rand::RngCore;
-use serde_derive::Serialize;
+use serde_derive::{Deserialize, Serialize};
 use ssz_derive::{Decode, Encode};
 use tree_hash_derive::{CachedTreeHash, TreeHash};
 
 /// Used for pairing an attestation with a proof-of-custody.
 ///
 /// Spec v0.5.1
-#[derive(Debug, Clone, PartialEq, Default, Serialize, Encode, Decode, TreeHash, CachedTreeHash)]
+#[derive(
+    Debug,
+    Clone,
+    PartialEq,
+    Default,
+    Serialize,
+    Deserialize,
+    Encode,
+    Decode,
+    TreeHash,
+    CachedTreeHash,
+)]
 pub struct AttestationDataAndCustodyBit {
     pub data: AttestationData,
     pub custody_bit: bool,

tests/ef_tests/src/test_case_result.rs

@@ -1,4 +1,5 @@
 use super::*;
+use types::EthSpec;
 
 #[derive(Debug, PartialEq, Clone)]
 pub struct TestCaseResult {
@@ -18,7 +19,7 @@ impl TestCaseResult {
 }
 
 pub trait Test {
-    fn test(&self) -> Vec<TestCaseResult>;
+    fn test<E: EthSpec>(&self) -> Vec<TestCaseResult>;
 }
 
 /// Compares `result` with `expected`.

tests/ef_tests/src/test_doc.rs

@@ -1,5 +1,6 @@
 use super::*;
 use std::{fs::File, io::prelude::*, path::PathBuf};
+use types::{EthSpec, FewValidatorsEthSpec, FoundationEthSpec};
 
 #[derive(Debug, Deserialize)]
 pub struct TestDoc {
@@ -26,8 +27,8 @@ impl TestDoc {
             header.handler.as_ref(),
             header.config.as_ref(),
         ) {
-            ("ssz", "uint", _) => run_test::<SszGeneric>(&doc.yaml),
-            ("ssz", "static", "minimal") => run_test::<SszStatic>(&doc.yaml),
+            ("ssz", "uint", _) => run_test::<SszGeneric, FoundationEthSpec>(&doc.yaml),
+            ("ssz", "static", "minimal") => run_test::<SszStatic, FewValidatorsEthSpec>(&doc.yaml),
             (runner, handler, config) => panic!(
                 "No implementation for runner: \"{}\", handler: \"{}\", config: \"{}\"",
                 runner, handler, config
@@ -41,16 +42,16 @@ impl TestDoc {
         let failures: Vec<&TestCaseResult> = results.iter().filter(|r| r.result.is_err()).collect();
 
         if !failures.is_empty() {
-            for f in failures {
+            for f in &failures {
                 dbg!(&f.case_index);
                 dbg!(&f.result);
             }
-            panic!()
+            panic!("{}/{} tests failed.", failures.len(), results.len())
         }
     }
 }
 
-pub fn run_test<T>(test_doc_yaml: &String) -> Vec<TestCaseResult>
+pub fn run_test<T, E: EthSpec>(test_doc_yaml: &String) -> Vec<TestCaseResult>
 where
     TestDocCases<T>: Test + serde::de::DeserializeOwned + TestDecode,
 {
@@ -59,5 +60,5 @@ where
     let test_cases: TestDocCases<T> =
         TestDocCases::test_decode(&test_cases_yaml.to_string()).unwrap();
 
-    test_cases.test()
+    test_cases.test::<E>()
 }

tests/ef_tests/src/test_doc_cases/ssz_generic.rs

@@ -1,4 +1,5 @@
 use super::*;
+use types::EthSpec;
 
 #[derive(Debug, Clone, Deserialize)]
 pub struct SszGeneric {
@@ -16,7 +17,7 @@ impl TestDecode for SszGeneric {
 }
 
 impl Test for TestDocCases<SszGeneric> {
-    fn test(&self) -> Vec<TestCaseResult> {
+    fn test<E: EthSpec>(&self) -> Vec<TestCaseResult> {
         self.test_cases
             .iter()
             .enumerate()

tests/ef_tests/src/test_doc_cases/ssz_static.rs

@@ -42,7 +42,7 @@ impl SszStatic {
 }
 
 impl Test for TestDocCases<SszStatic> {
-    fn test(&self) -> Vec<TestCaseResult> {
+    fn test<E: EthSpec>(&self) -> Vec<TestCaseResult> {
         self.test_cases
             .iter()
             .enumerate()
@@ -52,17 +52,15 @@ impl Test for TestDocCases<SszStatic> {
                     "Crosslink" => ssz_static_test::<Crosslink>(tc),
                     "Eth1Data" => ssz_static_test::<Eth1Data>(tc),
                     "AttestationData" => ssz_static_test::<AttestationData>(tc),
-                    /*
                     "AttestationDataAndCustodyBit" => {
                         ssz_static_test::<AttestationDataAndCustodyBit>(tc)
                     }
-                    */
                     "IndexedAttestation" => ssz_static_test::<IndexedAttestation>(tc),
                     "DepositData" => ssz_static_test::<DepositData>(tc),
                     "BeaconBlockHeader" => ssz_static_test::<BeaconBlockHeader>(tc),
                     "Validator" => ssz_static_test::<Validator>(tc),
                     "PendingAttestation" => ssz_static_test::<PendingAttestation>(tc),
-                    // "HistoricalBatch" => ssz_static_test::<HistoricalBatch>(tc),
+                    "HistoricalBatch" => ssz_static_test::<HistoricalBatch<E>>(tc),
                     "ProposerSlashing" => ssz_static_test::<ProposerSlashing>(tc),
                     "AttesterSlashing" => ssz_static_test::<AttesterSlashing>(tc),
                     "Attestation" => ssz_static_test::<Attestation>(tc),
@@ -71,7 +69,7 @@ impl Test for TestDocCases<SszStatic> {
                     "Transfer" => ssz_static_test::<Transfer>(tc),
                     "BeaconBlockBody" => ssz_static_test::<BeaconBlockBody>(tc),
                     "BeaconBlock" => ssz_static_test::<BeaconBlock>(tc),
-                    // "BeaconState" => ssz_static_test::<DepositData>(tc),
+                    "BeaconState" => ssz_static_test::<BeaconState<E>>(tc),
                     _ => Err(Error::FailedToParseTest(format!(
                         "Unknown type: {}",
                         tc.type_name