Replace Arc.clone()s with Arc::clone() in remaining tests

`arc.clone()` leaves the code somewhat ambiguous to whether we're
doing an expensive deep-clone operation or if we're doing a
(relatively) cheap pointer-copy-and-atomic-increment operation.

More importantly, it leaves entirely unclear what the semantics of
the object we just created are - does updating it update the
original or leave it be?

Thus, here, we replace `arc.clone()` calls with `Arc::clone()` in
remaining tests.

Author: TheBlueMatt

lightning-liquidity/src/lsps0/service.rs

@@ -93,7 +93,8 @@ mod tests {
 		let protocols: Vec<u16> = vec![];
 		let pending_messages = Arc::new(MessageQueue::new());
 
-		let lsps0_handler = Arc::new(LSPS0ServiceHandler::new(protocols, pending_messages.clone()));
+		let lsps0_handler =
+			Arc::new(LSPS0ServiceHandler::new(protocols, Arc::clone(&pending_messages)));
 
 		let list_protocols_request = LSPS0Message::Request(
 			LSPSRequestId("xyz123".to_string()),

lightning-liquidity/tests/common/mod.rs

@@ -408,16 +408,16 @@ pub(crate) fn create_liquidity_node(
 	let fee_estimator = Arc::new(test_utils::TestFeeEstimator::new(253));
 	let logger = Arc::new(test_utils::TestLogger::with_id(format!("node {}", i)));
 	let genesis_block = genesis_block(network);
-	let network_graph = Arc::new(NetworkGraph::new(network, logger.clone()));
+	let network_graph = Arc::new(NetworkGraph::new(network, Arc::clone(&logger)));
 	let scorer = Arc::new(LockingWrapper::new(TestScorer::new()));
 	let now = Duration::from_secs(genesis_block.header.time as u64);
 	let seed = [i as u8; 32];
 	let keys_manager = Arc::new(KeysManager::new(&seed, now.as_secs(), now.subsec_nanos()));
 	let router = Arc::new(DefaultRouter::new(
 		Arc::clone(&network_graph),
-		logger.clone(),
-		keys_manager.clone(),
-		scorer.clone(),
+		Arc::clone(&logger),
+		Arc::clone(&keys_manager),
+		Arc::clone(&scorer),
 		Default::default(),
 	));
 	let msg_router =
@@ -426,34 +426,34 @@ pub(crate) fn create_liquidity_node(
 	let kv_store =
 		Arc::new(FilesystemStore::new(format!("{}_persister_{}", &persist_dir, i).into()));
 	let chain_monitor = Arc::new(chainmonitor::ChainMonitor::new(
-		Some(chain_source.clone()),
-		tx_broadcaster.clone(),
-		logger.clone(),
-		fee_estimator.clone(),
-		kv_store.clone(),
-		keys_manager.clone(),
+		Some(Arc::clone(&chain_source)),
+		Arc::clone(&tx_broadcaster),
+		Arc::clone(&logger),
+		Arc::clone(&fee_estimator),
+		Arc::clone(&kv_store),
+		Arc::clone(&keys_manager),
 		keys_manager.get_peer_storage_key(),
 	));
 	let best_block = BestBlock::from_network(network);
 	let chain_params = ChainParameters { network, best_block };
 	let channel_manager = Arc::new(ChannelManager::new(
-		fee_estimator.clone(),
-		chain_monitor.clone(),
-		tx_broadcaster.clone(),
-		router.clone(),
-		msg_router.clone(),
-		logger.clone(),
-		keys_manager.clone(),
-		keys_manager.clone(),
-		keys_manager.clone(),
+		Arc::clone(&fee_estimator),
+		Arc::clone(&chain_monitor),
+		Arc::clone(&tx_broadcaster),
+		Arc::clone(&router),
+		Arc::clone(&msg_router),
+		Arc::clone(&logger),
+		Arc::clone(&keys_manager),
+		Arc::clone(&keys_manager),
+		Arc::clone(&keys_manager),
 		UserConfig::default(),
 		chain_params,
 		genesis_block.header.time,
 	));
 	let p2p_gossip_sync = Arc::new(P2PGossipSync::new(
-		network_graph.clone(),
-		Some(chain_source.clone()),
-		logger.clone(),
+		Arc::clone(&network_graph),
+		Some(Arc::clone(&chain_source)),
+		Arc::clone(&logger),
 	));
 
 	let liquidity_manager = Arc::new(LiquidityManager::new(
@@ -474,13 +474,13 @@ pub(crate) fn create_liquidity_node(
 		send_only_message_handler: Arc::clone(&chain_monitor),
 	};
 	let peer_manager =
-		Arc::new(PeerManager::new(msg_handler, 0, &seed, logger.clone(), keys_manager.clone()));
+		PeerManager::new(msg_handler, 0, &seed, Arc::clone(&logger), Arc::clone(&keys_manager));
 
 	Node {
 		channel_manager,
 		keys_manager,
 		p2p_gossip_sync,
-		peer_manager,
+		peer_manager: Arc::new(peer_manager),
 		liquidity_manager,
 		chain_monitor,
 		kv_store,

lightning/src/ln/functional_test_utils.rs

@@ -3355,8 +3355,8 @@ pub fn create_node_cfgs_with_persisters<'a>(node_count: usize, chanmon_cfgs: &'a
 			logger: &chanmon_cfgs[i].logger,
 			tx_broadcaster: &chanmon_cfgs[i].tx_broadcaster,
 			fee_estimator: &chanmon_cfgs[i].fee_estimator,
-			router: test_utils::TestRouter::new(network_graph.clone(), &chanmon_cfgs[i].logger, &chanmon_cfgs[i].scorer),
-			message_router: test_utils::TestMessageRouter::new(network_graph.clone(), &chanmon_cfgs[i].keys_manager),
+			router: test_utils::TestRouter::new(Arc::clone(&network_graph), &chanmon_cfgs[i].logger, &chanmon_cfgs[i].scorer),
+			message_router: test_utils::TestMessageRouter::new(Arc::clone(&network_graph), &chanmon_cfgs[i].keys_manager),
 			chain_monitor,
 			keys_manager: &chanmon_cfgs[i].keys_manager,
 			node_seed: seed,
@@ -3425,19 +3425,19 @@ pub fn create_network<'a, 'b: 'a, 'c: 'b>(node_count: usize, cfgs: &'b Vec<NodeC
 		);
 		let gossip_sync = P2PGossipSync::new(cfgs[i].network_graph.as_ref(), None, cfgs[i].logger);
 		let wallet_source = Arc::new(test_utils::TestWalletSource::new(SecretKey::from_slice(&[i as u8 + 1; 32]).unwrap()));
-		let wallet = Arc::new(WalletSync::new(wallet_source.clone(), cfgs[i].logger));
+		let wallet = Arc::new(WalletSync::new(Arc::clone(&wallet_source), cfgs[i].logger));
 		nodes.push(Node{
 			chain_source: cfgs[i].chain_source, tx_broadcaster: cfgs[i].tx_broadcaster,
 			fee_estimator: cfgs[i].fee_estimator, router: &cfgs[i].router,
 			message_router: &cfgs[i].message_router, chain_monitor: &cfgs[i].chain_monitor,
 			keys_manager: &cfgs[i].keys_manager, node: &chan_mgrs[i],
 			network_graph: cfgs[i].network_graph.as_ref(), gossip_sync,
-			node_seed: cfgs[i].node_seed, onion_messenger, network_chan_count: chan_count.clone(),
-			network_payment_count: payment_count.clone(), logger: cfgs[i].logger,
+			node_seed: cfgs[i].node_seed, onion_messenger, network_chan_count: Rc::clone(&chan_count),
+			network_payment_count: Rc::clone(&payment_count), logger: cfgs[i].logger,
 			blocks: Arc::clone(&cfgs[i].tx_broadcaster.blocks),
 			connect_style: Rc::clone(&connect_style),
 			override_init_features: Rc::clone(&cfgs[i].override_init_features),
-			wallet_source: wallet_source.clone(),
+			wallet_source: Arc::clone(&wallet_source),
 			bump_tx_handler: BumpTransactionEventHandlerSync::new(
 				cfgs[i].tx_broadcaster, wallet,
 				&cfgs[i].keys_manager, cfgs[i].logger,

lightning/src/ln/functional_tests.rs

@@ -5173,8 +5173,9 @@ pub fn test_key_derivation_params() {
 	let network_graph = Arc::new(NetworkGraph::new(Network::Testnet, &chanmon_cfgs[0].logger));
 	let scorer = RwLock::new(test_utils::TestScorer::new());
 	let router =
-		test_utils::TestRouter::new(network_graph.clone(), &chanmon_cfgs[0].logger, &scorer);
-	let message_router = test_utils::TestMessageRouter::new(network_graph.clone(), &keys_manager);
+		test_utils::TestRouter::new(Arc::clone(&network_graph), &chanmon_cfgs[0].logger, &scorer);
+	let message_router =
+		test_utils::TestMessageRouter::new(Arc::clone(&network_graph), &keys_manager);
 	let node = NodeCfg {
 		chain_source: &chanmon_cfgs[0].chain_source,
 		logger: &chanmon_cfgs[0].logger,

lightning/src/onion_message/functional_tests.rs

@@ -266,8 +266,8 @@ impl MessengerCfg {
 
 fn create_nodes_using_cfgs(cfgs: Vec<MessengerCfg>) -> Vec<MessengerNode> {
 	let gossip_logger = Arc::new(TestLogger::with_id("gossip".to_string()));
-	let network_graph = Arc::new(NetworkGraph::new(Network::Testnet, gossip_logger.clone()));
-	let gossip_sync = Arc::new(P2PGossipSync::new(network_graph.clone(), None, gossip_logger));
+	let network_graph = Arc::new(NetworkGraph::new(Network::Testnet, Arc::clone(&gossip_logger)));
+	let gossip_sync = Arc::new(P2PGossipSync::new(Arc::clone(&network_graph), None, gossip_logger));
 
 	let mut nodes = Vec::new();
 	for (i, cfg) in cfgs.into_iter().enumerate() {
@@ -280,34 +280,34 @@ fn create_nodes_using_cfgs(cfgs: Vec<MessengerCfg>) -> Vec<MessengerNode> {
 
 		let node_id_lookup = Arc::new(EmptyNodeIdLookUp {});
 		let message_router =
-			Arc::new(DefaultMessageRouter::new(network_graph.clone(), entropy_source.clone()));
+			DefaultMessageRouter::new(Arc::clone(&network_graph), Arc::clone(&entropy_source));
 		let offers_message_handler = Arc::new(TestOffersMessageHandler {});
 		let async_payments_message_handler = Arc::new(TestAsyncPaymentsMessageHandler {});
 		let dns_resolver_message_handler = Arc::new(TestDNSResolverMessageHandler {});
 		let custom_message_handler = Arc::new(TestCustomMessageHandler::new());
 		let messenger = if cfg.intercept_offline_peer_oms {
 			OnionMessenger::new_with_offline_peer_interception(
-				entropy_source.clone(),
-				node_signer.clone(),
-				logger.clone(),
+				Arc::clone(&entropy_source),
+				Arc::clone(&node_signer),
+				logger,
 				node_id_lookup,
-				message_router,
+				Arc::new(message_router),
 				offers_message_handler,
 				async_payments_message_handler,
 				dns_resolver_message_handler,
-				custom_message_handler.clone(),
+				Arc::clone(&custom_message_handler),
 			)
 		} else {
 			OnionMessenger::new(
-				entropy_source.clone(),
-				node_signer.clone(),
-				logger.clone(),
+				Arc::clone(&entropy_source),
+				Arc::clone(&node_signer),
+				logger,
 				node_id_lookup,
-				message_router,
+				Arc::new(message_router),
 				offers_message_handler,
 				async_payments_message_handler,
 				dns_resolver_message_handler,
-				custom_message_handler.clone(),
+				Arc::clone(&custom_message_handler),
 			)
 		};
 		nodes.push(MessengerNode {
@@ -316,7 +316,7 @@ fn create_nodes_using_cfgs(cfgs: Vec<MessengerCfg>) -> Vec<MessengerNode> {
 			entropy_source,
 			messenger,
 			custom_message_handler,
-			gossip_sync: gossip_sync.clone(),
+			gossip_sync: Arc::clone(&gossip_sync),
 		});
 	}
 	for i in 0..nodes.len() - 1 {

lightning/src/routing/router.rs

@@ -8414,8 +8414,8 @@ mod tests {
 		let secp_ctx = Secp256k1::new();
 		let logger = Arc::new(ln_test_utils::TestLogger::new());
 		let network_graph = Arc::new(NetworkGraph::new(Network::Testnet, Arc::clone(&logger)));
-		let gossip_sync = P2PGossipSync::new(network_graph.clone(), None, logger.clone());
-		let scorer = ProbabilisticScorer::new(ProbabilisticScoringDecayParameters::default(), network_graph.clone(), logger.clone());
+		let gossip_sync = P2PGossipSync::new(Arc::clone(&network_graph), None, Arc::clone(&logger));
+		let scorer = ProbabilisticScorer::new(ProbabilisticScoringDecayParameters::default(), Arc::clone(&network_graph), Arc::clone(&logger));
 		let random_seed_bytes = [42; 32];
 		let config = UserConfig::default();
 
@@ -8478,7 +8478,7 @@ mod tests {
 		let secp_ctx = Secp256k1::new();
 		let logger = Arc::new(ln_test_utils::TestLogger::new());
 		let network_graph = Arc::new(NetworkGraph::new(Network::Testnet, Arc::clone(&logger)));
-		let scorer = ProbabilisticScorer::new(ProbabilisticScoringDecayParameters::default(), network_graph.clone(), logger.clone());
+		let scorer = ProbabilisticScorer::new(ProbabilisticScoringDecayParameters::default(), Arc::clone(&network_graph), Arc::clone(&logger));
 		let random_seed_bytes = [42; 32];
 		let config = UserConfig::default();
 

lightning/src/util/persist.rs

@@ -1462,6 +1462,6 @@ mod tests {
 	#[test]
 	fn kvstore_trait_object_usage() {
 		let store: Arc<dyn KVStore + Send + Sync> = Arc::new(TestStore::new(false));
-		assert!(persist_fn::<_, TestChannelSigner>(store.clone()));
+		assert!(persist_fn::<_, TestChannelSigner>(Arc::clone(&store)));
 	}
 }

lightning/src/util/sweep.rs

@@ -992,7 +992,7 @@ where
 	pub fn sweeper_async(
 		&self,
 	) -> Arc<OutputSweeper<B, Arc<ChangeDestinationSourceSyncWrapper<D>>, E, F, K, L, O>> {
-		self.sweeper.clone()
+		Arc::clone(&self.sweeper)
 	}
 }
 

lightning/src/util/test_utils.rs

@@ -157,7 +157,7 @@ impl<'a> TestRouter<'a> {
 		let next_blinded_payment_paths = Mutex::new(Vec::new());
 		Self {
 			router: DefaultRouter::new(
-				network_graph.clone(),
+				Arc::clone(&network_graph),
 				logger,
 				entropy_source,
 				scorer,

lightning/src/util/wakers.rs

@@ -449,7 +449,7 @@ mod tests {
 		let thread_notifier = Arc::clone(&persistence_notifier);
 
 		let exit_thread = Arc::new(AtomicBool::new(false));
-		let exit_thread_clone = exit_thread.clone();
+		let exit_thread_clone = Arc::clone(&exit_thread);
 		thread::spawn(move || loop {
 			thread_notifier.notify();
 			if exit_thread_clone.load(Ordering::SeqCst) {