vey-io-ext: add more testcases

Author: zh-jq

lib/vey-icap-client/src/options/response.rs

@@ -305,10 +305,7 @@ mod tests {
             .parse_header_line(b"Max-Connections: 100\r\n")
             .unwrap();
         assert_eq!(options.server.as_deref(), Some("Example ICAP Server 1.0"));
-        assert_eq!(
-            options.service_tag,
-            "\"W3E4R7U9-L3E4R7U9-W3E4R7U9\""
-        );
+        assert_eq!(options.service_tag, "\"W3E4R7U9-L3E4R7U9-W3E4R7U9\"");
         assert_eq!(options.service_id.as_deref(), Some("respmod-scan"));
         assert_eq!(options.max_connections, Some(100));
         options.check().unwrap();

lib/vey-icap-client/src/service/config/mod.rs

@@ -156,10 +156,7 @@ impl IcapServiceConfig {
             "icaps" => 11344,
             _ => 1344,
         };
-        let include_port = self
-            .url
-            .port()
-            .is_some_and(|port| port != default_port);
+        let include_port = self.url.port().is_some_and(|port| port != default_port);
 
         match host {
             url::Host::Domain(domain) => {

lib/vey-io-ext/src/limit/token_bucket/stream.rs

@@ -139,9 +139,6 @@ mod tests {
         let limiter = GlobalStreamLimiter::new(GlobalLimitGroup::User, config);
         assert!(matches!(limiter.group(), GlobalLimitGroup::User));
         assert_eq!(limiter.check(10), StreamLimitAction::AdvanceBy(10));
-        assert!(matches!(
-            limiter.check(1),
-            StreamLimitAction::DelayUntil(_)
-        ));
+        assert!(matches!(limiter.check(1), StreamLimitAction::DelayUntil(_)));
     }
 }

lib/vey-io-ext/src/stream/ext/limited_write_ext.rs

@@ -46,7 +46,11 @@ mod tests {
     #[tokio::test]
     async fn write_all_vectored_writes_all_slices() {
         let mut writer = Vec::new();
-        let bufs = [IoSlice::new(b"ab"), IoSlice::new(b"cd"), IoSlice::new(b"ef")];
+        let bufs = [
+            IoSlice::new(b"ab"),
+            IoSlice::new(b"cd"),
+            IoSlice::new(b"ef"),
+        ];
         writer.write_all_vectored(bufs).await.unwrap();
         // Vec's AsyncWrite may not implement vectored specially; still should complete.
         writer.flush().await.unwrap();

lib/vey-io-ext/src/udp/mod.rs

@@ -141,4 +141,61 @@ mod tests {
         cfg.set_batch_count(4);
         assert_eq!(cfg.underlying_buffer_size(), 1024 * 4);
     }
+
+    #[test]
+    fn underlying_buffer_size_caps_the_batch_used_as_floor() {
+        let mut cfg = LimitedUdpRelayConfig::default();
+        cfg.set_underlying_buffer_size(0);
+        cfg.set_packet_size(1024);
+        cfg.set_batch_count(1024);
+        assert_eq!(
+            cfg.underlying_buffer_size(),
+            1024 * DEFAULT_UDP_RELAY_BATCH_COUNT
+        );
+    }
+
+    #[test]
+    fn underlying_buffer_size_keeps_the_larger_explicit_value() {
+        let mut cfg = LimitedUdpRelayConfig::default();
+        cfg.set_packet_size(MINIMUM_UDP_PACKET_SIZE);
+        cfg.set_batch_count(1);
+        cfg.set_underlying_buffer_size(1 << 20);
+        assert_eq!(cfg.underlying_buffer_size(), 1 << 20);
+    }
+
+    #[test]
+    fn underlying_buffer_size_with_zero_batch_falls_back_to_explicit_value() {
+        let mut cfg = LimitedUdpRelayConfig::default();
+        cfg.set_batch_count(0);
+        cfg.set_underlying_buffer_size(64);
+        assert_eq!(cfg.underlying_buffer_size(), 64);
+    }
+
+    #[test]
+    fn set_packet_size_accepts_the_exact_bounds() {
+        let mut cfg = LimitedUdpRelayConfig::default();
+        cfg.set_packet_size(MINIMUM_UDP_PACKET_SIZE);
+        assert_eq!(cfg.packet_size(), MINIMUM_UDP_PACKET_SIZE);
+        cfg.set_packet_size(MAXIMUM_UDP_PACKET_SIZE);
+        assert_eq!(cfg.packet_size(), MAXIMUM_UDP_PACKET_SIZE);
+    }
+
+    #[test]
+    fn set_yield_count_accepts_the_exact_minimum() {
+        let mut cfg = LimitedUdpRelayConfig::default();
+        cfg.set_yield_count(MINIMUM_UDP_RELAY_YIELD_COUNT);
+        assert_eq!(cfg.yield_count, MINIMUM_UDP_RELAY_YIELD_COUNT);
+        cfg.set_yield_count(0);
+        assert_eq!(cfg.yield_count, MINIMUM_UDP_RELAY_YIELD_COUNT);
+    }
+
+    #[test]
+    fn config_copy_keeps_the_source_unchanged() {
+        let mut cfg = LimitedUdpRelayConfig::default();
+        cfg.set_packet_size(1200);
+        let copied = cfg;
+        cfg.set_packet_size(1300);
+        assert_eq!(copied.packet_size(), 1200);
+        assert_ne!(copied, cfg);
+    }
 }