style: apply clippy lint

Itsusinn · Itsusinn · commit 652c8cbd5a3d · 2025-11-11T15:14:59.000+08:00
diff --git a/tuic-client/src/config.rs b/tuic-client/src/config.rs
@@ -423,7 +423,7 @@ mod tests {
 
 		let config_path = temp_dir.path().join(format!("config{}", extension));
 
-		fs::write(&config_path, &config_content).unwrap();
+		fs::write(&config_path, config_content).unwrap();
 
 		// Temporarily set command line arguments for clap to parse
 		let os_args = vec![
@@ -519,7 +519,7 @@ mod tests {
 
 		let config = config.unwrap();
 		assert_eq!(config.log_level, "debug");
-		assert_eq!(config.relay.zero_rtt_handshake, true);
+		assert!(config.relay.zero_rtt_handshake);
 	}
 
 	#[test]
@@ -533,23 +533,22 @@ mod tests {
 		assert_eq!(config.relay.ipstack_prefer, StackPrefer::V4first);
 		assert_eq!(config.relay.udp_relay_mode, UdpRelayMode::Native);
 		assert_eq!(config.relay.congestion_control, CongestionControl::Bbr);
-		assert_eq!(config.relay.zero_rtt_handshake, false);
-		assert_eq!(config.relay.disable_sni, false);
+		assert!(!config.relay.zero_rtt_handshake);
+		assert!(!config.relay.disable_sni);
 		assert_eq!(config.relay.timeout, Duration::from_secs(8));
 		assert_eq!(config.relay.heartbeat, Duration::from_secs(3));
-		assert_eq!(config.relay.disable_native_certs, false);
+		assert!(!config.relay.disable_native_certs);
 		assert_eq!(config.relay.send_window, 16 * 1024 * 1024);
 		assert_eq!(config.relay.receive_window, 8 * 1024 * 1024);
 		assert_eq!(config.relay.initial_mtu, 1200);
 		assert_eq!(config.relay.min_mtu, 1200);
-		assert_eq!(config.relay.gso, true);
-		assert_eq!(config.relay.pmtu, true);
+		assert!(config.relay.gso);
+		assert!(config.relay.pmtu);
 		assert_eq!(config.relay.gc_interval, Duration::from_secs(3));
 		assert_eq!(config.relay.gc_lifetime, Duration::from_secs(15));
-		assert_eq!(config.relay.skip_cert_verify, false);
+		assert!(!config.relay.skip_cert_verify);
 		assert_eq!(config.local.max_packet_size, 1500);
 	}
-
 	#[test]
 	fn test_tcp_udp_forward() {
 		let json5_config = include_str!("../tests/config/tcp_udp_forward.json5");
diff --git a/tuic-core/src/tests.rs b/tuic-core/src/tests.rs
@@ -159,7 +159,7 @@ fn test_heartbeat_creation() {
 
 #[test]
 fn test_heartbeat_default() {
-	let _hb = Heartbeat::default();
+	let _hb = Heartbeat;
 	assert_eq!(Heartbeat::type_code(), 0x04);
 }
 
diff --git a/tuic-server/src/acl.rs b/tuic-server/src/acl.rs
@@ -59,7 +59,7 @@ pub enum AclAddress {
 
 /// Represents port specifications with optional protocols
 #[derive(Debug, Clone, PartialEq, Serialize, Display)]
-#[display("{}", format_port_list(&entries))]
+#[display("{}", format_port_list(entries))]
 pub struct AclPorts {
 	/// List of port ranges or single ports with optional protocols
 	pub entries: Vec<AclPortEntry>,
@@ -120,10 +120,8 @@ impl AclRule {
 	/// Check if the rule matches the given IP address
 	fn matches_address(&self, ip: IpAddr) -> bool {
 		match &self.addr {
-			AclAddress::Ip(ip_str) => ip_str.parse::<IpAddr>().map_or(false, |parsed| parsed == ip),
-			AclAddress::Cidr(cidr_str) => cidr_str
-				.parse::<ip_network::IpNetwork>()
-				.map_or(false, |net| net.contains(ip)),
+			AclAddress::Ip(ip_str) => ip_str.parse::<IpAddr>() == Ok(ip),
+			AclAddress::Cidr(cidr_str) => cidr_str.parse::<ip_network::IpNetwork>().is_ok_and(|net| net.contains(ip)),
 			AclAddress::Domain(domain) => Self::match_domain(domain, ip),
 			AclAddress::WildcardDomain(pattern) => Self::match_wildcard_domain(pattern, ip),
 			AclAddress::Localhost => Self::is_loopback(ip),
@@ -148,7 +146,7 @@ impl AclRule {
 		(domain, 0)
 			.to_socket_addrs()
 			.ok()
-			.map_or(false, |mut iter| iter.any(|sa| sa.ip() == ip))
+			.is_some_and(|mut iter| iter.any(|sa| sa.ip() == ip))
 	}
 
 	/// Match a wildcard domain against an IP address
@@ -164,7 +162,7 @@ impl AclRule {
 			(stripped, 0)
 				.to_socket_addrs()
 				.ok()
-				.map_or(false, |mut iter| iter.any(|sa| sa.ip() == ip))
+				.is_some_and(|mut iter| iter.any(|sa| sa.ip() == ip))
 		}
 	}
 
diff --git a/tuic-server/src/config.rs b/tuic-server/src/config.rs
@@ -703,7 +703,7 @@ mod tests {
 		let temp_dir = tempdir().unwrap();
 		let config_path = temp_dir.path().join(format!("config{}", extension));
 
-		fs::write(&config_path, &config_content).unwrap();
+		fs::write(&config_path, config_content).unwrap();
 
 		// Temporarily set command line arguments for clap to parse
 		let os_args = vec![
@@ -716,11 +716,8 @@ mod tests {
 		let cli = Cli::try_parse_from(os_args)?;
 
 		// Call parse_config with the CLI and env_state
-		let result = parse_config(cli, env_state).await;
-
-		result
+		parse_config(cli, env_state).await
 	}
-
 	#[tokio::test]
 	async fn test_valid_toml_config() -> eyre::Result<()> {
 		let config = include_str!("../tests/config/valid_toml_config.toml");
@@ -729,13 +726,12 @@ mod tests {
 
 		assert_eq!(result.log_level, LogLevel::Warn);
 		assert_eq!(result.server, "127.0.0.1:8080".parse().unwrap());
-		assert_eq!(result.udp_relay_ipv6, false);
-		assert_eq!(result.zero_rtt_handshake, true);
+		assert!(!result.udp_relay_ipv6);
+		assert!(result.zero_rtt_handshake);
 
-		assert_eq!(result.tls.self_sign, true);
-		assert_eq!(result.tls.auto_ssl, true);
+		assert!(result.tls.self_sign);
+		assert!(result.tls.auto_ssl);
 		assert_eq!(result.tls.hostname, "testhost");
-
 		assert_eq!(result.quic.initial_mtu, 1400);
 		assert_eq!(result.quic.min_mtu, 1300);
 		assert_eq!(result.quic.send_window, 10000000);
@@ -772,10 +768,9 @@ mod tests {
 		let uuid = Uuid::parse_str("123e4567-e89b-12d3-a456-426614174002").unwrap();
 		assert_eq!(result.users.get(&uuid), Some(&"old_password".to_string()));
 
-		assert_eq!(result.tls.self_sign, false);
-		assert!(result.data_dir.ends_with("__test__legacy_data"));
 
-		// Cleanup test directories
+		assert!(!result.tls.self_sign);
+		assert!(result.data_dir.ends_with("__test__legacy_data")); // Cleanup test directories
 		let _ = tokio::fs::remove_dir_all("__test__legacy_data").await;
 	}
 
@@ -1009,17 +1004,16 @@ mod tests {
 		// Check default values
 		assert_eq!(result.log_level, LogLevel::Info);
 		assert_eq!(result.server, "[::]:8443".parse().unwrap());
-		assert_eq!(result.udp_relay_ipv6, true);
-		assert_eq!(result.zero_rtt_handshake, false);
-		assert_eq!(result.dual_stack, true);
+		assert!(result.udp_relay_ipv6);
+		assert!(!result.zero_rtt_handshake);
+		assert!(result.dual_stack);
 		assert_eq!(result.auth_timeout, Duration::from_secs(3));
 		assert_eq!(result.task_negotiation_timeout, Duration::from_secs(3));
 		assert_eq!(result.gc_interval, Duration::from_secs(10));
 		assert_eq!(result.gc_lifetime, Duration::from_secs(30));
 		assert_eq!(result.max_external_packet_size, 1500);
 		assert_eq!(result.stream_timeout, Duration::from_secs(60));
 	}
-
 	#[tokio::test]
 	async fn test_invalid_uuid() {
 		let config = include_str!("../tests/config/invalid_uuid.toml");
@@ -1097,14 +1091,13 @@ mod tests {
 		let result = test_parse_config(config, ".json").await.unwrap();
 
 		// Verify migration worked
-		assert_eq!(result.tls.self_sign, true);
+		assert!(result.tls.self_sign);
 		assert!(result.tls.certificate.ends_with("cert.pem"));
 		assert!(result.tls.private_key.ends_with("key.pem"));
 		assert_eq!(result.tls.hostname, "example.com");
 		assert_eq!(result.quic.congestion_control.controller, CongestionController::Bbr);
 		assert_eq!(result.quic.max_idle_time, Duration::from_secs(60));
 		assert_eq!(result.quic.initial_mtu, 1500);
-
 		assert!(result.restful.is_some());
 		assert_eq!(result.restful.unwrap().addr, "0.0.0.0:8080".parse().unwrap());
 	}
@@ -1188,15 +1181,14 @@ mod tests {
 
 		assert_eq!(result.log_level, LogLevel::Info);
 		assert_eq!(result.server, "127.0.0.1:9443".parse().unwrap());
-		assert_eq!(result.udp_relay_ipv6, false);
-		assert_eq!(result.zero_rtt_handshake, true);
+		assert!(!result.udp_relay_ipv6);
+		assert!(result.zero_rtt_handshake);
 
 		assert_eq!(result.users.len(), 2);
 
-		assert_eq!(result.tls.self_sign, true);
-		assert_eq!(result.tls.auto_ssl, true);
+		assert!(result.tls.self_sign);
+		assert!(result.tls.auto_ssl);
 		assert_eq!(result.tls.hostname, "json5.example.com");
-
 		assert_eq!(result.quic.initial_mtu, 1400);
 		assert_eq!(result.quic.min_mtu, 1300);
 		assert_eq!(result.quic.send_window, 8000000);
@@ -1239,9 +1231,8 @@ mod tests {
 		let result = test_parse_config(config, ".json5").await.unwrap();
 		assert_eq!(result.log_level, LogLevel::Error);
 		assert_eq!(result.server, "192.168.1.1:8443".parse().unwrap());
-		assert_eq!(result.tls.self_sign, false);
+		assert!(!result.tls.self_sign);
 	}
-
 	#[tokio::test]
 	async fn test_dir_parameter_finds_config() {
 		// Test that --dir finds the first config file in a directory
diff --git a/tuic-server/src/utils.rs b/tuic-server/src/utils.rs
@@ -50,16 +50,14 @@ mod tests {
 	#[test]
 	fn test_stack_prefer_variants() {
 		// Test all variants exist and are distinct
-		let modes = vec![
+		let modes = [
 			StackPrefer::V4only,
 			StackPrefer::V6only,
 			StackPrefer::V4first,
 			StackPrefer::V6first,
 		];
 
-		assert_eq!(modes.len(), 4);
-
-		// Test equality
+		assert_eq!(modes.len(), 4); // Test equality
 		assert_eq!(StackPrefer::V4only, StackPrefer::V4only);
 		assert_ne!(StackPrefer::V4only, StackPrefer::V6only);
 	}
diff --git a/tuic-tests/tests/integration_tests.rs b/tuic-tests/tests/integration_tests.rs
@@ -532,14 +532,12 @@ async fn test_server_client_integration() {
 							eprintln!("[TCP Test] Failed to read response: {}", e);
 							// Try regular read to see what we can get
 							let mut fallback_buffer = vec![0u8; 1024];
-							if let Ok(n) = timeout(Duration::from_secs(1), stream.read(&mut fallback_buffer)).await {
-								if let Ok(bytes) = n {
-									eprintln!(
-										"[TCP Test] Fallback read got {} bytes: {:?}",
-										bytes,
-										&fallback_buffer[..bytes]
-									);
-								}
+							if let Ok(Ok(bytes)) = timeout(Duration::from_secs(1), stream.read(&mut fallback_buffer)).await {
+								eprintln!(
+									"[TCP Test] Fallback read got {} bytes: {:?}",
+									bytes,
+									&fallback_buffer[..bytes]
+								);
 							}
 						}
 						Err(_) => {
@@ -596,31 +594,24 @@ async fn test_server_client_integration() {
 		let echo_task = tokio::spawn(async move {
 			let mut buf = vec![0u8; 1024];
 			println!("[UDP Echo Server] Waiting for packets...");
-			loop {
-				match timeout(Duration::from_secs(5), echo_server_clone.recv_from(&mut buf)).await {
-					Ok(Ok((n, addr))) => {
-						println!("[UDP Echo Server] Received {} bytes from {}", n, addr);
-						println!("[UDP Echo Server] Data: {:?}", &buf[..n]);
-						if let Err(e) = echo_server_clone.send_to(&buf[..n], addr).await {
-							eprintln!("[UDP Echo Server] Failed to send response: {}", e);
-						} else {
-							println!("[UDP Echo Server] Echoed {} bytes back to {}", n, addr);
-						}
-						break;
-					}
-					Ok(Err(e)) => {
-						eprintln!("[UDP Echo Server] Error receiving: {}", e);
-						break;
-					}
-					Err(_) => {
-						eprintln!("[UDP Echo Server] Timeout waiting for data (no packets received)");
-						break;
+			match timeout(Duration::from_secs(5), echo_server_clone.recv_from(&mut buf)).await {
+				Ok(Ok((n, addr))) => {
+					println!("[UDP Echo Server] Received {} bytes from {}", n, addr);
+					println!("[UDP Echo Server] Data: {:?}", &buf[..n]);
+					if let Err(e) = echo_server_clone.send_to(&buf[..n], addr).await {
+						eprintln!("[UDP Echo Server] Failed to send response: {}", e);
+					} else {
+						println!("[UDP Echo Server] Echoed {} bytes back to {}", n, addr);
 					}
 				}
+				Ok(Err(e)) => {
+					eprintln!("[UDP Echo Server] Error receiving: {}", e);
+				}
+				Err(_) => {
+					eprintln!("[UDP Echo Server] Timeout waiting for data (no packets received)");
+				}
 			}
-		});
-
-		// Give server time to start
+		}); // Give server time to start
 		tokio::time::sleep(Duration::from_millis(100)).await;
 
 		// Connect to SOCKS5 proxy using fast-socks5's UDP API

Original file line number	Diff line number	Diff line change
`@@ -159,7 +159,7 @@ fn test_heartbeat_creation() {`
`159`	`159`
`160`	`160`	`#[test]`
`161`	`161`	`fn test_heartbeat_default() {`
`162`		`- let _hb = Heartbeat::default();`
	`162`	`+ let _hb = Heartbeat;`
`163`	`163`	`assert_eq!(Heartbeat::type_code(), 0x04);`
`164`	`164`	`}`
`165`	`165`