#[macro_export]
macro_rules! check_closed_broadcast {
($node: expr, $with_error_msg: expr) => {{
- let events = $node.node.get_and_clear_pending_msg_events();
- assert_eq!(events.len(), if $with_error_msg { 2 } else { 1 });
- match events[0] {
+ 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 events[1] {
+ match msg_events[1] {
MessageSendEvent::HandleError { action: ErrorAction::SendErrorMessage { ref msg }, node_id: _ } => {
// TODO: Check node_id
Some(msg.clone())
}}
}
+/// Check that a channel's closing channel event has been issued
+#[macro_export]
+macro_rules! check_closed_event {
+ ($node: expr, $events: expr) => {{
+ let events = $node.node.get_and_clear_pending_events();
+ assert_eq!(events.len(), $events);
+ match events[0] {
+ Event::ChannelClosed { .. } => {}
+ _ => panic!("Unexpected event"),
+ }
+ }}
+}
+
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) {
let (node_a, broadcaster_a, struct_a) = if close_inbound_first { (&inbound_node.node, &inbound_node.tx_broadcaster, inbound_node) } else { (&outbound_node.node, &outbound_node.tx_broadcaster, outbound_node) };
let (node_b, broadcaster_b, struct_b) = if close_inbound_first { (&outbound_node.node, &outbound_node.tx_broadcaster, outbound_node) } else { (&inbound_node.node, &inbound_node.tx_broadcaster, inbound_node) };
{
commitment_signed_dance!($node_a, $node_b, $commitment_signed, $fail_backwards, true);
if $fail_backwards {
- expect_pending_htlcs_forwardable!($node_a);
+ let events = $node_a.node.get_and_clear_pending_events();
+ expect_pending_htlcs_forwardable!($node_a, events);
check_added_monitors!($node_a, 1);
let channel_state = $node_a.node.channel_state.lock().unwrap();
}
macro_rules! expect_pending_htlcs_forwardable_ignore {
- ($node: expr) => {{
- let events = $node.node.get_and_clear_pending_events();
- assert_eq!(events.len(), 1);
- match events[0] {
+ ($node: expr, $events: expr) => {{
+ assert_eq!($events.len(), 1);
+ match $events[0] {
Event::PendingHTLCsForwardable { .. } => { },
_ => panic!("Unexpected event"),
};
}
macro_rules! expect_pending_htlcs_forwardable {
- ($node: expr) => {{
- expect_pending_htlcs_forwardable_ignore!($node);
+ ($node: expr, $events: expr) => {{
+ expect_pending_htlcs_forwardable_ignore!($node, $events);
$node.node.process_pending_htlc_forwards();
}}
}
}
macro_rules! expect_payment_sent {
- ($node: expr, $expected_payment_preimage: expr) => {
- let events = $node.node.get_and_clear_pending_events();
- assert_eq!(events.len(), 1);
- match events[0] {
+ ($node: expr, $expected_payment_preimage: expr, $events: expr) => {
+ assert_eq!($events.len(), 1);
+ match $events[0] {
Event::PaymentSent { ref payment_preimage } => {
assert_eq!($expected_payment_preimage, *payment_preimage);
},
let events = $node.node.get_and_clear_pending_events();
assert_eq!(events.len(), 1);
match events[0] {
- Event::PaymentFailed { ref payment_hash, rejected_by_dest, ref network_update, ref error_code, ref error_data } => {
+ Event::PaymentFailed { ref payment_hash, rejected_by_dest, ref network_update, ref error_code, ref error_data, .. } => {
assert_eq!(*payment_hash, $expected_payment_hash, "unexpected payment_hash");
assert_eq!(rejected_by_dest, $rejected_by_dest, "unexpected rejected_by_dest value");
assert!(error_code.is_some(), "expected error_code.is_some() = true");
#[cfg(test)]
macro_rules! expect_payment_failed {
- ($node: expr, $expected_payment_hash: expr, $rejected_by_dest: expr $(, $expected_error_code: expr, $expected_error_data: expr)*) => {
- let events = $node.node.get_and_clear_pending_events();
+ ($node: expr, $events: expr, $expected_payment_hash: expr, $rejected_by_dest: expr $(, $expected_error_code: expr, $expected_error_data: expr)*) => {
+ let events: Vec<Event> = $events;
assert_eq!(events.len(), 1);
match events[0] {
- Event::PaymentFailed { ref payment_hash, rejected_by_dest, network_update: _, ref error_code, ref error_data } => {
+ Event::PaymentFailed { ref payment_hash, rejected_by_dest, network_update: _, ref error_code, ref error_data, .. } => {
assert_eq!(*payment_hash, $expected_payment_hash, "unexpected payment_hash");
assert_eq!(rejected_by_dest, $rejected_by_dest, "unexpected rejected_by_dest value");
assert!(error_code.is_some(), "expected error_code.is_some() = true");
check_added_monitors!(node, 0);
commitment_signed_dance!(node, prev_node, payment_event.commitment_msg, false);
- expect_pending_htlcs_forwardable!(node);
+ let events = node.node.get_and_clear_pending_events();
+ expect_pending_htlcs_forwardable!(node, events);
if idx == expected_path.len() - 1 {
let events_2 = node.node.get_and_clear_pending_events();
}
}
if !skip_last {
- expect_payment_sent!(origin_node, our_payment_preimage);
+ let events = origin_node.node.get_and_clear_pending_events();
+ expect_payment_sent!(origin_node, our_payment_preimage, events);
}
}
assert_eq!(path.last().unwrap().node.get_our_node_id(), expected_paths[0].last().unwrap().node.get_our_node_id());
}
assert!(expected_paths[0].last().unwrap().node.fail_htlc_backwards(&our_payment_hash));
- expect_pending_htlcs_forwardable!(expected_paths[0].last().unwrap());
+ let events = expected_paths[0].last().unwrap().node.get_and_clear_pending_events();
+ expect_pending_htlcs_forwardable!(expected_paths[0].last().unwrap(), events);
check_added_monitors!(expected_paths[0].last().unwrap(), expected_paths.len());
let mut per_path_msgs: Vec<((msgs::UpdateFailHTLC, msgs::CommitmentSigned), PublicKey)> = Vec::with_capacity(expected_paths.len());
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);
+ let events = node.node.get_and_clear_pending_events();
+ expect_pending_htlcs_forwardable!(node, events);
}
}
let events = node.node.get_and_clear_pending_msg_events();
let events = origin_node.node.get_and_clear_pending_events();
assert_eq!(events.len(), 1);
match events[0] {
- Event::PaymentFailed { payment_hash, rejected_by_dest, .. } => {
+ Event::PaymentFailed { payment_hash, rejected_by_dest, all_paths_failed, .. } => {
assert_eq!(payment_hash, our_payment_hash);
assert!(rejected_by_dest);
+ assert_eq!(all_paths_failed, i == expected_paths.len() - 1);
},
_ => panic!("Unexpected event"),
}