Relicense as dual Apache-2.0 + MIT

[rust-lightning] / lightning / src / util / test_utils.rs

diff --git a/lightning/src/util/test_utils.rs b/lightning/src/util/test_utils.rs
index 2134c26f9f605e81126bab0632e25eac4227c523..d684e9c07b5fce335d893e8b93ee5cdb698b7d7a 100644 (file)
--- a/lightning/src/util/test_utils.rs
+++ b/lightning/src/util/test_utils.rs
@@ -1,3 +1,12 @@
+// This file is Copyright its original authors, visible in version control
+// history.
+//
+// This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
+// or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
+// You may not use this file except in accordance with one or both of these
+// licenses.
+
 use chain::chaininterface;
 use chain::chaininterface::{ConfirmationTarget, ChainError, ChainWatchInterface};
 use chain::transaction::OutPoint;
@@ -5,6 +14,7 @@ use chain::keysinterface;
 use ln::channelmonitor;
 use ln::features::{ChannelFeatures, InitFeatures};
 use ln::msgs;
+use ln::msgs::OptionalField;
 use ln::channelmonitor::HTLCUpdate;
 use util::enforcing_trait_impls::EnforcingChannelKeys;
 use util::events;
@@ -22,6 +32,8 @@ use bitcoin::hash_types::{Txid, BlockHash};
 
 use bitcoin::secp256k1::{SecretKey, PublicKey, Secp256k1, Signature};
 
+use regex;
+
 use std::time::Duration;
 use std::sync::Mutex;
 use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
@@ -214,6 +226,7 @@ fn get_dummy_channel_update(short_chan_id: u64) -> msgs::ChannelUpdate {
                        flags: 0,
                        cltv_expiry_delta: 0,
                        htlc_minimum_msat: 0,
+                       htlc_maximum_msat: OptionalField::Absent,
                        fee_base_msat: 0,
                        fee_proportional_millionths: 0,
                        excess_data: vec![],
@@ -240,15 +253,15 @@ impl TestRoutingMessageHandler {
 }
 impl msgs::RoutingMessageHandler for TestRoutingMessageHandler {
        fn handle_node_announcement(&self, _msg: &msgs::NodeAnnouncement) -> Result<bool, msgs::LightningError> {
-               Err(msgs::LightningError { err: "", action: msgs::ErrorAction::IgnoreError })
+               Err(msgs::LightningError { err: "".to_owned(), action: msgs::ErrorAction::IgnoreError })
        }
        fn handle_channel_announcement(&self, _msg: &msgs::ChannelAnnouncement) -> Result<bool, msgs::LightningError> {
                self.chan_anns_recvd.fetch_add(1, Ordering::AcqRel);
-               Err(msgs::LightningError { err: "", action: msgs::ErrorAction::IgnoreError })
+               Err(msgs::LightningError { err: "".to_owned(), action: msgs::ErrorAction::IgnoreError })
        }
        fn handle_channel_update(&self, _msg: &msgs::ChannelUpdate) -> Result<bool, msgs::LightningError> {
                self.chan_upds_recvd.fetch_add(1, Ordering::AcqRel);
-               Err(msgs::LightningError { err: "", action: msgs::ErrorAction::IgnoreError })
+               Err(msgs::LightningError { err: "".to_owned(), action: msgs::ErrorAction::IgnoreError })
        }
        fn handle_htlc_fail_channel_update(&self, _update: &msgs::HTLCFailChannelUpdate) {}
        fn get_next_channel_announcements(&self, starting_point: u64, batch_amount: u8) -> Vec<(msgs::ChannelAnnouncement, Option<msgs::ChannelUpdate>, Option<msgs::ChannelUpdate>)> {
@@ -300,6 +313,30 @@ impl TestLogger {
                let log_entries = self.lines.lock().unwrap();
                assert_eq!(log_entries.get(&(module, line)), Some(&count));
        }
+
+       /// Search for the number of occurrence of the logged lines which
+       /// 1. belongs to the specified module and
+       /// 2. contains `line` in it.
+       /// And asserts if the number of occurrences is the same with the given `count`
+       pub fn assert_log_contains(&self, module: String, line: String, count: usize) {
+               let log_entries = self.lines.lock().unwrap();
+               let l: usize = log_entries.iter().filter(|&(&(ref m, ref l), _c)| {
+                       m == &module && l.contains(line.as_str())
+               }).map(|(_, c) | { c }).sum();
+               assert_eq!(l, count)
+       }
+
+    /// Search for the number of occurrences of logged lines which
+    /// 1. belong to the specified module and
+    /// 2. match the given regex pattern.
+    /// Assert that the number of occurrences equals the given `count`
+       pub fn assert_log_regex(&self, module: String, pattern: regex::Regex, count: usize) {
+               let log_entries = self.lines.lock().unwrap();
+               let l: usize = log_entries.iter().filter(|&(&(ref m, ref l), _c)| {
+                       m == &module && pattern.is_match(&l)
+               }).map(|(_, c) | { c }).sum();
+               assert_eq!(l, count)
+       }
 }
 
 impl Logger for TestLogger {