X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Futil%2Ftest_utils.rs;h=fe61e9c7214e25a8ad901f5242aea701e03950fe;hb=583a5b27482e67e0f813f0cbb690fab64250e294;hp=ee5180be70a5ec45a7c19c852818bdfcff95958c;hpb=40626958e451a3d63edbbcf0bc4a5be3f32ff629;p=rust-lightning

diff --git a/lightning/src/util/test_utils.rs b/lightning/src/util/test_utils.rs
index ee5180be..fe61e9c7 100644
--- a/lightning/src/util/test_utils.rs
+++ b/lightning/src/util/test_utils.rs
@@ -32,6 +32,7 @@ use crate::util::enforcing_trait_impls::{EnforcingSigner, EnforcementState};
 use crate::util::logger::{Logger, Level, Record};
 use crate::util::ser::{Readable, ReadableArgs, Writer, Writeable};
 
+use bitcoin::blockdata::constants::ChainHash;
 use bitcoin::blockdata::constants::genesis_block;
 use bitcoin::blockdata::transaction::{Transaction, TxOut};
 use bitcoin::blockdata::script::{Builder, Script};
@@ -126,10 +127,10 @@ impl<'a> Router for TestRouter<'a> {
 						// Since the path is reversed, the last element in our iteration is the first
 						// hop.
 						if idx == path.hops.len() - 1 {
-							scorer.channel_penalty_msat(hop.short_channel_id, &NodeId::from_pubkey(payer), &NodeId::from_pubkey(&hop.pubkey), usage);
+							scorer.channel_penalty_msat(hop.short_channel_id, &NodeId::from_pubkey(payer), &NodeId::from_pubkey(&hop.pubkey), usage, &());
 						} else {
 							let curr_hop_path_idx = path.hops.len() - 1 - idx;
-							scorer.channel_penalty_msat(hop.short_channel_id, &NodeId::from_pubkey(&path.hops[curr_hop_path_idx - 1].pubkey), &NodeId::from_pubkey(&hop.pubkey), usage);
+							scorer.channel_penalty_msat(hop.short_channel_id, &NodeId::from_pubkey(&path.hops[curr_hop_path_idx - 1].pubkey), &NodeId::from_pubkey(&hop.pubkey), usage, &());
 						}
 					}
 				}
@@ -140,7 +141,7 @@ impl<'a> Router for TestRouter<'a> {
 		let scorer = self.scorer.lock().unwrap();
 		find_route(
 			payer, params, &self.network_graph, first_hops, &logger,
-			&ScorerAccountingForInFlightHtlcs::new(scorer, &inflight_htlcs),
+			&ScorerAccountingForInFlightHtlcs::new(scorer, &inflight_htlcs), &(),
 			&[42; 32]
 		)
 	}
@@ -341,17 +342,20 @@ impl TestBroadcaster {
 }
 
 impl chaininterface::BroadcasterInterface for TestBroadcaster {
-	fn broadcast_transaction(&self, tx: &Transaction) {
-		let lock_time = tx.lock_time.0;
-		assert!(lock_time < 1_500_000_000);
-		if bitcoin::LockTime::from(tx.lock_time).is_block_height() && lock_time > self.blocks.lock().unwrap().last().unwrap().1 {
-			for inp in tx.input.iter() {
-				if inp.sequence != Sequence::MAX {
-					panic!("We should never broadcast a transaction before its locktime ({})!", tx.lock_time);
+	fn broadcast_transactions(&self, txs: &[&Transaction]) {
+		for tx in txs {
+			let lock_time = tx.lock_time.0;
+			assert!(lock_time < 1_500_000_000);
+			if bitcoin::LockTime::from(tx.lock_time).is_block_height() && lock_time > self.blocks.lock().unwrap().last().unwrap().1 {
+				for inp in tx.input.iter() {
+					if inp.sequence != Sequence::MAX {
+						panic!("We should never broadcast a transaction before its locktime ({})!", tx.lock_time);
+					}
 				}
 			}
 		}
-		self.txn_broadcasted.lock().unwrap().push(tx.clone());
+		let owned_txs: Vec<Transaction> = txs.iter().map(|tx| (*tx).clone()).collect();
+		self.txn_broadcasted.lock().unwrap().extend(owned_txs);
 	}
 }
 
@@ -359,14 +363,18 @@ pub struct TestChannelMessageHandler {
 	pub pending_events: Mutex<Vec<events::MessageSendEvent>>,
 	expected_recv_msgs: Mutex<Option<Vec<wire::Message<()>>>>,
 	connected_peers: Mutex<HashSet<PublicKey>>,
+	pub message_fetch_counter: AtomicUsize,
+	genesis_hash: ChainHash,
 }
 
 impl TestChannelMessageHandler {
-	pub fn new() -> Self {
+	pub fn new(genesis_hash: ChainHash) -> Self {
 		TestChannelMessageHandler {
 			pending_events: Mutex::new(Vec::new()),
 			expected_recv_msgs: Mutex::new(None),
 			connected_peers: Mutex::new(HashSet::new()),
+			message_fetch_counter: AtomicUsize::new(0),
+			genesis_hash,
 		}
 	}
 
@@ -470,6 +478,10 @@ impl msgs::ChannelMessageHandler for TestChannelMessageHandler {
 		channelmanager::provided_init_features(&UserConfig::default())
 	}
 
+	fn get_genesis_hashes(&self) -> Option<Vec<ChainHash>> {
+		Some(vec![self.genesis_hash])
+	}
+
 	fn handle_open_channel_v2(&self, _their_node_id: &PublicKey, msg: &msgs::OpenChannelV2) {
 		self.received_msg(wire::Message::OpenChannelV2(msg.clone()));
 	}
@@ -517,6 +529,7 @@ impl msgs::ChannelMessageHandler for TestChannelMessageHandler {
 
 impl events::MessageSendEventsProvider for TestChannelMessageHandler {
 	fn get_and_clear_pending_msg_events(&self) -> Vec<events::MessageSendEvent> {
+		self.message_fetch_counter.fetch_add(1, Ordering::AcqRel);
 		let mut pending_events = self.pending_events.lock().unwrap();
 		let mut ret = Vec::new();
 		mem::swap(&mut ret, &mut *pending_events);
@@ -738,7 +751,7 @@ impl Logger for TestLogger {
 	fn log(&self, record: &Record) {
 		*self.lines.lock().unwrap().entry((record.module_path.to_string(), format!("{}", record.args))).or_insert(0) += 1;
 		if record.level >= self.level {
-			#[cfg(feature = "std")]
+			#[cfg(all(not(ldk_bench), feature = "std"))]
 			println!("{:<5} {} [{} : {}, {}] {}", record.level.to_string(), self.id, record.module_path, record.file, record.line, record.args);
 		}
 	}
@@ -1012,8 +1025,9 @@ impl crate::util::ser::Writeable for TestScorer {
 }
 
 impl Score for TestScorer {
+	type ScoreParams = ();
 	fn channel_penalty_msat(
-		&self, short_channel_id: u64, _source: &NodeId, _target: &NodeId, usage: ChannelUsage
+		&self, short_channel_id: u64, _source: &NodeId, _target: &NodeId, usage: ChannelUsage, _score_params: &Self::ScoreParams
 	) -> u64 {
 		if let Some(scorer_expectations) = self.scorer_expectations.borrow_mut().as_mut() {
 			match scorer_expectations.pop_front() {