f cleanup test_closing_signed_reinit_timeout readability

Author: TheBlueMatt

lightning/src/ln/shutdown_tests.rs

@@ -727,7 +727,14 @@ fn test_invalid_shutdown_script() {
 	check_added_monitors!(nodes[0], 1);
 }
 
-fn do_test_closing_signed_reinit_timeout(timeout_step: u8) {
+#[derive(PartialEq)]
+enum TimeoutStep {
+	AfterShutdown,
+	AfterClosingSigned,
+	NoTimeout,
+}
+
+fn do_test_closing_signed_reinit_timeout(timeout_step: TimeoutStep) {
 	// The range-based closing signed negotiation allows the funder to restart the process with a
 	// new range if the previous range did not overlap. This allows implementations to request user
 	// intervention allowing users to enter a new fee range. We do not implement the sending side
@@ -759,9 +766,11 @@ fn do_test_closing_signed_reinit_timeout(timeout_step: u8) {
 	}
 
 	let mut node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id());
+	// nodes[0] should use a "reasonable" feerate, well under the 10 sat/vByte that nodes[1] thinks
+	// is the current prevailing feerate.
 	assert!(node_0_closing_signed.fee_satoshis <= 500);
 
-	if timeout_step != 0 {
+	if timeout_step != TimeoutStep::AfterShutdown {
 		nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed);
 		// At this point nodes[1] should send back a warning message indicating it disagrees with the
 		// given channel-closing fee. Currently we do not implement warning messages so instead we
@@ -779,12 +788,12 @@ fn do_test_closing_signed_reinit_timeout(timeout_step: u8) {
 		let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id());
 		nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed);
 		let node_0_2nd_closing_signed = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
-		if timeout_step > 1 {
+		if timeout_step == TimeoutStep::NoTimeout {
 			nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed.1.unwrap());
 		}
 	}
 
-	if timeout_step <= 1 {
+	if timeout_step != TimeoutStep::NoTimeout {
 		assert!(nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().is_empty());
 	} else {
 		assert_eq!(nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().len(), 1);
@@ -797,17 +806,16 @@ fn do_test_closing_signed_reinit_timeout(timeout_step: u8) {
 	assert_eq!(txn.len(), 1);
 	assert_eq!(txn[0].output.len(), 2);
 
-	// If we timed out we should have a P2WPKH and P2WSH output, otherwise both should be P2WPKH.
-	if timeout_step <= 1 {
-		assert!((txn[0].output[0].script_pubkey.len() == 20+1+1 &&
-		         txn[0].output[1].script_pubkey.len() == 32+1+1) ||
-		        (txn[0].output[1].script_pubkey.len() == 20+1+1 &&
-		         txn[0].output[0].script_pubkey.len() == 32+1+1));
+	if timeout_step != TimeoutStep::NoTimeout {
+		assert!((txn[0].output[0].script_pubkey.is_v0_p2wpkh() &&
+		         txn[0].output[1].script_pubkey.is_v0_p2wsh()) ||
+		        (txn[0].output[1].script_pubkey.is_v0_p2wpkh() &&
+		         txn[0].output[0].script_pubkey.is_v0_p2wsh()));
 		check_closed_broadcast!(nodes[1], true);
 		check_added_monitors!(nodes[1], 1);
 	} else {
-		assert_eq!(txn[0].output[0].script_pubkey.len(), 20+1+1);
-		assert_eq!(txn[0].output[1].script_pubkey.len(), 20+1+1);
+		assert!(txn[0].output[0].script_pubkey.is_v0_p2wpkh());
+		assert!(txn[0].output[1].script_pubkey.is_v0_p2wpkh());
 
 		let events = nodes[1].node.get_and_clear_pending_msg_events();
 		assert_eq!(events.len(), 1);
@@ -822,7 +830,7 @@ fn do_test_closing_signed_reinit_timeout(timeout_step: u8) {
 
 #[test]
 fn test_closing_signed_reinit_timeout() {
-	do_test_closing_signed_reinit_timeout(0);
-	do_test_closing_signed_reinit_timeout(1);
-	do_test_closing_signed_reinit_timeout(2);
+	do_test_closing_signed_reinit_timeout(TimeoutStep::AfterShutdown);
+	do_test_closing_signed_reinit_timeout(TimeoutStep::AfterClosingSigned);
+	do_test_closing_signed_reinit_timeout(TimeoutStep::NoTimeout);
 }