Macro out getting payment_preimage/hash in network tests

[rust-lightning] / src / ln / channelmanager.rs

diff --git a/src/ln/channelmanager.rs b/src/ln/channelmanager.rs
index ba535d007bc0f8c64678a07008ba41ce6af53760..9818f9d9c9dbe2ca836b425b084463c474e96b1c 100644 (file)
--- a/src/ln/channelmanager.rs
+++ b/src/ln/channelmanager.rs
@@ -365,9 +365,15 @@ impl ChannelManager {
                let channel = Channel::new_outbound(&*self.fee_estimator, chan_keys, their_network_key, channel_value_satoshis, push_msat, self.announce_channels_publicly, user_id, Arc::clone(&self.logger))?;
                let res = channel.get_open_channel(self.genesis_hash.clone(), &*self.fee_estimator);
                let mut channel_state = self.channel_state.lock().unwrap();
-               match channel_state.by_id.insert(channel.channel_id(), channel) {
-                       Some(_) => panic!("RNG is bad???"),
-                       None => {}
+               match channel_state.by_id.entry(channel.channel_id()) {
+                       hash_map::Entry::Occupied(_) => {
+                               if cfg!(feature = "fuzztarget") {
+                                       return Err(APIError::APIMisuseError { err: "Fuzzy bad RNG" });
+                               } else {
+                                       panic!("RNG is bad???");
+                               }
+                       },
+                       hash_map::Entry::Vacant(entry) => { entry.insert(channel); }
                }
 
                let mut events = self.pending_events.lock().unwrap();
@@ -2456,9 +2462,11 @@ mod tests {
        }
        impl Drop for Node {
                fn drop(&mut self) {
-                       // Check that we processed all pending events
-                       assert_eq!(self.node.get_and_clear_pending_events().len(), 0);
-                       assert_eq!(self.chan_monitor.added_monitors.lock().unwrap().len(), 0);
+                       if !::std::thread::panicking() {
+                               // Check that we processed all pending events
+                               assert_eq!(self.node.get_and_clear_pending_events().len(), 0);
+                               assert_eq!(self.chan_monitor.added_monitors.lock().unwrap().len(), 0);
+                       }
                }
        }
 
@@ -2733,16 +2741,22 @@ mod tests {
                }
        }
 
+       macro_rules! get_payment_preimage_hash {
+               ($node: expr) => {
+                       {
+                               let payment_preimage = [*$node.network_payment_count.borrow(); 32];
+                               *$node.network_payment_count.borrow_mut() += 1;
+                               let mut payment_hash = [0; 32];
+                               let mut sha = Sha256::new();
+                               sha.input(&payment_preimage[..]);
+                               sha.result(&mut payment_hash);
+                               (payment_preimage, payment_hash)
+                       }
+               }
+       }
+
        fn send_along_route(origin_node: &Node, route: Route, expected_route: &[&Node], recv_value: u64) -> ([u8; 32], [u8; 32]) {
-               let our_payment_preimage = [*origin_node.network_payment_count.borrow(); 32];
-               *origin_node.network_payment_count.borrow_mut() += 1;
-               let our_payment_hash = {
-                       let mut sha = Sha256::new();
-                       sha.input(&our_payment_preimage[..]);
-                       let mut ret = [0; 32];
-                       sha.result(&mut ret);
-                       ret
-               };
+               let (our_payment_preimage, our_payment_hash) = get_payment_preimage_hash!(origin_node);
 
                let mut payment_event = {
                        origin_node.node.send_payment(route, our_payment_hash).unwrap();
@@ -2900,15 +2914,7 @@ mod tests {
                        assert_eq!(hop.pubkey, node.node.get_our_node_id());
                }
 
-               let our_payment_preimage = [*origin_node.network_payment_count.borrow(); 32];
-               *origin_node.network_payment_count.borrow_mut() += 1;
-               let our_payment_hash = {
-                       let mut sha = Sha256::new();
-                       sha.input(&our_payment_preimage[..]);
-                       let mut ret = [0; 32];
-                       sha.result(&mut ret);
-                       ret
-               };
+               let (_, our_payment_hash) = get_payment_preimage_hash!(origin_node);
 
                let err = origin_node.node.send_payment(route, our_payment_hash).err().unwrap();
                match err {
@@ -3495,15 +3501,7 @@ mod tests {
 
                let route = nodes[0].router.get_route(&nodes[2].node.get_our_node_id(), None, &Vec::new(), 1000000, 42).unwrap();
 
-               let our_payment_preimage = [*nodes[0].network_payment_count.borrow(); 32];
-               *nodes[0].network_payment_count.borrow_mut() += 1;
-               let our_payment_hash = {
-                       let mut sha = Sha256::new();
-                       sha.input(&our_payment_preimage[..]);
-                       let mut ret = [0; 32];
-                       sha.result(&mut ret);
-                       ret
-               };
+               let (our_payment_preimage, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
 
                let mut payment_event = {
                        nodes[0].node.send_payment(route, our_payment_hash).unwrap();