Update Simulacrum

This allows simplifying the workaround for issue 55.
pcsm/simulacrum#55

Cargo.toml

@@ -75,4 +75,4 @@ lto = true
 members = ["isa-l"]
 
 [patch.crates-io]
-simulacrum_mock = { git = "https://github.com/pcsm/simulacrum/", rev = "872b48d" }
+simulacrum_mock = { git = "https://github.com/pcsm/simulacrum/", rev = "13416e9" }

src/common/ddml_mock.rs

@@ -10,12 +10,10 @@ use simulacrum::*;
 use std::{
     any,
     borrow::Borrow,
-    collections::hash_map::HashMap
 };
 
 pub struct DDMLMock {
     e: Expectations,
-    m: HashMap<any::TypeId, &'static str>
 }
 
 impl DDMLMock {
@@ -42,7 +40,6 @@ impl DDMLMock {
     pub fn new() -> Self {
         Self {
             e: Expectations::new(),
-            m: HashMap::new()
         }
     }
 
@@ -88,24 +85,17 @@ impl DDMLMock {
     }
 
     // Due to a bug in Simulacrum, mocking DDML::put is way overcomplicated.
-    // The test method must first call `expect_put_type` with the type to be
-    // mocked, and a name for it.  Then `expect_put` and `put` can be used like
-    // normal.
     //
     // Simulacrum can't mock a single generic method with different type
-    // parameters more than once in the same test
+    // parameters more than once in the same test.  The workaround is to
+    // dynamically construct the method name.
     // https://github.com/pcsm/simulacrum/issues/55"]
     pub fn expect_put<T: Cacheable>(&mut self) -> Method<(T, Compression, TxgT),
         Box<Future<Item=DRP, Error=Error> + Send>>
     {
-        let method_name = self.m.get(&any::TypeId::of::<T>()).unwrap_or(&"put");
         self.e.expect::<(T, Compression, TxgT),
                         Box<Future<Item=DRP, Error=Error> + Send>>
-            (method_name)
-    }
-
-    pub fn expect_put_type<T: Cacheable>(&mut self, name: &'static str) {
-        self.m.insert(any::TypeId::of::<T>(), name);
+            (&DDMLMock::generic_method_name::<T>())
     }
 
     pub fn expect_sync_all(&mut self)
@@ -115,6 +105,10 @@ impl DDMLMock {
                         Box<Future<Item=(), Error=Error> + Send>>("sync_all")
     }
 
+    fn generic_method_name<T: 'static + ?Sized>() -> String {
+        format!("put::<{:?}>", any::TypeId::of::<T>())
+    }
+
     pub fn get_direct<T: Cacheable>(&self, drp: &DRP)
         -> Box<Future<Item=Box<T>, Error=Error> + Send> {
         self.e.was_called_returning::<*const DRP,
@@ -249,10 +243,10 @@ impl DML for DDMLMock {
                          txg:TxgT)
         -> Box<Future<Item=DRP, Error=Error> + Send>
     {
-        let method_name = self.m.get(&any::TypeId::of::<T>()).unwrap_or(&"put");
+        let method_name = DDMLMock::generic_method_name::<T>();
         self.e.was_called_returning::<(T, Compression, TxgT),
             (Box<Future<Item=DRP, Error=Error> + Send>)>
-            (method_name, (cacheable, compression, txg))
+            (&method_name, (cacheable, compression, txg))
     }
 
     fn sync_all(&self, txg: TxgT) -> Box<Future<Item=(), Error=Error> + Send>

src/common/dml_mock.rs

@@ -5,6 +5,7 @@ use crate::common::cache::{Cacheable, CacheRef};
 use crate::common::dml::*;
 use futures::Future;
 use simulacrum::*;
+use std::any;
 
 /// A very simple mock object that implements `DML` and nothing else.
 pub struct DMLMock {
@@ -38,20 +39,21 @@ impl DMLMock {
     }
 
     // Due to a bug in Simulacrum, mocking DDML::put is way overcomplicated.
-    // The test method must first call `expect_put_type` with the type to be
-    // mocked, and a name for it.  Then `expect_put` and `put` can be used like
-    // normal.
     //
     // Simulacrum can't mock a single generic method with different type
-    // parameters more than once in the same test
+    // parameters more than once in the same test.  The workaround is to
+    // dynamically construct the method name.
     // https://github.com/pcsm/simulacrum/issues/55"]
     pub fn expect_put<T: Cacheable>(&mut self) -> Method<(T, Compression, TxgT),
         Box<Future<Item=u32, Error=Error> + Send>>
     {
-        let method_name = &"put";
         self.e.expect::<(T, Compression, TxgT),
                         Box<Future<Item=u32, Error=Error> + Send>>
-            (method_name)
+            (&DMLMock::generic_method_name::<T>())
+    }
+
+    fn generic_method_name<T: 'static + ?Sized>() -> String {
+        format!("put::<{:?}>", any::TypeId::of::<T>())
     }
 
     pub fn new() -> Self {
@@ -101,10 +103,10 @@ impl DML for DMLMock {
                          txg:TxgT)
         -> Box<Future<Item=u32, Error=Error> + Send>
     {
-        let method_name = &"put";
+        let method_name = DMLMock::generic_method_name::<T>();
         self.e.was_called_returning::<(T, Compression, TxgT),
             (Box<Future<Item=u32, Error=Error> + Send>)>
-            (method_name, (cacheable, compression, txg))
+            (&method_name, (cacheable, compression, txg))
     }
 
     fn sync_all(&self, txg: TxgT) -> Box<Future<Item=(), Error=Error> + Send>

src/common/idml.rs

@@ -1119,10 +1119,6 @@ mod t {
         let mut ddml = DDML::new();
         let drp = DRP::new(PBA::new(0, 0), Compression::None, 40000, 40000,
                            0xdead_beef);
-        ddml.expect_put_type::<Arc<tree::Node<DRP, RID, RidtEntry>>>
-            ("put_ridt");
-        ddml.expect_put_type::<Arc<tree::Node<DRP, PBA, RID>>>
-            ("put_alloct");
         ddml.expect_put::<Arc<tree::Node<DRP, RID, RidtEntry>>>()
             .called_any()
             .with(params!(any(), any(), TxgT::from(42)))