X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Fln%2Ffunctional_test_utils.rs;h=54d199a26f83f85cec4567baa1b1fae45d9e6faa;hb=c242003dd3c430a8395af1e48bd1e5c1f5ed94ae;hp=cff632e4bc86b6a9e2a9f36b9b9787c0d3d6f8e7;hpb=1988cb22cc510a62b92d67b78058c49922df47d0;p=rust-lightning

diff --git a/lightning/src/ln/functional_test_utils.rs b/lightning/src/ln/functional_test_utils.rs
index cff632e4..54d199a2 100644
--- a/lightning/src/ln/functional_test_utils.rs
+++ b/lightning/src/ln/functional_test_utils.rs
@@ -24,7 +24,7 @@ use util::enforcing_trait_impls::EnforcingSigner;
 use util::scid_utils;
 use util::test_utils;
 use util::test_utils::{panicking, TestChainMonitor};
-use util::events::{Event, MessageSendEvent, MessageSendEventsProvider, PaymentPurpose};
+use util::events::{Event, HTLCDestination, MessageSendEvent, MessageSendEventsProvider, PaymentPurpose};
 use util::errors::APIError;
 use util::config::UserConfig;
 use util::ser::{ReadableArgs, Writeable};
@@ -46,6 +46,7 @@ use core::cell::RefCell;
 use alloc::rc::Rc;
 use sync::{Arc, Mutex};
 use core::mem;
+use core::iter::repeat;
 
 pub const CHAN_CONFIRM_DEPTH: u32 = 10;
 
@@ -1185,7 +1186,7 @@ macro_rules! commitment_signed_dance {
 		{
 			commitment_signed_dance!($node_a, $node_b, $commitment_signed, $fail_backwards, true);
 			if $fail_backwards {
-				$crate::expect_pending_htlcs_forwardable!($node_a);
+				expect_pending_htlcs_forwardable_and_htlc_handling_failed!($node_a, vec![$crate::util::events::HTLCDestination::NextHopChannel{ node_id: Some($node_b.node.get_our_node_id()), channel_id: $commitment_signed.channel_id }]);
 				check_added_monitors!($node_a, 1);
 
 				let channel_state = $node_a.node.channel_state.lock().unwrap();
@@ -1253,23 +1254,72 @@ macro_rules! get_route_and_payment_hash {
 }
 
 #[macro_export]
-/// Clears (and ignores) a PendingHTLCsForwardable event
-macro_rules! expect_pending_htlcs_forwardable_ignore {
-	($node: expr) => {{
+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();
-		assert_eq!(events.len(), 1);
 		match events[0] {
 			$crate::util::events::Event::PendingHTLCsForwardable { .. } => { },
 			_ => panic!("Unexpected event"),
 		};
+
+		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]
+macro_rules! expect_htlc_handling_failed_destinations {
+	($events: expr, $expected_failures: expr) => {{
+		for event in $events {
+			match event {
+				$crate::util::events::Event::PendingHTLCsForwardable { .. } => { },
+				$crate::util::events::Event::HTLCHandlingFailed { ref failed_next_destination, .. } => {
+					assert!($expected_failures.contains(&failed_next_destination))
+				},
+				_ => panic!("Unexpected destination"),
+			}
+		}
+	}}
+}
+
+#[macro_export]
+/// Clears (and ignores) a PendingHTLCsForwardable event
+macro_rules! expect_pending_htlcs_forwardable_ignore {
+	($node: expr) => {{
+		expect_pending_htlcs_forwardable_conditions!($node, vec![]);
+	}};
+}
+
+#[macro_export]
+/// Clears (and ignores) PendingHTLCsForwardable and HTLCHandlingFailed events
+macro_rules! expect_pending_htlcs_forwardable_and_htlc_handling_failed_ignore {
+	($node: expr, $expected_failures: expr) => {{
+		expect_pending_htlcs_forwardable_conditions!($node, $expected_failures);
+	}};
+}
+
 #[macro_export]
 /// Handles a PendingHTLCsForwardable event
 macro_rules! expect_pending_htlcs_forwardable {
 	($node: expr) => {{
-		$crate::expect_pending_htlcs_forwardable_ignore!($node);
+		expect_pending_htlcs_forwardable_ignore!($node);
+		$node.node.process_pending_htlc_forwards();
+
+		// Ensure process_pending_htlc_forwards is idempotent.
+		$node.node.process_pending_htlc_forwards();
+	}};
+}
+
+#[macro_export]
+/// 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);
 		$node.node.process_pending_htlc_forwards();
 
 		// Ensure process_pending_htlc_forwards is idempotent.
@@ -1814,7 +1864,8 @@ pub fn fail_payment_along_route<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expe
 		assert_eq!(path.last().unwrap().node.get_our_node_id(), expected_paths[0].last().unwrap().node.get_our_node_id());
 	}
 	expected_paths[0].last().unwrap().node.fail_htlc_backwards(&our_payment_hash);
-	expect_pending_htlcs_forwardable!(expected_paths[0].last().unwrap());
+	let expected_destinations: Vec<HTLCDestination> = repeat(HTLCDestination::FailedPayment { payment_hash: our_payment_hash }).take(expected_paths.len()).collect();
+	expect_pending_htlcs_forwardable_and_htlc_handling_failed!(expected_paths[0].last().unwrap(), expected_destinations);
 
 	pass_failed_payment_back(origin_node, expected_paths, skip_last, our_payment_hash);
 }
@@ -1855,7 +1906,7 @@ pub fn pass_failed_payment_back<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expe
 				node.node.handle_update_fail_htlc(&prev_node.node.get_our_node_id(), &next_msgs.as_ref().unwrap().0);
 				commitment_signed_dance!(node, prev_node, next_msgs.as_ref().unwrap().1, update_next_node);
 				if !update_next_node {
-					expect_pending_htlcs_forwardable!(node);
+					expect_pending_htlcs_forwardable_and_htlc_handling_failed!(node, vec![HTLCDestination::NextHopChannel { node_id: Some(prev_node.node.get_our_node_id()), channel_id: next_msgs.as_ref().unwrap().0.channel_id }]);
 				}
 			}
 			let events = node.node.get_and_clear_pending_msg_events();