X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Fln%2Ffunctional_test_utils.rs;h=1e99a475fe9f1501dd5042c8b4d344e55a7aa5f8;hb=85b573ddad70f3c5ee36e0992d587842af507a8d;hp=ded630547377913d8f731441f33f60719cd1dec3;hpb=871aec262171f95ec2dfa869021e33ebddd25111;p=rust-lightning

diff --git a/lightning/src/ln/functional_test_utils.rs b/lightning/src/ln/functional_test_utils.rs
index ded630547..1e99a475f 100644
--- a/lightning/src/ln/functional_test_utils.rs
+++ b/lightning/src/ln/functional_test_utils.rs
@@ -20,6 +20,7 @@ use crate::routing::router::{self, PaymentParameters, Route};
 use crate::ln::features::InitFeatures;
 use crate::ln::msgs;
 use crate::ln::msgs::{ChannelMessageHandler,RoutingMessageHandler};
+use crate::util::events::ClosureReason;
 use crate::util::enforcing_trait_impls::EnforcingSigner;
 use crate::util::scid_utils;
 use crate::util::test_utils;
@@ -1231,58 +1232,67 @@ macro_rules! check_warn_msg {
 
 /// Check that a channel's closing channel update has been broadcasted, and optionally
 /// check whether an error message event has occurred.
+pub fn check_closed_broadcast(node: &Node, with_error_msg: bool) -> Option<msgs::ErrorMessage> {
+	let msg_events = node.node.get_and_clear_pending_msg_events();
+	assert_eq!(msg_events.len(), if with_error_msg { 2 } else { 1 });
+	match msg_events[0] {
+		MessageSendEvent::BroadcastChannelUpdate { ref msg } => {
+			assert_eq!(msg.contents.flags & 2, 2);
+		},
+		_ => panic!("Unexpected event"),
+	}
+	if with_error_msg {
+		match msg_events[1] {
+			MessageSendEvent::HandleError { action: msgs::ErrorAction::SendErrorMessage { ref msg }, node_id: _ } => {
+				// TODO: Check node_id
+				Some(msg.clone())
+			},
+			_ => panic!("Unexpected event"),
+		}
+	} else { None }
+}
+
+/// Check that a channel's closing channel update has been broadcasted, and optionally
+/// check whether an error message event has occurred.
+///
+/// Don't use this, use the identically-named function instead.
 #[macro_export]
 macro_rules! check_closed_broadcast {
-	($node: expr, $with_error_msg: expr) => {{
-		use $crate::util::events::MessageSendEvent;
-		use $crate::ln::msgs::ErrorAction;
+	($node: expr, $with_error_msg: expr) => {
+		$crate::ln::functional_test_utils::check_closed_broadcast(&$node, $with_error_msg)
+	}
+}
 
-		let msg_events = $node.node.get_and_clear_pending_msg_events();
-		assert_eq!(msg_events.len(), if $with_error_msg { 2 } else { 1 });
-		match msg_events[0] {
-			MessageSendEvent::BroadcastChannelUpdate { ref msg } => {
-				assert_eq!(msg.contents.flags & 2, 2);
+/// Check that a channel's closing channel events has been issued
+pub fn check_closed_event(node: &Node, events_count: usize, expected_reason: ClosureReason, is_check_discard_funding: bool) {
+	let events = node.node.get_and_clear_pending_events();
+	assert_eq!(events.len(), events_count, "{:?}", events);
+	let mut issues_discard_funding = false;
+	for event in events {
+		match event {
+			Event::ChannelClosed { ref reason, .. } => {
+				assert_eq!(*reason, expected_reason);
 			},
+			Event::DiscardFunding { .. } => {
+				issues_discard_funding = true;
+			}
 			_ => panic!("Unexpected event"),
 		}
-		if $with_error_msg {
-			match msg_events[1] {
-				MessageSendEvent::HandleError { action: ErrorAction::SendErrorMessage { ref msg }, node_id: _ } => {
-					// TODO: Check node_id
-					Some(msg.clone())
-				},
-				_ => panic!("Unexpected event"),
-			}
-		} else { None }
-	}}
+	}
+	assert_eq!(is_check_discard_funding, issues_discard_funding);
 }
 
 /// Check that a channel's closing channel events has been issued
+///
+/// Don't use this, use the identically-named function instead.
 #[macro_export]
 macro_rules! check_closed_event {
 	($node: expr, $events: expr, $reason: expr) => {
 		check_closed_event!($node, $events, $reason, false);
 	};
-	($node: expr, $events: expr, $reason: expr, $is_check_discard_funding: expr) => {{
-		use $crate::util::events::Event;
-
-		let events = $node.node.get_and_clear_pending_events();
-		assert_eq!(events.len(), $events, "{:?}", events);
-		let expected_reason = $reason;
-		let mut issues_discard_funding = false;
-		for event in events {
-			match event {
-				Event::ChannelClosed { ref reason, .. } => {
-					assert_eq!(*reason, expected_reason);
-				},
-				Event::DiscardFunding { .. } => {
-					issues_discard_funding = true;
-				}
-				_ => panic!("Unexpected event"),
-			}
-		}
-		assert_eq!($is_check_discard_funding, issues_discard_funding);
-	}}
+	($node: expr, $events: expr, $reason: expr, $is_check_discard_funding: expr) => {
+		$crate::ln::functional_test_utils::check_closed_event(&$node, $events, $reason, $is_check_discard_funding);
+	}
 }
 
 pub fn close_channel<'a, 'b, 'c>(outbound_node: &Node<'a, 'b, 'c>, inbound_node: &Node<'a, 'b, 'c>, channel_id: &[u8; 32], funding_tx: Transaction, close_inbound_first: bool) -> (msgs::ChannelUpdate, msgs::ChannelUpdate, Transaction) {
@@ -1384,22 +1394,11 @@ impl SendEvent {
 }
 
 #[macro_export]
+/// Don't use this, use the identically-named function instead.
 macro_rules! expect_pending_htlcs_forwardable_conditions {
-	($node: expr, $expected_failures: expr) => {{
-		let expected_failures = $expected_failures;
-		let events = $node.node.get_and_clear_pending_events();
-		match events[0] {
-			$crate::util::events::Event::PendingHTLCsForwardable { .. } => { },
-			_ => panic!("Unexpected event {:?}", events),
-		};
-
-		let count = expected_failures.len() + 1;
-		assert_eq!(events.len(), count);
-
-		if expected_failures.len() > 0 {
-			expect_htlc_handling_failed_destinations!(events, expected_failures)
-		}
-	}}
+	($node: expr, $expected_failures: expr) => {
+		$crate::ln::functional_test_utils::expect_pending_htlcs_forwardable_conditions($node.node.get_and_clear_pending_events(), &$expected_failures);
+	}
 }
 
 #[macro_export]
@@ -1417,27 +1416,49 @@ macro_rules! expect_htlc_handling_failed_destinations {
 	}}
 }
 
+/// Checks that an [`Event::PendingHTLCsForwardable`] is available in the given events and, if
+/// there are any [`Event::HTLCHandlingFailed`] events their [`HTLCDestination`] is included in the
+/// `expected_failures` set.
+pub fn expect_pending_htlcs_forwardable_conditions(events: Vec<Event>, expected_failures: &[HTLCDestination]) {
+	match events[0] {
+		Event::PendingHTLCsForwardable { .. } => { },
+		_ => panic!("Unexpected event {:?}", events),
+	};
+
+	let count = expected_failures.len() + 1;
+	assert_eq!(events.len(), count);
+
+	if expected_failures.len() > 0 {
+		expect_htlc_handling_failed_destinations!(events, expected_failures)
+	}
+}
+
 #[macro_export]
 /// Clears (and ignores) a PendingHTLCsForwardable event
+///
+/// Don't use this, call [`expect_pending_htlcs_forwardable_conditions()`] with an empty failure
+/// set instead.
 macro_rules! expect_pending_htlcs_forwardable_ignore {
-	($node: expr) => {{
-		expect_pending_htlcs_forwardable_conditions!($node, vec![]);
-	}};
+	($node: expr) => {
+		$crate::ln::functional_test_utils::expect_pending_htlcs_forwardable_conditions($node.node.get_and_clear_pending_events(), &[]);
+	}
 }
 
 #[macro_export]
 /// Clears (and ignores) PendingHTLCsForwardable and HTLCHandlingFailed events
+///
+/// Don't use this, call [`expect_pending_htlcs_forwardable_conditions()`] instead.
 macro_rules! expect_pending_htlcs_forwardable_and_htlc_handling_failed_ignore {
-	($node: expr, $expected_failures: expr) => {{
-		expect_pending_htlcs_forwardable_conditions!($node, $expected_failures);
-	}};
+	($node: expr, $expected_failures: expr) => {
+		$crate::ln::functional_test_utils::expect_pending_htlcs_forwardable_conditions($node.node.get_and_clear_pending_events(), &$expected_failures);
+	}
 }
 
 #[macro_export]
 /// Handles a PendingHTLCsForwardable event
 macro_rules! expect_pending_htlcs_forwardable {
 	($node: expr) => {{
-		expect_pending_htlcs_forwardable_ignore!($node);
+		$crate::ln::functional_test_utils::expect_pending_htlcs_forwardable_conditions($node.node.get_and_clear_pending_events(), &[]);
 		$node.node.process_pending_htlc_forwards();
 
 		// Ensure process_pending_htlc_forwards is idempotent.
@@ -1449,7 +1470,7 @@ macro_rules! expect_pending_htlcs_forwardable {
 /// Handles a PendingHTLCsForwardable and HTLCHandlingFailed event
 macro_rules! expect_pending_htlcs_forwardable_and_htlc_handling_failed {
 	($node: expr, $expected_failures: expr) => {{
-		expect_pending_htlcs_forwardable_and_htlc_handling_failed_ignore!($node, $expected_failures);
+		$crate::ln::functional_test_utils::expect_pending_htlcs_forwardable_conditions($node.node.get_and_clear_pending_events(), &$expected_failures);
 		$node.node.process_pending_htlc_forwards();
 
 		// Ensure process_pending_htlc_forwards is idempotent.