阿里sdk

EdgeHttpDNS/sdk/ios/AlicloudHttpDNSTests/Network/.gitignore

@@ -0,0 +1 @@
+server.pem

EdgeHttpDNS/sdk/ios/AlicloudHttpDNSTests/Network/HttpdnsNWHTTPClientTestBase.h

@@ -0,0 +1,24 @@
+//
+//  HttpdnsNWHTTPClientTestBase.h
+//  AlicloudHttpDNSTests
+//
+//  @author Created by Claude Code on 2025-11-01
+//  Copyright © 2025 alibaba-inc.com. All rights reserved.
+//
+//  测试基类 - 为所有 HttpdnsNWHTTPClient 测试提供共享的 setup/teardown
+//
+
+#import <XCTest/XCTest.h>
+#import "HttpdnsNWHTTPClient.h"
+#import "HttpdnsNWHTTPClient_Internal.h"
+#import "HttpdnsNWReusableConnection.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface HttpdnsNWHTTPClientTestBase : XCTestCase
+
+@property (nonatomic, strong) HttpdnsNWHTTPClient *client;
+
+@end
+
+NS_ASSUME_NONNULL_END

EdgeHttpDNS/sdk/ios/AlicloudHttpDNSTests/Network/HttpdnsNWHTTPClientTestBase.m

@@ -0,0 +1,42 @@
+//
+//  HttpdnsNWHTTPClientTestBase.m
+//  AlicloudHttpDNSTests
+//
+//  @author Created by Claude Code on 2025-11-01
+//  Copyright © 2025 alibaba-inc.com. All rights reserved.
+//
+//  测试基类实现 - 共享的环境配置与清理逻辑
+//
+//  注意：所有测试需要先启动本地 mock server
+//  启动命令：cd AlicloudHttpDNSTests/Network && python3 mock_server.py
+//  服务端口：
+//    - HTTP:  11080
+//    - HTTPS: 11443, 11444, 11445, 11446
+//
+
+#import "HttpdnsNWHTTPClientTestBase.h"
+
+@implementation HttpdnsNWHTTPClientTestBase
+
+- (void)setUp {
+    [super setUp];
+
+    // 设置环境变量以跳过 TLS 验证（用于本地 mock server 的自签名证书）
+    // 这是安全的，因为：
+    // 1. 仅在测试环境生效
+    // 2. 连接限制为本地 loopback (127.0.0.1)
+    // 3. 不影响生产代码
+    setenv("HTTPDNS_SKIP_TLS_VERIFY", "1", 1);
+
+    self.client = [[HttpdnsNWHTTPClient alloc] init];
+}
+
+- (void)tearDown {
+    // 清除环境变量，避免影响其他测试
+    unsetenv("HTTPDNS_SKIP_TLS_VERIFY");
+
+    self.client = nil;
+    [super tearDown];
+}
+
+@end

EdgeHttpDNS/sdk/ios/AlicloudHttpDNSTests/Network/HttpdnsNWHTTPClientTestHelper.h

@@ -0,0 +1,58 @@
+//
+//  HttpdnsNWHTTPClientTestHelper.h
+//  AlicloudHttpDNSTests
+//
+//  @author Created by Claude Code on 2025-11-01
+//  Copyright © 2025 alibaba-inc.com. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface HttpdnsNWHTTPClientTestHelper : NSObject
+
+#pragma mark - HTTP 响应数据构造
+
+// 构造标准 HTTP 响应数据
++ (NSData *)createHTTPResponseWithStatus:(NSInteger)statusCode
+                              statusText:(NSString *)statusText
+                                 headers:(nullable NSDictionary<NSString *, NSString *> *)headers
+                                    body:(nullable NSData *)body;
+
+// 构造 chunked 编码的 HTTP 响应
++ (NSData *)createChunkedHTTPResponseWithStatus:(NSInteger)statusCode
+                                        headers:(nullable NSDictionary<NSString *, NSString *> *)headers
+                                         chunks:(NSArray<NSData *> *)chunks;
+
+// 构造 chunked 编码的 HTTP 响应（带 trailers）
++ (NSData *)createChunkedHTTPResponseWithStatus:(NSInteger)statusCode
+                                        headers:(nullable NSDictionary<NSString *, NSString *> *)headers
+                                         chunks:(NSArray<NSData *> *)chunks
+                                       trailers:(nullable NSDictionary<NSString *, NSString *> *)trailers;
+
+#pragma mark - Chunked 编码工具
+
+// 编码单个 chunk
++ (NSData *)encodeChunk:(NSData *)data;
+
+// 编码单个 chunk（带 extension）
++ (NSData *)encodeChunk:(NSData *)data extension:(nullable NSString *)extension;
+
+// 编码终止 chunk（size=0）
++ (NSData *)encodeLastChunk;
+
+// 编码终止 chunk（带 trailers）
++ (NSData *)encodeLastChunkWithTrailers:(NSDictionary<NSString *, NSString *> *)trailers;
+
+#pragma mark - 测试数据生成
+
+// 生成指定大小的随机数据
++ (NSData *)randomDataWithSize:(NSUInteger)size;
+
+// 生成 JSON 格式的响应体
++ (NSData *)jsonBodyWithDictionary:(NSDictionary *)dictionary;
+
+@end
+
+NS_ASSUME_NONNULL_END

EdgeHttpDNS/sdk/ios/AlicloudHttpDNSTests/Network/HttpdnsNWHTTPClientTestHelper.m

@@ -0,0 +1,168 @@
+//
+//  HttpdnsNWHTTPClientTestHelper.m
+//  AlicloudHttpDNSTests
+//
+//  @author Created by Claude Code on 2025-11-01
+//  Copyright © 2025 alibaba-inc.com. All rights reserved.
+//
+
+#import "HttpdnsNWHTTPClientTestHelper.h"
+
+@implementation HttpdnsNWHTTPClientTestHelper
+
+#pragma mark - HTTP 响应数据构造
+
++ (NSData *)createHTTPResponseWithStatus:(NSInteger)statusCode
+                              statusText:(NSString *)statusText
+                                 headers:(nullable NSDictionary<NSString *, NSString *> *)headers
+                                    body:(nullable NSData *)body {
+    NSMutableString *response = [NSMutableString string];
+
+    // 状态行
+    [response appendFormat:@"HTTP/1.1 %ld %@\r\n", (long)statusCode, statusText ?: @"OK"];
+
+    // 头部
+    if (headers) {
+        for (NSString *key in headers) {
+            [response appendFormat:@"%@: %@\r\n", key, headers[key]];
+        }
+    }
+
+    // 如果有 body 但没有 Content-Length，自动添加
+    if (body && body.length > 0 && !headers[@"Content-Length"]) {
+        [response appendFormat:@"Content-Length: %lu\r\n", (unsigned long)body.length];
+    }
+
+    // 空行分隔头部和 body
+    [response appendString:@"\r\n"];
+
+    NSMutableData *responseData = [[response dataUsingEncoding:NSUTF8StringEncoding] mutableCopy];
+
+    // 添加 body
+    if (body) {
+        [responseData appendData:body];
+    }
+
+    return [responseData copy];
+}
+
++ (NSData *)createChunkedHTTPResponseWithStatus:(NSInteger)statusCode
+                                        headers:(nullable NSDictionary<NSString *, NSString *> *)headers
+                                         chunks:(NSArray<NSData *> *)chunks {
+    return [self createChunkedHTTPResponseWithStatus:statusCode
+                                             headers:headers
+                                              chunks:chunks
+                                            trailers:nil];
+}
+
++ (NSData *)createChunkedHTTPResponseWithStatus:(NSInteger)statusCode
+                                        headers:(nullable NSDictionary<NSString *, NSString *> *)headers
+                                         chunks:(NSArray<NSData *> *)chunks
+                                       trailers:(nullable NSDictionary<NSString *, NSString *> *)trailers {
+    NSMutableString *response = [NSMutableString string];
+
+    // 状态行
+    [response appendFormat:@"HTTP/1.1 %ld OK\r\n", (long)statusCode];
+
+    // 头部
+    if (headers) {
+        for (NSString *key in headers) {
+            [response appendFormat:@"%@: %@\r\n", key, headers[key]];
+        }
+    }
+
+    // Transfer-Encoding 头部
+    [response appendString:@"Transfer-Encoding: chunked\r\n"];
+
+    // 空行
+    [response appendString:@"\r\n"];
+
+    NSMutableData *responseData = [[response dataUsingEncoding:NSUTF8StringEncoding] mutableCopy];
+
+    // 添加每个 chunk
+    for (NSData *chunk in chunks) {
+        [responseData appendData:[self encodeChunk:chunk]];
+    }
+
+    // 添加终止 chunk
+    if (trailers) {
+        [responseData appendData:[self encodeLastChunkWithTrailers:trailers]];
+    } else {
+        [responseData appendData:[self encodeLastChunk]];
+    }
+
+    return [responseData copy];
+}
+
+#pragma mark - Chunked 编码工具
+
++ (NSData *)encodeChunk:(NSData *)data {
+    return [self encodeChunk:data extension:nil];
+}
+
++ (NSData *)encodeChunk:(NSData *)data extension:(nullable NSString *)extension {
+    NSMutableString *chunkString = [NSMutableString string];
+
+    // Chunk size（十六进制）
+    if (extension) {
+        [chunkString appendFormat:@"%lx;%@\r\n", (unsigned long)data.length, extension];
+    } else {
+        [chunkString appendFormat:@"%lx\r\n", (unsigned long)data.length];
+    }
+
+    NSMutableData *chunkData = [[chunkString dataUsingEncoding:NSUTF8StringEncoding] mutableCopy];
+
+    // Chunk data
+    [chunkData appendData:data];
+
+    // CRLF
+    [chunkData appendData:[@"\r\n" dataUsingEncoding:NSUTF8StringEncoding]];
+
+    return [chunkData copy];
+}
+
++ (NSData *)encodeLastChunk {
+    return [@"0\r\n\r\n" dataUsingEncoding:NSUTF8StringEncoding];
+}
+
++ (NSData *)encodeLastChunkWithTrailers:(NSDictionary<NSString *, NSString *> *)trailers {
+    NSMutableString *lastChunkString = [NSMutableString stringWithString:@"0\r\n"];
+
+    // 添加 trailer 头部
+    for (NSString *key in trailers) {
+        [lastChunkString appendFormat:@"%@: %@\r\n", key, trailers[key]];
+    }
+
+    // 空行终止
+    [lastChunkString appendString:@"\r\n"];
+
+    return [lastChunkString dataUsingEncoding:NSUTF8StringEncoding];
+}
+
+#pragma mark - 测试数据生成
+
++ (NSData *)randomDataWithSize:(NSUInteger)size {
+    NSMutableData *data = [NSMutableData dataWithLength:size];
+    if (SecRandomCopyBytes(kSecRandomDefault, size, data.mutableBytes) != 0) {
+        // 如果 SecRandom 失败，使用简单的随机数
+        uint8_t *bytes = data.mutableBytes;
+        for (NSUInteger i = 0; i < size; i++) {
+            bytes[i] = arc4random_uniform(256);
+        }
+    }
+    return [data copy];
+}
+
++ (NSData *)jsonBodyWithDictionary:(NSDictionary *)dictionary {
+    NSError *error = nil;
+    NSData *jsonData = [NSJSONSerialization dataWithJSONObject:dictionary
+                                                       options:0
+                                                         error:&error];
+    if (error) {
+        NSLog(@"JSON serialization error: %@", error);
+        return nil;
+    }
+    return jsonData;
+}
+
+@end

EdgeHttpDNS/sdk/ios/AlicloudHttpDNSTests/Network/HttpdnsNWHTTPClientTests.m

@@ -0,0 +1,742 @@
+//
+//  HttpdnsNWHTTPClientTests.m
+//  AlicloudHttpDNSTests
+//
+//  @author Created by Claude Code on 2025-11-01
+//  Copyright © 2025 alibaba-inc.com. All rights reserved.
+//
+
+#import <XCTest/XCTest.h>
+#import <OCMock/OCMock.h>
+#import "HttpdnsNWHTTPClient.h"
+#import "HttpdnsNWHTTPClient_Internal.h"
+#import "HttpdnsNWReusableConnection.h"
+#import "HttpdnsNWHTTPClientTestHelper.h"
+
+@interface HttpdnsNWHTTPClientTests : XCTestCase
+
+@property (nonatomic, strong) HttpdnsNWHTTPClient *client;
+
+@end
+
+@implementation HttpdnsNWHTTPClientTests
+
+- (void)setUp {
+    [super setUp];
+    self.client = [[HttpdnsNWHTTPClient alloc] init];
+}
+
+- (void)tearDown {
+    self.client = nil;
+    [super tearDown];
+}
+
+#pragma mark - A. HTTP 解析逻辑测试
+
+#pragma mark - A1. Header 解析 (9个)
+
+// A1.1 正常响应
+- (void)testParseHTTPHeaders_ValidResponse_Success {
+    NSData *data = [HttpdnsNWHTTPClientTestHelper createHTTPResponseWithStatus:200
+                                                                     statusText:@"OK"
+                                                                        headers:@{@"Content-Type": @"application/json"}
+                                                                           body:nil];
+
+    NSUInteger headerEndIndex;
+    NSInteger statusCode;
+    NSDictionary *headers;
+    NSError *error;
+
+    HttpdnsHTTPHeaderParseResult result = [self.client tryParseHTTPHeadersInData:data
+                                                                  headerEndIndex:&headerEndIndex
+                                                                      statusCode:&statusCode
+                                                                         headers:&headers
+                                                                           error:&error];
+
+    XCTAssertEqual(result, HttpdnsHTTPHeaderParseResultSuccess);
+    XCTAssertEqual(statusCode, 200);
+    XCTAssertNotNil(headers);
+    XCTAssertEqualObjects(headers[@"content-type"], @"application/json"); // key 应该转为小写
+    XCTAssertNil(error);
+}
+
+// A1.2 多个头部
+- (void)testParseHTTPHeaders_MultipleHeaders_AllParsed {
+    NSDictionary *testHeaders = @{
+        @"Content-Type": @"application/json",
+        @"Content-Length": @"123",
+        @"Connection": @"keep-alive",
+        @"X-Custom-Header": @"custom-value",
+        @"Cache-Control": @"no-cache"
+    };
+
+    NSData *data = [HttpdnsNWHTTPClientTestHelper createHTTPResponseWithStatus:200
+                                                                     statusText:@"OK"
+                                                                        headers:testHeaders
+                                                                           body:nil];
+
+    NSUInteger headerEndIndex;
+    NSInteger statusCode;
+    NSDictionary *headers;
+    NSError *error;
+
+    HttpdnsHTTPHeaderParseResult result = [self.client tryParseHTTPHeadersInData:data
+                                                                  headerEndIndex:&headerEndIndex
+                                                                      statusCode:&statusCode
+                                                                         headers:&headers
+                                                                           error:&error];
+
+    XCTAssertEqual(result, HttpdnsHTTPHeaderParseResultSuccess);
+    XCTAssertEqual(headers.count, testHeaders.count);
+    // 验证所有头部都被解析，且 key 转为小写
+    XCTAssertEqualObjects(headers[@"content-type"], @"application/json");
+    XCTAssertEqualObjects(headers[@"content-length"], @"123");
+    XCTAssertEqualObjects(headers[@"connection"], @"keep-alive");
+    XCTAssertEqualObjects(headers[@"x-custom-header"], @"custom-value");
+    XCTAssertEqualObjects(headers[@"cache-control"], @"no-cache");
+}
+
+// A1.3 不完整响应
+- (void)testParseHTTPHeaders_IncompleteData_ReturnsIncomplete {
+    NSString *incompleteResponse = @"HTTP/1.1 200 OK\r\nContent-Type: application/json\r\n";
+    NSData *data = [incompleteResponse dataUsingEncoding:NSUTF8StringEncoding];
+
+    NSUInteger headerEndIndex;
+    NSInteger statusCode;
+    NSDictionary *headers;
+    NSError *error;
+
+    HttpdnsHTTPHeaderParseResult result = [self.client tryParseHTTPHeadersInData:data
+                                                                  headerEndIndex:&headerEndIndex
+                                                                      statusCode:&statusCode
+                                                                         headers:&headers
+                                                                           error:&error];
+
+    XCTAssertEqual(result, HttpdnsHTTPHeaderParseResultIncomplete);
+}
+
+// A1.4 无效状态行
+- (void)testParseHTTPHeaders_InvalidStatusLine_ReturnsError {
+    NSString *invalidResponse = @"INVALID\r\n\r\n";
+    NSData *data = [invalidResponse dataUsingEncoding:NSUTF8StringEncoding];
+
+    NSUInteger headerEndIndex;
+    NSInteger statusCode;
+    NSDictionary *headers;
+    NSError *error;
+
+    HttpdnsHTTPHeaderParseResult result = [self.client tryParseHTTPHeadersInData:data
+                                                                  headerEndIndex:&headerEndIndex
+                                                                      statusCode:&statusCode
+                                                                         headers:&headers
+                                                                           error:&error];
+
+    XCTAssertEqual(result, HttpdnsHTTPHeaderParseResultError);
+    XCTAssertNotNil(error);
+}
+
+// A1.5 头部包含空格
+- (void)testParseHTTPHeaders_HeadersWithWhitespace_Trimmed {
+    NSString *responseWithSpaces = @"HTTP/1.1 200 OK\r\nContent-Type:  application/json  \r\n\r\n";
+    NSData *data = [responseWithSpaces dataUsingEncoding:NSUTF8StringEncoding];
+
+    NSUInteger headerEndIndex;
+    NSInteger statusCode;
+    NSDictionary *headers;
+    NSError *error;
+
+    HttpdnsHTTPHeaderParseResult result = [self.client tryParseHTTPHeadersInData:data
+                                                                  headerEndIndex:&headerEndIndex
+                                                                      statusCode:&statusCode
+                                                                         headers:&headers
+                                                                           error:&error];
+
+    XCTAssertEqual(result, HttpdnsHTTPHeaderParseResultSuccess);
+    XCTAssertEqualObjects(headers[@"content-type"], @"application/json"); // 应该被 trim
+}
+
+// A1.6 头部没有值
+- (void)testParseHTTPHeaders_EmptyHeaderValue_HandledGracefully {
+    NSString *responseWithEmptyValue = @"HTTP/1.1 200 OK\r\nX-Empty-Header:\r\n\r\n";
+    NSData *data = [responseWithEmptyValue dataUsingEncoding:NSUTF8StringEncoding];
+
+    NSUInteger headerEndIndex;
+    NSInteger statusCode;
+    NSDictionary *headers;
+    NSError *error;
+
+    HttpdnsHTTPHeaderParseResult result = [self.client tryParseHTTPHeadersInData:data
+                                                                  headerEndIndex:&headerEndIndex
+                                                                      statusCode:&statusCode
+                                                                         headers:&headers
+                                                                           error:&error];
+
+    XCTAssertEqual(result, HttpdnsHTTPHeaderParseResultSuccess);
+    XCTAssertEqualObjects(headers[@"x-empty-header"], @"");
+}
+
+// A1.7 状态码非数字
+- (void)testParseHTTPHeaders_NonNumericStatusCode_ReturnsError {
+    NSString *invalidStatusCode = @"HTTP/1.1 ABC OK\r\n\r\n";
+    NSData *data = [invalidStatusCode dataUsingEncoding:NSUTF8StringEncoding];
+
+    NSUInteger headerEndIndex;
+    NSInteger statusCode;
+    NSDictionary *headers;
+    NSError *error;
+
+    HttpdnsHTTPHeaderParseResult result = [self.client tryParseHTTPHeadersInData:data
+                                                                  headerEndIndex:&headerEndIndex
+                                                                      statusCode:&statusCode
+                                                                         headers:&headers
+                                                                           error:&error];
+
+    XCTAssertEqual(result, HttpdnsHTTPHeaderParseResultError);
+}
+
+// A1.8 状态码为零
+- (void)testParseHTTPHeaders_StatusCodeZero_ReturnsError {
+    NSString *zeroStatusCode = @"HTTP/1.1 0 OK\r\n\r\n";
+    NSData *data = [zeroStatusCode dataUsingEncoding:NSUTF8StringEncoding];
+
+    NSUInteger headerEndIndex;
+    NSInteger statusCode;
+    NSDictionary *headers;
+    NSError *error;
+
+    HttpdnsHTTPHeaderParseResult result = [self.client tryParseHTTPHeadersInData:data
+                                                                  headerEndIndex:&headerEndIndex
+                                                                      statusCode:&statusCode
+                                                                         headers:&headers
+                                                                           error:&error];
+
+    XCTAssertEqual(result, HttpdnsHTTPHeaderParseResultError);
+}
+
+// A1.9 头部没有冒号被跳过
+- (void)testParseHTTPHeaders_HeaderWithoutColon_Skipped {
+    NSString *responseWithInvalidHeader = @"HTTP/1.1 200 OK\r\nInvalidHeader\r\nContent-Type: application/json\r\n\r\n";
+    NSData *data = [responseWithInvalidHeader dataUsingEncoding:NSUTF8StringEncoding];
+
+    NSUInteger headerEndIndex;
+    NSInteger statusCode;
+    NSDictionary *headers;
+    NSError *error;
+
+    HttpdnsHTTPHeaderParseResult result = [self.client tryParseHTTPHeadersInData:data
+                                                                  headerEndIndex:&headerEndIndex
+                                                                      statusCode:&statusCode
+                                                                         headers:&headers
+                                                                           error:&error];
+
+    XCTAssertEqual(result, HttpdnsHTTPHeaderParseResultSuccess);
+    XCTAssertEqualObjects(headers[@"content-type"], @"application/json"); // 有效头部正常解析
+}
+
+#pragma mark - A2. Chunked 编码检查 (8个)
+
+// A2.1 单个 chunk
+- (void)testCheckChunkedBody_SingleChunk_DetectsComplete {
+    NSString *singleChunkBody = @"5\r\nhello\r\n0\r\n\r\n";
+    NSString *response = [NSString stringWithFormat:@"HTTP/1.1 200 OK\r\n\r\n%@", singleChunkBody];
+    NSData *data = [response dataUsingEncoding:NSUTF8StringEncoding];
+
+    NSUInteger headerEndIndex = [@"HTTP/1.1 200 OK" length];
+    NSError *error;
+
+    HttpdnsHTTPChunkParseResult result = [self.client checkChunkedBodyCompletionInData:data
+                                                                         headerEndIndex:headerEndIndex
+                                                                                 error:&error];
+
+    XCTAssertEqual(result, HttpdnsHTTPChunkParseResultSuccess);
+    XCTAssertNil(error);
+}
+
+// A2.2 多个 chunks
+- (void)testCheckChunkedBody_MultipleChunks_DetectsComplete {
+    NSString *multiChunkBody = @"5\r\nhello\r\n6\r\n world\r\n0\r\n\r\n";
+    NSString *response = [NSString stringWithFormat:@"HTTP/1.1 200 OK\r\n\r\n%@", multiChunkBody];
+    NSData *data = [response dataUsingEncoding:NSUTF8StringEncoding];
+
+    NSUInteger headerEndIndex = [@"HTTP/1.1 200 OK" length];
+    NSError *error;
+
+    HttpdnsHTTPChunkParseResult result = [self.client checkChunkedBodyCompletionInData:data
+                                                                         headerEndIndex:headerEndIndex
+                                                                                 error:&error];
+
+    XCTAssertEqual(result, HttpdnsHTTPChunkParseResultSuccess);
+    XCTAssertNil(error);
+}
+
+// A2.3 不完整 chunk
+- (void)testCheckChunkedBody_IncompleteChunk_ReturnsIncomplete {
+    NSString *incompleteChunkBody = @"5\r\nhel"; // 数据不完整
+    NSString *response = [NSString stringWithFormat:@"HTTP/1.1 200 OK\r\n\r\n%@", incompleteChunkBody];
+    NSData *data = [response dataUsingEncoding:NSUTF8StringEncoding];
+
+    NSUInteger headerEndIndex = [@"HTTP/1.1 200 OK" length];
+    NSError *error;
+
+    HttpdnsHTTPChunkParseResult result = [self.client checkChunkedBodyCompletionInData:data
+                                                                         headerEndIndex:headerEndIndex
+                                                                                 error:&error];
+
+    XCTAssertEqual(result, HttpdnsHTTPChunkParseResultIncomplete);
+}
+
+// A2.4 带 chunk extension
+- (void)testCheckChunkedBody_WithChunkExtension_Ignored {
+    NSString *chunkWithExtension = @"5;name=value\r\nhello\r\n0\r\n\r\n";
+    NSString *response = [NSString stringWithFormat:@"HTTP/1.1 200 OK\r\n\r\n%@", chunkWithExtension];
+    NSData *data = [response dataUsingEncoding:NSUTF8StringEncoding];
+
+    // headerEndIndex 指向第一个 \r\n\r\n 中的第一个 \r
+    NSUInteger headerEndIndex = [@"HTTP/1.1 200 OK" length];
+    NSError *error;
+
+    HttpdnsHTTPChunkParseResult result = [self.client checkChunkedBodyCompletionInData:data
+                                                                         headerEndIndex:headerEndIndex
+                                                                                 error:&error];
+
+    XCTAssertEqual(result, HttpdnsHTTPChunkParseResultSuccess);
+    XCTAssertNil(error);
+}
+
+// A2.5 无效十六进制 size
+- (void)testCheckChunkedBody_InvalidHexSize_ReturnsError {
+    NSString *invalidChunkSize = @"ZZZ\r\nhello\r\n0\r\n\r\n";
+    NSString *response = [NSString stringWithFormat:@"HTTP/1.1 200 OK\r\n\r\n%@", invalidChunkSize];
+    NSData *data = [response dataUsingEncoding:NSUTF8StringEncoding];
+
+    NSUInteger headerEndIndex = [@"HTTP/1.1 200 OK" length];
+    NSError *error;
+
+    HttpdnsHTTPChunkParseResult result = [self.client checkChunkedBodyCompletionInData:data
+                                                                         headerEndIndex:headerEndIndex
+                                                                                 error:&error];
+
+    XCTAssertEqual(result, HttpdnsHTTPChunkParseResultError);
+    XCTAssertNotNil(error);
+}
+
+// A2.6 Chunk size 溢出
+- (void)testCheckChunkedBody_ChunkSizeOverflow_ReturnsError {
+    NSString *overflowChunkSize = @"FFFFFFFFFFFFFFFF\r\n";
+    NSString *response = [NSString stringWithFormat:@"HTTP/1.1 200 OK\r\n\r\n%@", overflowChunkSize];
+    NSData *data = [response dataUsingEncoding:NSUTF8StringEncoding];
+
+    NSUInteger headerEndIndex = [@"HTTP/1.1 200 OK" length];
+    NSError *error;
+
+    HttpdnsHTTPChunkParseResult result = [self.client checkChunkedBodyCompletionInData:data
+                                                                         headerEndIndex:headerEndIndex
+                                                                                 error:&error];
+
+    XCTAssertEqual(result, HttpdnsHTTPChunkParseResultError);
+    XCTAssertNotNil(error);
+}
+
+// A2.7 缺少 CRLF 终止符
+- (void)testCheckChunkedBody_MissingCRLFTerminator_ReturnsError {
+    NSString *missingTerminator = @"5\r\nhelloXX0\r\n\r\n"; // 应该是 hello\r\n
+    NSString *response = [NSString stringWithFormat:@"HTTP/1.1 200 OK\r\n\r\n%@", missingTerminator];
+    NSData *data = [response dataUsingEncoding:NSUTF8StringEncoding];
+
+    NSUInteger headerEndIndex = [@"HTTP/1.1 200 OK" length];
+    NSError *error;
+
+    HttpdnsHTTPChunkParseResult result = [self.client checkChunkedBodyCompletionInData:data
+                                                                         headerEndIndex:headerEndIndex
+                                                                                 error:&error];
+
+    XCTAssertEqual(result, HttpdnsHTTPChunkParseResultError);
+    XCTAssertNotNil(error);
+}
+
+// A2.8 带 trailers
+- (void)testCheckChunkedBody_WithTrailers_DetectsComplete {
+    NSString *chunkWithTrailers = @"5\r\nhello\r\n0\r\nX-Trailer: value\r\nX-Custom: test\r\n\r\n";
+    NSString *response = [NSString stringWithFormat:@"HTTP/1.1 200 OK\r\n\r\n%@", chunkWithTrailers];
+    NSData *data = [response dataUsingEncoding:NSUTF8StringEncoding];
+
+    NSUInteger headerEndIndex = [@"HTTP/1.1 200 OK" length];
+    NSError *error;
+
+    HttpdnsHTTPChunkParseResult result = [self.client checkChunkedBodyCompletionInData:data
+                                                                         headerEndIndex:headerEndIndex
+                                                                                 error:&error];
+
+    XCTAssertEqual(result, HttpdnsHTTPChunkParseResultSuccess);
+    XCTAssertNil(error);
+}
+
+#pragma mark - A3. Chunked 解码 (2个)
+
+// A3.1 多个 chunks 解码
+- (void)testDecodeChunkedBody_MultipleChunks_DecodesCorrectly {
+    NSArray *chunks = @[
+        [@"hello" dataUsingEncoding:NSUTF8StringEncoding],
+        [@" world" dataUsingEncoding:NSUTF8StringEncoding]
+    ];
+
+    NSData *chunkedData = [HttpdnsNWHTTPClientTestHelper createChunkedHTTPResponseWithStatus:200
+                                                                                      headers:nil
+                                                                                       chunks:chunks];
+
+    // 提取 chunked body 部分（跳过 headers）
+    NSData *headerData = [@"HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n" dataUsingEncoding:NSUTF8StringEncoding];
+    NSData *bodyData = [chunkedData subdataWithRange:NSMakeRange(headerData.length, chunkedData.length - headerData.length)];
+
+    NSError *error;
+    NSData *decoded = [self.client decodeChunkedBody:bodyData error:&error];
+
+    XCTAssertNotNil(decoded);
+    XCTAssertNil(error);
+    NSString *decodedString = [[NSString alloc] initWithData:decoded encoding:NSUTF8StringEncoding];
+    XCTAssertEqualObjects(decodedString, @"hello world");
+}
+
+// A3.2 无效格式返回 nil
+- (void)testDecodeChunkedBody_InvalidFormat_ReturnsNil {
+    NSString *invalidChunked = @"ZZZ\r\nbad data\r\n";
+    NSData *bodyData = [invalidChunked dataUsingEncoding:NSUTF8StringEncoding];
+
+    NSError *error;
+    NSData *decoded = [self.client decodeChunkedBody:bodyData error:&error];
+
+    XCTAssertNil(decoded);
+    XCTAssertNotNil(error);
+}
+
+#pragma mark - A4. 完整响应解析 (6个)
+
+// A4.1 Content-Length 响应
+- (void)testParseResponse_WithContentLength_ParsesCorrectly {
+    NSString *bodyString = @"{\"ips\":[]}";
+    NSData *bodyData = [bodyString dataUsingEncoding:NSUTF8StringEncoding];
+    NSData *responseData = [HttpdnsNWHTTPClientTestHelper createHTTPResponseWithStatus:200
+                                                                             statusText:@"OK"
+                                                                                headers:@{@"Content-Type": @"application/json"}
+                                                                                   body:bodyData];
+
+    NSInteger statusCode;
+    NSDictionary *headers;
+    NSData *body;
+    NSError *error;
+
+    BOOL success = [self.client parseHTTPResponseData:responseData
+                                            statusCode:&statusCode
+                                               headers:&headers
+                                                  body:&body
+                                                 error:&error];
+
+    XCTAssertTrue(success);
+    XCTAssertEqual(statusCode, 200);
+    XCTAssertNotNil(headers);
+    XCTAssertEqualObjects(headers[@"content-type"], @"application/json");
+    XCTAssertEqualObjects(body, bodyData);
+    XCTAssertNil(error);
+}
+
+// A4.2 Chunked 响应
+- (void)testParseResponse_WithChunkedEncoding_DecodesBody {
+    NSArray *chunks = @[
+        [@"{\"ips\"" dataUsingEncoding:NSUTF8StringEncoding],
+        [@":[]}" dataUsingEncoding:NSUTF8StringEncoding]
+    ];
+
+    NSData *responseData = [HttpdnsNWHTTPClientTestHelper createChunkedHTTPResponseWithStatus:200
+                                                                                       headers:@{@"Content-Type": @"application/json"}
+                                                                                        chunks:chunks];
+
+    NSInteger statusCode;
+    NSDictionary *headers;
+    NSData *body;
+    NSError *error;
+
+    BOOL success = [self.client parseHTTPResponseData:responseData
+                                            statusCode:&statusCode
+                                               headers:&headers
+                                                  body:&body
+                                                 error:&error];
+
+    XCTAssertTrue(success);
+    XCTAssertEqual(statusCode, 200);
+    NSString *bodyString = [[NSString alloc] initWithData:body encoding:NSUTF8StringEncoding];
+    XCTAssertEqualObjects(bodyString, @"{\"ips\":[]}");
+}
+
+// A4.3 空 body
+- (void)testParseResponse_EmptyBody_Success {
+    NSData *responseData = [HttpdnsNWHTTPClientTestHelper createHTTPResponseWithStatus:204
+                                                                             statusText:@"No Content"
+                                                                                headers:nil
+                                                                                   body:nil];
+
+    NSInteger statusCode;
+    NSDictionary *headers;
+    NSData *body;
+    NSError *error;
+
+    BOOL success = [self.client parseHTTPResponseData:responseData
+                                            statusCode:&statusCode
+                                               headers:&headers
+                                                  body:&body
+                                                 error:&error];
+
+    XCTAssertTrue(success);
+    XCTAssertEqual(statusCode, 204);
+    XCTAssertEqual(body.length, 0);
+}
+
+// A4.4 Content-Length 不匹配仍然成功
+- (void)testParseResponse_ContentLengthMismatch_LogsButSucceeds {
+    NSData *bodyData = [@"short" dataUsingEncoding:NSUTF8StringEncoding];
+    NSData *responseData = [HttpdnsNWHTTPClientTestHelper createHTTPResponseWithStatus:200
+                                                                             statusText:@"OK"
+                                                                                headers:@{@"Content-Length": @"100"} // 不匹配
+                                                                                   body:bodyData];
+
+    NSInteger statusCode;
+    NSDictionary *headers;
+    NSData *body;
+    NSError *error;
+
+    BOOL success = [self.client parseHTTPResponseData:responseData
+                                            statusCode:&statusCode
+                                               headers:&headers
+                                                  body:&body
+                                                 error:&error];
+
+    XCTAssertTrue(success); // 仍然成功，只是日志警告
+    XCTAssertEqualObjects(body, bodyData);
+}
+
+// A4.5 空数据返回错误
+- (void)testParseResponse_EmptyData_ReturnsError {
+    NSData *emptyData = [NSData data];
+
+    NSInteger statusCode;
+    NSDictionary *headers;
+    NSData *body;
+    NSError *error;
+
+    BOOL success = [self.client parseHTTPResponseData:emptyData
+                                            statusCode:&statusCode
+                                               headers:&headers
+                                                  body:&body
+                                                 error:&error];
+
+    XCTAssertFalse(success);
+    XCTAssertNotNil(error);
+}
+
+// A4.6 只有 headers 无 body
+- (void)testParseResponse_OnlyHeaders_EmptyBody {
+    NSData *responseData = [HttpdnsNWHTTPClientTestHelper createHTTPResponseWithStatus:200
+                                                                             statusText:@"OK"
+                                                                                headers:@{@"Content-Type": @"text/plain"}
+                                                                                   body:nil];
+
+    NSInteger statusCode;
+    NSDictionary *headers;
+    NSData *body;
+    NSError *error;
+
+    BOOL success = [self.client parseHTTPResponseData:responseData
+                                            statusCode:&statusCode
+                                               headers:&headers
+                                                  body:&body
+                                                 error:&error];
+
+    XCTAssertTrue(success);
+    XCTAssertEqual(statusCode, 200);
+    XCTAssertNotNil(headers);
+    XCTAssertEqual(body.length, 0);
+}
+
+#pragma mark - C. 请求构建测试 (7个)
+
+// C.1 基本 GET 请求
+- (void)testBuildHTTPRequest_BasicGET_CorrectFormat {
+    NSURL *url = [NSURL URLWithString:@"http://example.com/"];
+    NSString *request = [self.client buildHTTPRequestStringWithURL:url userAgent:@"TestAgent"];
+
+    XCTAssertTrue([request containsString:@"GET / HTTP/1.1\r\n"]);
+    XCTAssertTrue([request containsString:@"Host: example.com\r\n"]);
+    XCTAssertTrue([request containsString:@"User-Agent: TestAgent\r\n"]);
+    XCTAssertTrue([request containsString:@"Accept: application/json\r\n"]);
+    XCTAssertTrue([request containsString:@"Accept-Encoding: identity\r\n"]);
+    XCTAssertTrue([request containsString:@"Connection: keep-alive\r\n"]);
+    XCTAssertTrue([request hasSuffix:@"\r\n\r\n"]);
+}
+
+// C.2 带查询参数
+- (void)testBuildHTTPRequest_WithQueryString_Included {
+    NSURL *url = [NSURL URLWithString:@"http://example.com/path?foo=bar&baz=qux"];
+    NSString *request = [self.client buildHTTPRequestStringWithURL:url userAgent:nil];
+
+    XCTAssertTrue([request containsString:@"GET /path?foo=bar&baz=qux HTTP/1.1\r\n"]);
+}
+
+// C.3 包含 User-Agent
+- (void)testBuildHTTPRequest_WithUserAgent_Included {
+    NSURL *url = [NSURL URLWithString:@"http://example.com/"];
+    NSString *request = [self.client buildHTTPRequestStringWithURL:url userAgent:@"CustomAgent/1.0"];
+
+    XCTAssertTrue([request containsString:@"User-Agent: CustomAgent/1.0\r\n"]);
+}
+
+// C.4 HTTP 默认端口不显示
+- (void)testBuildHTTPRequest_HTTPDefaultPort_NotInHost {
+    NSURL *url = [NSURL URLWithString:@"http://example.com:80/"];
+    NSString *request = [self.client buildHTTPRequestStringWithURL:url userAgent:nil];
+
+    XCTAssertTrue([request containsString:@"Host: example.com\r\n"]);
+    XCTAssertFalse([request containsString:@"Host: example.com:80\r\n"]);
+}
+
+// C.5 HTTPS 默认端口不显示
+- (void)testBuildHTTPRequest_HTTPSDefaultPort_NotInHost {
+    NSURL *url = [NSURL URLWithString:@"https://example.com:443/"];
+    NSString *request = [self.client buildHTTPRequestStringWithURL:url userAgent:nil];
+
+    XCTAssertTrue([request containsString:@"Host: example.com\r\n"]);
+    XCTAssertFalse([request containsString:@"Host: example.com:443\r\n"]);
+}
+
+// C.6 非默认端口显示
+- (void)testBuildHTTPRequest_NonDefaultPort_InHost {
+    NSURL *url = [NSURL URLWithString:@"http://example.com:8080/"];
+    NSString *request = [self.client buildHTTPRequestStringWithURL:url userAgent:nil];
+
+    XCTAssertTrue([request containsString:@"Host: example.com:8080\r\n"]);
+}
+
+// C.7 固定头部存在
+- (void)testBuildHTTPRequest_FixedHeaders_Present {
+    NSURL *url = [NSURL URLWithString:@"http://example.com/"];
+    NSString *request = [self.client buildHTTPRequestStringWithURL:url userAgent:nil];
+
+    XCTAssertTrue([request containsString:@"Accept: application/json\r\n"]);
+    XCTAssertTrue([request containsString:@"Accept-Encoding: identity\r\n"]);
+    XCTAssertTrue([request containsString:@"Connection: keep-alive\r\n"]);
+}
+
+#pragma mark - E. TLS 验证测试 (4个占位符)
+
+// 注意：TLS 验证测试需要真实的 SecTrustRef 或复杂的 mock
+// 这些测试在实际环境中需要根据测试框架调整
+
+// E.1 有效证书返回 YES
+- (void)testEvaluateServerTrust_ValidCertificate_ReturnsYES {
+    // 需要创建有效的 SecTrustRef 进行测试
+    // 跳过或标记为手动测试
+}
+
+// E.2 Proceed 结果返回 YES
+- (void)testEvaluateServerTrust_ProceedResult_ReturnsYES {
+    // Mock SecTrustEvaluate 返回 kSecTrustResultProceed
+}
+
+// E.3 无效证书返回 NO
+- (void)testEvaluateServerTrust_InvalidCertificate_ReturnsNO {
+    // Mock SecTrustEvaluate 返回 kSecTrustResultDeny
+}
+
+// E.4 指定域名使用 SSL Policy
+- (void)testEvaluateServerTrust_WithDomain_UsesSSLPolicy {
+    // 验证使用了 SecPolicyCreateSSL(true, domain)
+}
+
+#pragma mark - F. 边缘情况测试 (5个)
+
+// F.1 超长 URL
+- (void)testPerformRequest_VeryLongURL_HandlesCorrectly {
+    NSMutableString *longPath = [NSMutableString stringWithString:@"http://example.com/"];
+    for (int i = 0; i < 1000; i++) {
+        [longPath appendString:@"long/"];
+    }
+
+    NSURL *url = [NSURL URLWithString:longPath];
+    XCTAssertNotNil(url);
+
+    NSString *request = [self.client buildHTTPRequestStringWithURL:url userAgent:nil];
+    XCTAssertTrue(request.length > 5000);
+}
+
+// F.2 空 User-Agent
+- (void)testBuildRequest_EmptyUserAgent_NoUserAgentHeader {
+    NSURL *url = [NSURL URLWithString:@"http://example.com/"];
+    NSString *requestWithNil = [self.client buildHTTPRequestStringWithURL:url userAgent:nil];
+
+    XCTAssertFalse([requestWithNil containsString:@"User-Agent:"]);
+}
+
+// F.3 超大响应体
+- (void)testParseResponse_VeryLargeBody_HandlesCorrectly {
+    NSData *largeBody = [HttpdnsNWHTTPClientTestHelper randomDataWithSize:5 * 1024 * 1024];
+    NSData *responseData = [HttpdnsNWHTTPClientTestHelper createHTTPResponseWithStatus:200
+                                                                             statusText:@"OK"
+                                                                                headers:nil
+                                                                                   body:largeBody];
+
+    NSInteger statusCode;
+    NSDictionary *headers;
+    NSData *body;
+    NSError *error;
+
+    BOOL success = [self.client parseHTTPResponseData:responseData
+                                            statusCode:&statusCode
+                                               headers:&headers
+                                                  body:&body
+                                                 error:&error];
+
+    XCTAssertTrue(success);
+    XCTAssertEqual(body.length, largeBody.length);
+}
+
+// F.4 Chunked 解码失败回退到原始数据
+- (void)testParseResponse_ChunkedDecodeFails_FallsBackToRaw {
+    NSString *badChunked = @"HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\nBAD_CHUNK_DATA";
+    NSData *responseData = [badChunked dataUsingEncoding:NSUTF8StringEncoding];
+
+    NSInteger statusCode;
+    NSDictionary *headers;
+    NSData *body;
+    NSError *error;
+
+    BOOL success = [self.client parseHTTPResponseData:responseData
+                                            statusCode:&statusCode
+                                               headers:&headers
+                                                  body:&body
+                                                 error:&error];
+
+    XCTAssertTrue(success);
+    XCTAssertNotNil(body);
+}
+
+// F.5 连接池 key 生成测试
+- (void)testConnectionPoolKey_DifferentHosts_SeparateKeys {
+    NSString *key1 = [self.client connectionPoolKeyForHost:@"host1.com" port:@"80" useTLS:NO];
+    NSString *key2 = [self.client connectionPoolKeyForHost:@"host2.com" port:@"80" useTLS:NO];
+
+    XCTAssertNotEqualObjects(key1, key2);
+}
+
+- (void)testConnectionPoolKey_DifferentPorts_SeparateKeys {
+    NSString *key1 = [self.client connectionPoolKeyForHost:@"example.com" port:@"80" useTLS:NO];
+    NSString *key2 = [self.client connectionPoolKeyForHost:@"example.com" port:@"8080" useTLS:NO];
+
+    XCTAssertNotEqualObjects(key1, key2);
+}
+
+- (void)testConnectionPoolKey_HTTPvsHTTPS_SeparateKeys {
+    NSString *keyHTTP = [self.client connectionPoolKeyForHost:@"example.com" port:@"80" useTLS:NO];
+    NSString *keyHTTPS = [self.client connectionPoolKeyForHost:@"example.com" port:@"443" useTLS:YES];
+
+    XCTAssertNotEqualObjects(keyHTTP, keyHTTPS);
+}
+
+@end

EdgeHttpDNS/sdk/ios/AlicloudHttpDNSTests/Network/HttpdnsNWHTTPClient_BasicIntegrationTests.m

@@ -0,0 +1,406 @@
+//
+//  HttpdnsNWHTTPClient_BasicIntegrationTests.m
+//  AlicloudHttpDNSTests
+//
+//  @author Created by Claude Code on 2025-11-01
+//  Copyright © 2025 alibaba-inc.com. All rights reserved.
+//
+//  基础集成测试 - 包含基础功能 (G) 和连接复用 (J) 测试组
+//  测试总数：12 个（G:7 + J:5）
+//
+
+#import "HttpdnsNWHTTPClientTestBase.h"
+
+@interface HttpdnsNWHTTPClient_BasicIntegrationTests : HttpdnsNWHTTPClientTestBase
+
+@end
+
+@implementation HttpdnsNWHTTPClient_BasicIntegrationTests
+
+#pragma mark - G. 集成测试（真实网络）
+
+// G.1 HTTP GET 请求
+- (void)testIntegration_HTTPGetRequest_RealNetwork {
+    XCTestExpectation *expectation = [self expectationWithDescription:@"HTTP GET request"];
+
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+        NSError *error = nil;
+        HttpdnsNWHTTPClientResponse *response = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                                                                userAgent:@"HttpdnsNWHTTPClient/1.0"
+                                                                                  timeout:15.0
+                                                                                    error:&error];
+
+        XCTAssertNotNil(response, @"Response should not be nil");
+        XCTAssertNil(error, @"Error should be nil, got: %@", error);
+        XCTAssertEqual(response.statusCode, 200, @"Status code should be 200");
+        XCTAssertNotNil(response.body, @"Body should not be nil");
+        XCTAssertGreaterThan(response.body.length, 0, @"Body should not be empty");
+
+        // 验证响应包含 JSON
+        NSError *jsonError = nil;
+        NSDictionary *jsonDict = [NSJSONSerialization JSONObjectWithData:response.body
+                                                                 options:0
+                                                                   error:&jsonError];
+        XCTAssertNotNil(jsonDict, @"Response should be valid JSON");
+        XCTAssertNil(jsonError, @"JSON parsing should succeed");
+
+        [expectation fulfill];
+    });
+
+    [self waitForExpectations:@[expectation] timeout:20.0];
+}
+
+// G.2 HTTPS GET 请求
+- (void)testIntegration_HTTPSGetRequest_RealNetwork {
+    XCTestExpectation *expectation = [self expectationWithDescription:@"HTTPS GET request"];
+
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+        NSError *error = nil;
+        HttpdnsNWHTTPClientResponse *response = [self.client performRequestWithURLString:@"https://127.0.0.1:11443/get"
+                                                                                userAgent:@"HttpdnsNWHTTPClient/1.0"
+                                                                                  timeout:15.0
+                                                                                    error:&error];
+
+        XCTAssertNotNil(response, @"Response should not be nil");
+        XCTAssertNil(error, @"Error should be nil, got: %@", error);
+        XCTAssertEqual(response.statusCode, 200, @"Status code should be 200");
+        XCTAssertNotNil(response.body, @"Body should not be nil");
+
+        // 验证 TLS 成功建立
+        XCTAssertGreaterThan(response.body.length, 0, @"HTTPS body should not be empty");
+
+        [expectation fulfill];
+    });
+
+    [self waitForExpectations:@[expectation] timeout:20.0];
+}
+
+// G.3 HTTP 404 响应
+- (void)testIntegration_NotFound_Returns404 {
+    XCTestExpectation *expectation = [self expectationWithDescription:@"404 response"];
+
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+        NSError *error = nil;
+        HttpdnsNWHTTPClientResponse *response = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/status/404"
+                                                                                userAgent:@"HttpdnsNWHTTPClient/1.0"
+                                                                                  timeout:15.0
+                                                                                    error:&error];
+
+        XCTAssertNotNil(response, @"Response should not be nil even for 404");
+        XCTAssertNil(error, @"Error should be nil for valid HTTP response");
+        XCTAssertEqual(response.statusCode, 404, @"Status code should be 404");
+
+        [expectation fulfill];
+    });
+
+    [self waitForExpectations:@[expectation] timeout:20.0];
+}
+
+// G.4 连接复用测试
+- (void)testIntegration_ConnectionReuse_MultipleRequests {
+    XCTestExpectation *expectation = [self expectationWithDescription:@"Connection reuse"];
+
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+        NSError *error1 = nil;
+        HttpdnsNWHTTPClientResponse *response1 = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                                                                 userAgent:@"HttpdnsNWHTTPClient/1.0"
+                                                                                   timeout:15.0
+                                                                                     error:&error1];
+
+        XCTAssertNotNil(response1, @"First response should not be nil");
+        XCTAssertNil(error1, @"First request should succeed");
+        XCTAssertEqual(response1.statusCode, 200);
+
+        // 立即发起第二个请求，应该复用连接
+        NSError *error2 = nil;
+        HttpdnsNWHTTPClientResponse *response2 = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                                                                 userAgent:@"HttpdnsNWHTTPClient/1.0"
+                                                                                   timeout:15.0
+                                                                                     error:&error2];
+
+        XCTAssertNotNil(response2, @"Second response should not be nil");
+        XCTAssertNil(error2, @"Second request should succeed");
+        XCTAssertEqual(response2.statusCode, 200);
+
+        [expectation fulfill];
+    });
+
+    [self waitForExpectations:@[expectation] timeout:30.0];
+}
+
+// G.5 Chunked 响应处理
+- (void)testIntegration_ChunkedResponse_RealNetwork {
+    XCTestExpectation *expectation = [self expectationWithDescription:@"Chunked response"];
+
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+        NSError *error = nil;
+        // httpbin.org/stream-bytes 返回 chunked 编码的响应
+        HttpdnsNWHTTPClientResponse *response = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/stream-bytes/1024"
+                                                                                userAgent:@"HttpdnsNWHTTPClient/1.0"
+                                                                                  timeout:15.0
+                                                                                    error:&error];
+
+        XCTAssertNotNil(response, @"Response should not be nil");
+        XCTAssertNil(error, @"Error should be nil, got: %@", error);
+        XCTAssertEqual(response.statusCode, 200);
+        XCTAssertEqual(response.body.length, 1024, @"Should receive exactly 1024 bytes");
+
+        // 验证 Transfer-Encoding 头
+        NSString *transferEncoding = response.headers[@"transfer-encoding"];
+        if (transferEncoding) {
+            XCTAssertTrue([transferEncoding containsString:@"chunked"], @"Should use chunked encoding");
+        }
+
+        [expectation fulfill];
+    });
+
+    [self waitForExpectations:@[expectation] timeout:20.0];
+}
+
+#pragma mark - 额外的集成测试
+
+// G.6 超时测试（可选）
+- (void)testIntegration_RequestTimeout_ReturnsError {
+    XCTestExpectation *expectation = [self expectationWithDescription:@"Request timeout"];
+
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+        NSError *error = nil;
+        // httpbin.org/delay/10 会延迟 10 秒响应，我们设置 2 秒超时
+        HttpdnsNWHTTPClientResponse *response = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/delay/10"
+                                                                                userAgent:@"HttpdnsNWHTTPClient/1.0"
+                                                                                  timeout:2.0
+                                                                                    error:&error];
+
+        XCTAssertNil(response, @"Response should be nil on timeout");
+        XCTAssertNotNil(error, @"Error should be set on timeout");
+
+        [expectation fulfill];
+    });
+
+    [self waitForExpectations:@[expectation] timeout:5.0];
+}
+
+// G.7 多个不同头部的请求
+- (void)testIntegration_CustomHeaders_Reflected {
+    XCTestExpectation *expectation = [self expectationWithDescription:@"Custom headers"];
+
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+        NSError *error = nil;
+        HttpdnsNWHTTPClientResponse *response = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/headers"
+                                                                                userAgent:@"TestUserAgent/1.0"
+                                                                                  timeout:15.0
+                                                                                    error:&error];
+
+        XCTAssertNotNil(response);
+        XCTAssertEqual(response.statusCode, 200);
+
+        // 解析 JSON 响应，验证我们的 User-Agent 被发送
+        NSError *jsonError = nil;
+        NSDictionary *jsonDict = [NSJSONSerialization JSONObjectWithData:response.body
+                                                                 options:0
+                                                                   error:&jsonError];
+        XCTAssertNotNil(jsonDict);
+
+        NSDictionary *headers = jsonDict[@"headers"];
+        XCTAssertTrue([headers[@"User-Agent"] containsString:@"TestUserAgent"], @"User-Agent should be sent");
+
+        [expectation fulfill];
+    });
+
+    [self waitForExpectations:@[expectation] timeout:20.0];
+}
+
+#pragma mark - J. 连接复用详细测试
+
+// J.1 连接过期测试（31秒后创建新连接）
+- (void)testConnectionReuse_Expiry31Seconds_NewConnectionCreated {
+    if (getenv("SKIP_SLOW_TESTS")) {
+        return;
+    }
+
+    XCTestExpectation *expectation = [self expectationWithDescription:@"Connection expiry"];
+
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+        CFAbsoluteTime time1 = CFAbsoluteTimeGetCurrent();
+        NSError *error1 = nil;
+        HttpdnsNWHTTPClientResponse *response1 = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                                                                 userAgent:@"First"
+                                                                                   timeout:15.0
+                                                                                     error:&error1];
+        CFAbsoluteTime elapsed1 = CFAbsoluteTimeGetCurrent() - time1;
+        XCTAssertTrue(response1 != nil || error1 != nil);
+
+        // 等待31秒让连接过期
+        [NSThread sleepForTimeInterval:31.0];
+
+        // 第二个请求应该创建新连接（可能稍慢，因为需要建立连接）
+        CFAbsoluteTime time2 = CFAbsoluteTimeGetCurrent();
+        NSError *error2 = nil;
+        HttpdnsNWHTTPClientResponse *response2 = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                                                                 userAgent:@"Second"
+                                                                                   timeout:15.0
+                                                                                     error:&error2];
+        CFAbsoluteTime elapsed2 = CFAbsoluteTimeGetCurrent() - time2;
+        XCTAssertTrue(response2 != nil || error2 != nil);
+
+        // 注意：由于网络波动，不能严格比较时间
+        // 只验证请求都成功即可
+
+        [expectation fulfill];
+    });
+
+    [self waitForExpectations:@[expectation] timeout:70.0];
+}
+
+// J.2 连接池容量限制验证
+- (void)testConnectionReuse_TenRequests_OnlyFourConnectionsKept {
+    XCTestExpectation *expectation = [self expectationWithDescription:@"Pool size limit"];
+
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+        // 连续10个请求
+        for (NSInteger i = 0; i < 10; i++) {
+            NSError *error = nil;
+            HttpdnsNWHTTPClientResponse *response = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                                                                    userAgent:@"PoolSizeTest"
+                                                                                      timeout:15.0
+                                                                                        error:&error];
+            XCTAssertTrue(response != nil || error != nil);
+        }
+
+        // 等待所有连接归还
+        [NSThread sleepForTimeInterval:1.0];
+
+        // 无法直接验证池大小，但如果实现正确，池应自动限制
+        // 后续请求应该仍能正常工作
+        NSError *error = nil;
+        HttpdnsNWHTTPClientResponse *response = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                                                                userAgent:@"Verification"
+                                                                                  timeout:15.0
+                                                                                    error:&error];
+        XCTAssertTrue(response != nil || error != nil);
+
+        [expectation fulfill];
+    });
+
+    [self waitForExpectations:@[expectation] timeout:120.0];
+}
+
+// J.3 不同路径复用连接
+- (void)testConnectionReuse_DifferentPaths_SameConnection {
+    XCTestExpectation *expectation = [self expectationWithDescription:@"Different paths"];
+
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+        NSArray<NSString *> *paths = @[@"/get", @"/headers", @"/user-agent", @"/uuid"];
+        NSMutableArray<NSNumber *> *times = [NSMutableArray array];
+
+        for (NSString *path in paths) {
+            CFAbsoluteTime start = CFAbsoluteTimeGetCurrent();
+            NSString *urlString = [NSString stringWithFormat:@"http://127.0.0.1:11080%@", path];
+            NSError *error = nil;
+            HttpdnsNWHTTPClientResponse *response = [self.client performRequestWithURLString:urlString
+                                                                                    userAgent:@"PathTest"
+                                                                                      timeout:15.0
+                                                                                        error:&error];
+            CFAbsoluteTime elapsed = CFAbsoluteTimeGetCurrent() - start;
+
+            XCTAssertTrue(response != nil || error != nil);
+            [times addObject:@(elapsed)];
+        }
+
+        // 如果连接复用工作正常，后续请求应该更快（但网络波动可能影响）
+        // 至少验证所有请求都成功
+        XCTAssertEqual(times.count, paths.count);
+
+        [expectation fulfill];
+    });
+
+    [self waitForExpectations:@[expectation] timeout:60.0];
+}
+
+// J.4 HTTP vs HTTPS 使用不同连接
+- (void)testConnectionReuse_HTTPvsHTTPS_DifferentPoolKeys {
+    XCTestExpectation *expectation = [self expectationWithDescription:@"HTTP vs HTTPS"];
+
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+        // HTTP 请求
+        NSError *httpError = nil;
+        HttpdnsNWHTTPClientResponse *httpResponse = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                                                                    userAgent:@"HTTP"
+                                                                                      timeout:15.0
+                                                                                        error:&httpError];
+        XCTAssertTrue(httpResponse != nil || httpError != nil);
+
+        // HTTPS 请求（应该使用不同的连接池 key）
+        NSError *httpsError = nil;
+        HttpdnsNWHTTPClientResponse *httpsResponse = [self.client performRequestWithURLString:@"https://127.0.0.1:11443/get"
+                                                                                     userAgent:@"HTTPS"
+                                                                                       timeout:15.0
+                                                                                         error:&httpsError];
+        XCTAssertTrue(httpsResponse != nil || httpsError != nil);
+
+        // 两者都应该成功，且不会相互干扰
+        [expectation fulfill];
+    });
+
+    [self waitForExpectations:@[expectation] timeout:35.0];
+}
+
+// J.5 长连接保持测试
+- (void)testConnectionReuse_TwentyRequestsOneSecondApart_ConnectionKeptAlive {
+    if (getenv("SKIP_SLOW_TESTS")) {
+        return;
+    }
+
+    XCTestExpectation *expectation = [self expectationWithDescription:@"Keep-alive"];
+
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+        NSInteger successCount = 0;
+        NSMutableArray<NSNumber *> *requestTimes = [NSMutableArray array];
+
+        // 20个请求，间隔1秒（第一个请求立即执行）
+        for (NSInteger i = 0; i < 20; i++) {
+            // 除第一个请求外，每次请求前等待1秒
+            if (i > 0) {
+                [NSThread sleepForTimeInterval:1.0];
+            }
+
+            CFAbsoluteTime startTime = CFAbsoluteTimeGetCurrent();
+            NSError *error = nil;
+            HttpdnsNWHTTPClientResponse *response = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                                                                    userAgent:@"KeepAlive"
+                                                                                      timeout:10.0
+                                                                                        error:&error];
+            CFAbsoluteTime elapsed = CFAbsoluteTimeGetCurrent() - startTime;
+            [requestTimes addObject:@(elapsed)];
+
+            if (response && (response.statusCode == 200 || response.statusCode == 503)) {
+                successCount++;
+            } else {
+                // 如果请求失败，提前退出以避免超时
+                break;
+            }
+        }
+
+        // 至少大部分请求应该成功
+        XCTAssertGreaterThan(successCount, 15, @"Most requests should succeed with connection reuse");
+
+        // 验证连接复用：后续请求应该更快（如果使用了keep-alive）
+        if (requestTimes.count >= 10) {
+            double firstRequestTime = [requestTimes[0] doubleValue];
+            double laterAvgTime = 0;
+            for (NSInteger i = 5; i < MIN(10, requestTimes.count); i++) {
+                laterAvgTime += [requestTimes[i] doubleValue];
+            }
+            laterAvgTime /= MIN(5, requestTimes.count - 5);
+            // 后续请求应该不会明显更慢（说明连接复用工作正常）
+            XCTAssertLessThanOrEqual(laterAvgTime, firstRequestTime * 2.0, @"Connection reuse should keep latency reasonable");
+        }
+
+        [expectation fulfill];
+    });
+
+    // 超时计算: 19秒sleep + 20个请求×~2秒 = 59秒，设置50秒（提前退出机制保证效率）
+    [self waitForExpectations:@[expectation] timeout:50.0];
+}
+
+@end

EdgeHttpDNS/sdk/ios/AlicloudHttpDNSTests/Network/HttpdnsNWHTTPClient_ConcurrencyTests.m

@@ -0,0 +1,534 @@
+//
+//  HttpdnsNWHTTPClient_ConcurrencyTests.m
+//  AlicloudHttpDNSTests
+//
+//  @author Created by Claude Code on 2025-11-01
+//  Copyright © 2025 alibaba-inc.com. All rights reserved.
+//
+//  并发测试 - 包含并发请求 (H)、竞态条件 (I)、并发多端口 (N) 测试组
+//  测试总数：13 个（H:5 + I:5 + N:3）
+//
+
+#import "HttpdnsNWHTTPClientTestBase.h"
+
+@interface HttpdnsNWHTTPClient_ConcurrencyTests : HttpdnsNWHTTPClientTestBase
+
+@end
+
+@implementation HttpdnsNWHTTPClient_ConcurrencyTests
+
+#pragma mark - H. 并发测试
+
+// H.1 并发请求同一主机
+- (void)testConcurrency_ParallelRequestsSameHost_AllSucceed {
+    NSInteger concurrentCount = 10;
+    NSMutableArray<XCTestExpectation *> *expectations = [NSMutableArray array];
+    dispatch_group_t group = dispatch_group_create();
+    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
+
+    NSMutableArray<NSNumber *> *responseTimes = [NSMutableArray array];
+    NSLock *lock = [[NSLock alloc] init];
+
+    for (NSInteger i = 0; i < concurrentCount; i++) {
+        XCTestExpectation *expectation = [self expectationWithDescription:[NSString stringWithFormat:@"Request %ld", (long)i]];
+        [expectations addObject:expectation];
+
+        dispatch_group_enter(group);
+        dispatch_async(queue, ^{
+            CFAbsoluteTime startTime = CFAbsoluteTimeGetCurrent();
+            NSError *error = nil;
+            HttpdnsNWHTTPClientResponse *response = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                                                                    userAgent:@"HttpdnsNWHTTPClient/1.0"
+                                                                                      timeout:15.0
+                                                                                        error:&error];
+            CFAbsoluteTime endTime = CFAbsoluteTimeGetCurrent();
+
+            XCTAssertNotNil(response, @"Response %ld should not be nil", (long)i);
+            XCTAssertTrue(response.statusCode == 200 || response.statusCode == 503,
+                         @"Request %ld got statusCode=%ld, expected 200 or 503", (long)i, (long)response.statusCode);
+
+            [lock lock];
+            [responseTimes addObject:@(endTime - startTime)];
+            [lock unlock];
+
+            [expectation fulfill];
+            dispatch_group_leave(group);
+        });
+    }
+
+    [self waitForExpectations:expectations timeout:30.0];
+
+    // 验证至少部分请求复用了连接（响应时间有差异）
+    XCTAssertEqual(responseTimes.count, concurrentCount);
+}
+
+// H.2 并发请求不同路径
+- (void)testConcurrency_ParallelRequestsDifferentPaths_AllSucceed {
+    NSArray<NSString *> *paths = @[@"/get", @"/status/200", @"/headers", @"/user-agent", @"/uuid"];
+    NSMutableArray<XCTestExpectation *> *expectations = [NSMutableArray array];
+    dispatch_group_t group = dispatch_group_create();
+    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
+
+    for (NSString *path in paths) {
+        XCTestExpectation *expectation = [self expectationWithDescription:path];
+        [expectations addObject:expectation];
+
+        dispatch_group_enter(group);
+        dispatch_async(queue, ^{
+            NSString *urlString = [NSString stringWithFormat:@"http://127.0.0.1:11080%@", path];
+            NSError *error = nil;
+            HttpdnsNWHTTPClientResponse *response = [self.client performRequestWithURLString:urlString
+                                                                                    userAgent:@"HttpdnsNWHTTPClient/1.0"
+                                                                                      timeout:15.0
+                                                                                        error:&error];
+
+            XCTAssertNotNil(response, @"Response for %@ should not be nil", path);
+            XCTAssertTrue(response.statusCode == 200 || response.statusCode == 503, @"Request %@ should get valid status", path);
+
+            [expectation fulfill];
+            dispatch_group_leave(group);
+        });
+    }
+
+    [self waitForExpectations:expectations timeout:30.0];
+}
+
+// H.3 并发 HTTP + HTTPS
+- (void)testConcurrency_MixedHTTPAndHTTPS_BothSucceed {
+    NSInteger httpCount = 5;
+    NSInteger httpsCount = 5;
+    NSMutableArray<XCTestExpectation *> *expectations = [NSMutableArray array];
+    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
+
+    // HTTP 请求
+    for (NSInteger i = 0; i < httpCount; i++) {
+        XCTestExpectation *expectation = [self expectationWithDescription:[NSString stringWithFormat:@"HTTP %ld", (long)i]];
+        [expectations addObject:expectation];
+
+        dispatch_async(queue, ^{
+            NSError *error = nil;
+            HttpdnsNWHTTPClientResponse *response = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                                                                    userAgent:@"HttpdnsNWHTTPClient/1.0"
+                                                                                      timeout:15.0
+                                                                                        error:&error];
+
+            XCTAssertNotNil(response);
+            [expectation fulfill];
+        });
+    }
+
+    // HTTPS 请求
+    for (NSInteger i = 0; i < httpsCount; i++) {
+        XCTestExpectation *expectation = [self expectationWithDescription:[NSString stringWithFormat:@"HTTPS %ld", (long)i]];
+        [expectations addObject:expectation];
+
+        dispatch_async(queue, ^{
+            NSError *error = nil;
+            HttpdnsNWHTTPClientResponse *response = [self.client performRequestWithURLString:@"https://127.0.0.1:11443/get"
+                                                                                    userAgent:@"HttpdnsNWHTTPClient/1.0"
+                                                                                      timeout:15.0
+                                                                                        error:&error];
+
+            XCTAssertNotNil(response);
+            [expectation fulfill];
+        });
+    }
+
+    [self waitForExpectations:expectations timeout:40.0];
+}
+
+// H.4 高负载压力测试
+- (void)testConcurrency_HighLoad50Concurrent_NoDeadlock {
+    NSInteger concurrentCount = 50;
+    NSMutableArray<XCTestExpectation *> *expectations = [NSMutableArray array];
+    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
+
+    NSLock *successCountLock = [[NSLock alloc] init];
+    __block NSInteger successCount = 0;
+
+    for (NSInteger i = 0; i < concurrentCount; i++) {
+        XCTestExpectation *expectation = [self expectationWithDescription:[NSString stringWithFormat:@"Request %ld", (long)i]];
+        [expectations addObject:expectation];
+
+        dispatch_async(queue, ^{
+            NSError *error = nil;
+            HttpdnsNWHTTPClientResponse *response = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                                                                    userAgent:@"HttpdnsNWHTTPClient/1.0"
+                                                                                      timeout:15.0
+                                                                                        error:&error];
+
+            if (response && (response.statusCode == 200 || response.statusCode == 503)) {
+                [successCountLock lock];
+                successCount++;
+                [successCountLock unlock];
+            }
+
+            [expectation fulfill];
+        });
+    }
+
+    [self waitForExpectations:expectations timeout:60.0];
+
+    // 至少大部分请求应该成功（允许部分失败，因为高负载）
+    XCTAssertGreaterThan(successCount, concurrentCount * 0.8, @"At least 80%% should succeed");
+}
+
+// H.5 混合串行+并发
+- (void)testConcurrency_MixedSerialAndParallel_NoInterference {
+    XCTestExpectation *serialExpectation = [self expectationWithDescription:@"Serial requests"];
+    XCTestExpectation *parallel1 = [self expectationWithDescription:@"Parallel 1"];
+    XCTestExpectation *parallel2 = [self expectationWithDescription:@"Parallel 2"];
+    XCTestExpectation *parallel3 = [self expectationWithDescription:@"Parallel 3"];
+
+    dispatch_queue_t serialQueue = dispatch_queue_create("serial", DISPATCH_QUEUE_SERIAL);
+    dispatch_queue_t parallelQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
+
+    // 串行线程
+    dispatch_async(serialQueue, ^{
+        for (NSInteger i = 0; i < 5; i++) {
+            NSError *error = nil;
+            HttpdnsNWHTTPClientResponse *response = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                                                                    userAgent:@"Serial"
+                                                                                      timeout:15.0
+                                                                                        error:&error];
+            XCTAssertNotNil(response);
+        }
+        [serialExpectation fulfill];
+    });
+
+    // 并发线程
+    dispatch_async(parallelQueue, ^{
+        NSError *error = nil;
+        HttpdnsNWHTTPClientResponse *response = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/uuid"
+                                                                                userAgent:@"Parallel1"
+                                                                                  timeout:15.0
+                                                                                    error:&error];
+        XCTAssertNotNil(response);
+        [parallel1 fulfill];
+    });
+
+    dispatch_async(parallelQueue, ^{
+        NSError *error = nil;
+        HttpdnsNWHTTPClientResponse *response = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/headers"
+                                                                                userAgent:@"Parallel2"
+                                                                                  timeout:15.0
+                                                                                    error:&error];
+        XCTAssertNotNil(response);
+        [parallel2 fulfill];
+    });
+
+    dispatch_async(parallelQueue, ^{
+        NSError *error = nil;
+        HttpdnsNWHTTPClientResponse *response = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/user-agent"
+                                                                                userAgent:@"Parallel3"
+                                                                                  timeout:15.0
+                                                                                    error:&error];
+        XCTAssertNotNil(response);
+        [parallel3 fulfill];
+    });
+
+    [self waitForExpectations:@[serialExpectation, parallel1, parallel2, parallel3] timeout:60.0];
+}
+
+#pragma mark - I. 竞态条件测试
+
+// I.1 连接池容量测试
+- (void)testRaceCondition_ExceedPoolCapacity_MaxFourConnections {
+    XCTestExpectation *expectation = [self expectationWithDescription:@"Pool capacity test"];
+
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+        // 快速连续发起 10 个请求
+        for (NSInteger i = 0; i < 10; i++) {
+            NSError *error = nil;
+            HttpdnsNWHTTPClientResponse *response = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                                                                    userAgent:@"PoolTest"
+                                                                                      timeout:15.0
+                                                                                        error:&error];
+            XCTAssertTrue(response != nil || error != nil);
+        }
+
+        // 等待连接归还
+        [NSThread sleepForTimeInterval:1.0];
+
+        // 注意：无法直接检查池大小（内部实现），只能通过行为验证
+        // 如果实现正确，池应自动限制为最多 4 个空闲连接
+
+        [expectation fulfill];
+    });
+
+    [self waitForExpectations:@[expectation] timeout:120.0];
+}
+
+// I.2 同时归还连接
+- (void)testRaceCondition_SimultaneousConnectionReturn_NoDataRace {
+    NSInteger concurrentCount = 5;
+    NSMutableArray<XCTestExpectation *> *expectations = [NSMutableArray array];
+    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
+
+    for (NSInteger i = 0; i < concurrentCount; i++) {
+        XCTestExpectation *expectation = [self expectationWithDescription:[NSString stringWithFormat:@"Return %ld", (long)i]];
+        [expectations addObject:expectation];
+
+        dispatch_async(queue, ^{
+            NSError *error = nil;
+            HttpdnsNWHTTPClientResponse *response = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                                                                    userAgent:@"ReturnTest"
+                                                                                      timeout:15.0
+                                                                                        error:&error];
+            XCTAssertTrue(response != nil || error != nil);
+            // 连接在这里自动归还
+
+            [expectation fulfill];
+        });
+    }
+
+    [self waitForExpectations:expectations timeout:30.0];
+
+    // 如果没有崩溃或断言失败，说明并发归还处理正确
+}
+
+// I.3 获取-归还-再获取竞态
+- (void)testRaceCondition_AcquireReturnReacquire_CorrectState {
+    XCTestExpectation *expectation = [self expectationWithDescription:@"Acquire-Return-Reacquire"];
+
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+        // 第一个请求
+        NSError *error1 = nil;
+        HttpdnsNWHTTPClientResponse *response1 = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                                                                 userAgent:@"First"
+                                                                                   timeout:15.0
+                                                                                     error:&error1];
+        XCTAssertTrue(response1 != nil || error1 != nil);
+
+        // 极短暂等待确保连接归还
+        [NSThread sleepForTimeInterval:0.1];
+
+        // 第二个请求应该能复用连接
+        NSError *error2 = nil;
+        HttpdnsNWHTTPClientResponse *response2 = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                                                                 userAgent:@"Second"
+                                                                                   timeout:15.0
+                                                                                     error:&error2];
+        XCTAssertTrue(response2 != nil || error2 != nil);
+
+        [expectation fulfill];
+    });
+
+    [self waitForExpectations:@[expectation] timeout:35.0];
+}
+
+// I.4 超时与活跃连接冲突（需要31秒，标记为慢测试）
+- (void)testRaceCondition_ExpiredConnectionPruning_CreatesNewConnection {
+    // 跳过此测试如果环境变量设置了 SKIP_SLOW_TESTS
+    if (getenv("SKIP_SLOW_TESTS")) {
+        return;
+    }
+
+    XCTestExpectation *expectation = [self expectationWithDescription:@"Connection expiry"];
+
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+        // 创建连接
+        NSError *error1 = nil;
+        HttpdnsNWHTTPClientResponse *response1 = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                                                                 userAgent:@"Initial"
+                                                                                   timeout:15.0
+                                                                                     error:&error1];
+        XCTAssertTrue(response1 != nil || error1 != nil);
+
+        // 等待超过30秒超时
+        [NSThread sleepForTimeInterval:31.0];
+
+        // 新请求应该创建新连接（旧连接已过期）
+        NSError *error2 = nil;
+        HttpdnsNWHTTPClientResponse *response2 = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                                                                 userAgent:@"AfterExpiry"
+                                                                                   timeout:15.0
+                                                                                     error:&error2];
+        XCTAssertTrue(response2 != nil || error2 != nil);
+
+        [expectation fulfill];
+    });
+
+    [self waitForExpectations:@[expectation] timeout:70.0];
+}
+
+// I.5 错误恢复竞态
+- (void)testRaceCondition_ErrorRecovery_PoolRemainsHealthy {
+    NSMutableArray<XCTestExpectation *> *expectations = [NSMutableArray array];
+    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
+
+    // 发起一些会失败的请求
+    for (NSInteger i = 0; i < 3; i++) {
+        XCTestExpectation *expectation = [self expectationWithDescription:[NSString stringWithFormat:@"Error %ld", (long)i]];
+        [expectations addObject:expectation];
+
+        dispatch_async(queue, ^{
+            NSError *error = nil;
+            // 使用短超时导致失败
+            HttpdnsNWHTTPClientResponse *response = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/delay/5"
+                                                                                    userAgent:@"ErrorTest"
+                                                                                      timeout:1.0
+                                                                                        error:&error];
+            // 预期失败
+            [expectation fulfill];
+        });
+    }
+
+    [self waitForExpectations:expectations timeout:15.0];
+
+    // 验证后续正常请求仍能成功
+    XCTestExpectation *recoveryExpectation = [self expectationWithDescription:@"Recovery"];
+    dispatch_async(queue, ^{
+        NSError *error = nil;
+        HttpdnsNWHTTPClientResponse *response = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                                                                userAgent:@"Recovery"
+                                                                                  timeout:15.0
+                                                                                    error:&error];
+        XCTAssertTrue(response != nil || error != nil);
+        [recoveryExpectation fulfill];
+    });
+
+    [self waitForExpectations:@[recoveryExpectation] timeout:20.0];
+}
+
+#pragma mark - N. 并发多端口测试
+
+// N.1 并发保持连接（慢测试）
+- (void)testConcurrentMultiPort_ParallelKeepAlive_IndependentConnections {
+    if (getenv("SKIP_SLOW_TESTS")) {
+        return;
+    }
+
+    XCTestExpectation *expectation11443 = [self expectationWithDescription:@"Port 11443 keep-alive"];
+    XCTestExpectation *expectation11444 = [self expectationWithDescription:@"Port 11444 keep-alive"];
+
+    // 线程 1：向端口 11443 发起 10 个请求，间隔 1 秒
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+        for (NSInteger i = 0; i < 10; i++) {
+            if (i > 0) {
+                [NSThread sleepForTimeInterval:1.0];
+            }
+            NSError *error = nil;
+            [self.client performRequestWithURLString:@"https://127.0.0.1:11443/get"
+                                            userAgent:@"KeepAlive11443"
+                                              timeout:15.0
+                                                error:&error];
+        }
+        [expectation11443 fulfill];
+    });
+
+    // 线程 2：同时向端口 11444 发起 10 个请求，间隔 1 秒
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+        for (NSInteger i = 0; i < 10; i++) {
+            if (i > 0) {
+                [NSThread sleepForTimeInterval:1.0];
+            }
+            NSError *error = nil;
+            [self.client performRequestWithURLString:@"https://127.0.0.1:11444/get"
+                                            userAgent:@"KeepAlive11444"
+                                              timeout:15.0
+                                                error:&error];
+        }
+        [expectation11444 fulfill];
+    });
+
+    [self waitForExpectations:@[expectation11443, expectation11444] timeout:40.0];
+}
+
+// N.2 轮询端口分配模式
+- (void)testConcurrentMultiPort_RoundRobinDistribution_EvenLoad {
+    XCTestExpectation *expectation = [self expectationWithDescription:@"Round-robin distribution"];
+
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+        NSArray<NSNumber *> *ports = @[@11443, @11444, @11445, @11446];
+        NSInteger totalRequests = 100;
+        NSMutableDictionary<NSNumber *, NSNumber *> *portRequestCounts = [NSMutableDictionary dictionary];
+
+        // 初始化计数器
+        for (NSNumber *port in ports) {
+            portRequestCounts[port] = @0;
+        }
+
+        // 以轮询方式向 4 个端口分发 100 个请求
+        for (NSInteger i = 0; i < totalRequests; i++) {
+            NSNumber *port = ports[i % ports.count];
+            NSString *urlString = [NSString stringWithFormat:@"https://127.0.0.1:%@/get", port];
+
+            NSError *error = nil;
+            HttpdnsNWHTTPClientResponse *response = [self.client performRequestWithURLString:urlString
+                                                                                    userAgent:@"RoundRobin"
+                                                                                      timeout:15.0
+                                                                                        error:&error];
+
+            if (response && response.statusCode == 200) {
+                NSInteger count = [portRequestCounts[port] integerValue];
+                portRequestCounts[port] = @(count + 1);
+            }
+        }
+
+        // 验证每个端口大约获得 25 个请求
+        for (NSNumber *port in ports) {
+            NSInteger count = [portRequestCounts[port] integerValue];
+            XCTAssertEqual(count, 25, @"Port %@ should receive 25 requests", port);
+        }
+
+        [expectation fulfill];
+    });
+
+    [self waitForExpectations:@[expectation] timeout:180.0];
+}
+
+// N.3 混合负载多端口场景
+- (void)testConcurrentMultiPort_MixedLoadPattern_RobustHandling {
+    NSMutableArray<XCTestExpectation *> *expectations = [NSMutableArray array];
+    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
+
+    // 端口 11443：高负载（20 个请求）
+    for (NSInteger i = 0; i < 20; i++) {
+        XCTestExpectation *expectation = [self expectationWithDescription:[NSString stringWithFormat:@"Heavy11443 %ld", (long)i]];
+        [expectations addObject:expectation];
+
+        dispatch_async(queue, ^{
+            NSError *error = nil;
+            [self.client performRequestWithURLString:@"https://127.0.0.1:11443/get"
+                                            userAgent:@"HeavyLoad"
+                                              timeout:15.0
+                                                error:&error];
+            [expectation fulfill];
+        });
+    }
+
+    // 端口 11444：中负载（10 个请求）
+    for (NSInteger i = 0; i < 10; i++) {
+        XCTestExpectation *expectation = [self expectationWithDescription:[NSString stringWithFormat:@"Medium11444 %ld", (long)i]];
+        [expectations addObject:expectation];
+
+        dispatch_async(queue, ^{
+            NSError *error = nil;
+            [self.client performRequestWithURLString:@"https://127.0.0.1:11444/get"
+                                            userAgent:@"MediumLoad"
+                                              timeout:15.0
+                                                error:&error];
+            [expectation fulfill];
+        });
+    }
+
+    // 端口 11445：低负载（5 个请求）
+    for (NSInteger i = 0; i < 5; i++) {
+        XCTestExpectation *expectation = [self expectationWithDescription:[NSString stringWithFormat:@"Light11445 %ld", (long)i]];
+        [expectations addObject:expectation];
+
+        dispatch_async(queue, ^{
+            NSError *error = nil;
+            [self.client performRequestWithURLString:@"https://127.0.0.1:11445/get"
+                                            userAgent:@"LightLoad"
+                                              timeout:15.0
+                                                error:&error];
+            [expectation fulfill];
+        });
+    }
+
+    [self waitForExpectations:expectations timeout:80.0];
+}
+
+@end

EdgeHttpDNS/sdk/ios/AlicloudHttpDNSTests/Network/HttpdnsNWHTTPClient_EdgeCasesAndTimeoutTests.m

@@ -0,0 +1,740 @@
+//
+//  HttpdnsNWHTTPClient_EdgeCasesAndTimeoutTests.m
+//  AlicloudHttpDNSTests
+//
+//  @author Created by Claude Code on 2025-11-01
+//  Copyright © 2025 alibaba-inc.com. All rights reserved.
+//
+//  边界条件与超时测试 - 包含边界条件 (M)、超时交互 (P) 和 Connection 头部 (R) 测试组
+//  测试总数：15 个（M:4 + P:6 + R:5）
+//
+
+#import "HttpdnsNWHTTPClientTestBase.h"
+
+@interface HttpdnsNWHTTPClient_EdgeCasesAndTimeoutTests : HttpdnsNWHTTPClientTestBase
+
+@end
+
+@implementation HttpdnsNWHTTPClient_EdgeCasesAndTimeoutTests
+
+#pragma mark - M. 边界条件与验证测试
+
+// M.1 连接复用边界：端口内复用，端口间隔离
+- (void)testEdgeCase_ConnectionReuseWithinPortOnly_NotAcross {
+    XCTestExpectation *expectation = [self expectationWithDescription:@"Reuse boundaries"];
+
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+        // 请求 A 到端口 11443
+        CFAbsoluteTime timeA = CFAbsoluteTimeGetCurrent();
+        NSError *errorA = nil;
+        HttpdnsNWHTTPClientResponse *responseA = [self.client performRequestWithURLString:@"https://127.0.0.1:11443/get"
+                                                                                 userAgent:@"RequestA"
+                                                                                   timeout:15.0
+                                                                                     error:&errorA];
+        CFAbsoluteTime elapsedA = CFAbsoluteTimeGetCurrent() - timeA;
+        XCTAssertNotNil(responseA);
+
+        // 请求 B 到端口 11443（应该复用连接，可能更快）
+        CFAbsoluteTime timeB = CFAbsoluteTimeGetCurrent();
+        NSError *errorB = nil;
+        HttpdnsNWHTTPClientResponse *responseB = [self.client performRequestWithURLString:@"https://127.0.0.1:11443/get"
+                                                                                 userAgent:@"RequestB"
+                                                                                   timeout:15.0
+                                                                                     error:&errorB];
+        CFAbsoluteTime elapsedB = CFAbsoluteTimeGetCurrent() - timeB;
+        XCTAssertNotNil(responseB);
+
+        // 请求 C 到端口 11444（应该创建新连接）
+        CFAbsoluteTime timeC = CFAbsoluteTimeGetCurrent();
+        NSError *errorC = nil;
+        HttpdnsNWHTTPClientResponse *responseC = [self.client performRequestWithURLString:@"https://127.0.0.1:11444/get"
+                                                                                 userAgent:@"RequestC"
+                                                                                   timeout:15.0
+                                                                                     error:&errorC];
+        CFAbsoluteTime elapsedC = CFAbsoluteTimeGetCurrent() - timeC;
+        XCTAssertNotNil(responseC);
+
+        // 请求 D 到端口 11444（应该复用端口 11444 的连接）
+        CFAbsoluteTime timeD = CFAbsoluteTimeGetCurrent();
+        NSError *errorD = nil;
+        HttpdnsNWHTTPClientResponse *responseD = [self.client performRequestWithURLString:@"https://127.0.0.1:11444/get"
+                                                                                 userAgent:@"RequestD"
+                                                                                   timeout:15.0
+                                                                                     error:&errorD];
+        CFAbsoluteTime elapsedD = CFAbsoluteTimeGetCurrent() - timeD;
+        XCTAssertNotNil(responseD);
+
+        // 验证所有请求都成功
+        XCTAssertEqual(responseA.statusCode, 200);
+        XCTAssertEqual(responseB.statusCode, 200);
+        XCTAssertEqual(responseC.statusCode, 200);
+        XCTAssertEqual(responseD.statusCode, 200);
+
+        [expectation fulfill];
+    });
+
+    [self waitForExpectations:@[expectation] timeout:70.0];
+}
+
+// M.2 高端口数量压力测试
+- (void)testEdgeCase_HighPortCount_AllPortsManaged {
+    XCTestExpectation *expectation = [self expectationWithDescription:@"High port count"];
+
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+        NSArray<NSNumber *> *ports = @[@11443, @11444, @11445, @11446];
+
+        // 第一轮：向所有端口各发起一个请求
+        for (NSNumber *port in ports) {
+            NSString *urlString = [NSString stringWithFormat:@"https://127.0.0.1:%@/get", port];
+            NSError *error = nil;
+            HttpdnsNWHTTPClientResponse *response = [self.client performRequestWithURLString:urlString
+                                                                                    userAgent:@"Round1"
+                                                                                      timeout:15.0
+                                                                                        error:&error];
+            XCTAssertNotNil(response, @"First round request to port %@ should succeed", port);
+        }
+
+        // 第二轮：再次向所有端口发起请求（应该复用连接）
+        for (NSNumber *port in ports) {
+            NSString *urlString = [NSString stringWithFormat:@"https://127.0.0.1:%@/get", port];
+            NSError *error = nil;
+            HttpdnsNWHTTPClientResponse *response = [self.client performRequestWithURLString:urlString
+                                                                                    userAgent:@"Round2"
+                                                                                      timeout:15.0
+                                                                                        error:&error];
+            XCTAssertNotNil(response, @"Second round request to port %@ should reuse connection", port);
+        }
+
+        [expectation fulfill];
+    });
+
+    [self waitForExpectations:@[expectation] timeout:120.0];
+}
+
+// M.3 并发池访问安全性
+- (void)testEdgeCase_ConcurrentPoolAccess_NoDataRace {
+    NSMutableArray<XCTestExpectation *> *expectations = [NSMutableArray array];
+    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
+
+    NSArray<NSNumber *> *ports = @[@11443, @11444, @11445];
+    NSInteger requestsPerPort = 5;
+
+    // 向三个端口并发发起请求
+    for (NSNumber *port in ports) {
+        for (NSInteger i = 0; i < requestsPerPort; i++) {
+            XCTestExpectation *expectation = [self expectationWithDescription:[NSString stringWithFormat:@"Port %@ Req %ld", port, (long)i]];
+            [expectations addObject:expectation];
+
+            dispatch_async(queue, ^{
+                NSString *urlString = [NSString stringWithFormat:@"https://127.0.0.1:%@/get", port];
+                NSError *error = nil;
+                HttpdnsNWHTTPClientResponse *response = [self.client performRequestWithURLString:urlString
+                                                                                        userAgent:@"ConcurrentAccess"
+                                                                                          timeout:15.0
+                                                                                            error:&error];
+                // 如果没有崩溃或断言失败，说明并发访问安全
+                XCTAssertTrue(response != nil || error != nil);
+                [expectation fulfill];
+            });
+        }
+    }
+
+    [self waitForExpectations:expectations timeout:50.0];
+}
+
+// M.4 端口迁移模式
+- (void)testEdgeCase_PortMigration_OldConnectionsEventuallyExpire {
+    if (getenv("SKIP_SLOW_TESTS")) {
+        return;
+    }
+
+    XCTestExpectation *expectation = [self expectationWithDescription:@"Port migration"];
+
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+        // 阶段 1：向端口 11443 发起多个请求
+        for (NSInteger i = 0; i < 5; i++) {
+            NSError *error = nil;
+            [self.client performRequestWithURLString:@"https://127.0.0.1:11443/get"
+                                            userAgent:@"Port11443"
+                                              timeout:15.0
+                                                error:&error];
+        }
+
+        // 阶段 2：切换到端口 11444，发起多个请求
+        for (NSInteger i = 0; i < 5; i++) {
+            NSError *error = nil;
+            [self.client performRequestWithURLString:@"https://127.0.0.1:11444/get"
+                                            userAgent:@"Port11444"
+                                              timeout:15.0
+                                                error:&error];
+        }
+
+        // 等待超过 30 秒，让端口 11443 的连接过期
+        [NSThread sleepForTimeInterval:31.0];
+
+        // 阶段 3：验证端口 11444 仍然可用
+        NSError *error1 = nil;
+        HttpdnsNWHTTPClientResponse *response1 = [self.client performRequestWithURLString:@"https://127.0.0.1:11444/get"
+                                                                                 userAgent:@"Port11444After"
+                                                                                   timeout:15.0
+                                                                                     error:&error1];
+        XCTAssertNotNil(response1, @"Port 11444 should still work after 11443 expired");
+
+        // 阶段 4：端口 11443 应该创建新连接（旧连接已过期）
+        NSError *error2 = nil;
+        HttpdnsNWHTTPClientResponse *response2 = [self.client performRequestWithURLString:@"https://127.0.0.1:11443/get"
+                                                                                 userAgent:@"Port11443New"
+                                                                                   timeout:15.0
+                                                                                     error:&error2];
+        XCTAssertNotNil(response2, @"Port 11443 should work with new connection after expiry");
+
+        [expectation fulfill];
+    });
+
+    [self waitForExpectations:@[expectation] timeout:120.0];
+}
+
+#pragma mark - P. 超时与连接池交互测试
+
+// P.1 单次超时后连接被正确移除
+- (void)testTimeout_SingleRequest_ConnectionRemovedFromPool {
+    [self.client resetPoolStatistics];
+    NSString *poolKey = @"127.0.0.1:11080:tcp";
+
+    // 验证初始状态
+    XCTAssertEqual([self.client connectionPoolCountForKey:poolKey], 0,
+                   @"Pool should be empty initially");
+
+    // 发起超时请求（delay 10s, timeout 1s）
+    NSError *error = nil;
+    HttpdnsNWHTTPClientResponse *response = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/delay/10"
+                                                                            userAgent:@"TimeoutTest"
+                                                                              timeout:1.0
+                                                                                error:&error];
+
+    // 验证请求失败
+    XCTAssertNil(response, @"Response should be nil on timeout");
+    XCTAssertNotNil(error, @"Error should be set on timeout");
+
+    // 等待异步 returnConnection 完成
+    [NSThread sleepForTimeInterval:0.5];
+
+    // 验证池状态：超时连接应该被移除
+    XCTAssertEqual([self.client connectionPoolCountForKey:poolKey], 0,
+                   @"Timed-out connection should be removed from pool");
+    XCTAssertEqual([self.client totalConnectionCount], 0,
+                   @"No connections should remain in pool");
+
+    // 验证统计
+    XCTAssertEqual(self.client.connectionCreationCount, 1,
+                   @"Should have created 1 connection");
+    XCTAssertEqual(self.client.connectionReuseCount, 0,
+                   @"No reuse for timed-out connection");
+}
+
+// P.2 超时后连接池恢复能力
+- (void)testTimeout_PoolRecovery_SubsequentRequestSucceeds {
+    [self.client resetPoolStatistics];
+    NSString *poolKey = @"127.0.0.1:11080:tcp";
+
+    // 第一个请求：超时
+    NSError *error1 = nil;
+    HttpdnsNWHTTPClientResponse *response1 = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/delay/10"
+                                                                             userAgent:@"TimeoutTest"
+                                                                               timeout:1.0
+                                                                                 error:&error1];
+    XCTAssertNil(response1, @"First request should timeout");
+    XCTAssertNotNil(error1);
+
+    // 等待清理完成
+    [NSThread sleepForTimeInterval:0.5];
+
+    // 第二个请求：正常（验证池已恢复）
+    NSError *error2 = nil;
+    HttpdnsNWHTTPClientResponse *response2 = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                                                             userAgent:@"RecoveryTest"
+                                                                               timeout:15.0
+                                                                                 error:&error2];
+    XCTAssertNotNil(response2, @"Second request should succeed after timeout");
+    XCTAssertEqual(response2.statusCode, 200);
+
+    // 等待 returnConnection
+    [NSThread sleepForTimeInterval:0.5];
+
+    // 验证池恢复：现在应该有 1 个连接（来自第二个请求）
+    XCTAssertEqual([self.client connectionPoolCountForKey:poolKey], 1,
+                   @"Pool should have 1 connection from second request");
+
+    // 第三个请求：应该复用第二个请求的连接
+    NSError *error3 = nil;
+    HttpdnsNWHTTPClientResponse *response3 = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                                                             userAgent:@"ReuseTest"
+                                                                               timeout:15.0
+                                                                                 error:&error3];
+    XCTAssertNotNil(response3);
+    XCTAssertEqual(response3.statusCode, 200);
+
+    // 验证统计：1 个超时（创建后移除）+ 1 个成功（创建）+ 1 个复用
+    XCTAssertEqual(self.client.connectionCreationCount, 2,
+                   @"Should have created 2 connections (1 timed out, 1 succeeded)");
+    XCTAssertEqual(self.client.connectionReuseCount, 1,
+                   @"Third request should reuse second's connection");
+}
+
+// P.3 并发场景：部分超时不影响成功请求的连接复用
+- (void)testTimeout_ConcurrentPartialTimeout_SuccessfulRequestsReuse {
+    [self.client resetPoolStatistics];
+    NSString *poolKey = @"127.0.0.1:11080:tcp";
+
+    NSMutableArray<XCTestExpectation *> *expectations = [NSMutableArray array];
+    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
+
+    NSLock *successCountLock = [[NSLock alloc] init];
+    NSLock *timeoutCountLock = [[NSLock alloc] init];
+    __block NSInteger successCount = 0;
+    __block NSInteger timeoutCount = 0;
+
+    // 发起 10 个请求：5 个正常，5 个超时
+    for (NSInteger i = 0; i < 10; i++) {
+        XCTestExpectation *expectation = [self expectationWithDescription:[NSString stringWithFormat:@"Request %ld", (long)i]];
+        [expectations addObject:expectation];
+
+        dispatch_async(queue, ^{
+            NSError *error = nil;
+            NSString *urlString;
+            NSTimeInterval timeout;
+
+            if (i % 2 == 0) {
+                // 偶数：正常请求
+                urlString = @"http://127.0.0.1:11080/get";
+                timeout = 15.0;
+            } else {
+                // 奇数：超时请求
+                urlString = @"http://127.0.0.1:11080/delay/10";
+                timeout = 0.5;
+            }
+
+            HttpdnsNWHTTPClientResponse *response = [self.client performRequestWithURLString:urlString
+                                                                                    userAgent:@"ConcurrentTest"
+                                                                                      timeout:timeout
+                                                                                        error:&error];
+
+            if (response && response.statusCode == 200) {
+                [successCountLock lock];
+                successCount++;
+                [successCountLock unlock];
+            } else {
+                [timeoutCountLock lock];
+                timeoutCount++;
+                [timeoutCountLock unlock];
+            }
+
+            [expectation fulfill];
+        });
+    }
+
+    [self waitForExpectations:expectations timeout:20.0];
+
+    // 验证结果
+    XCTAssertEqual(successCount, 5, @"5 requests should succeed");
+    XCTAssertEqual(timeoutCount, 5, @"5 requests should timeout");
+
+    // 验证连接创建数合理（5个成功 + 5个超时 = 最多10个，可能有复用）
+    XCTAssertGreaterThan(self.client.connectionCreationCount, 0,
+                         @"Should have created connections for concurrent requests");
+    XCTAssertLessThanOrEqual(self.client.connectionCreationCount, 10,
+                             @"Should not create more than 10 connections");
+
+    // 等待所有连接归还（异步操作需要更长时间）
+    [NSThread sleepForTimeInterval:2.0];
+
+    // 验证总连接数合理（无泄漏）- 关键验证点
+    // 在并发场景下，成功的连接可能已经被关闭（remote close），池可能为空
+    XCTAssertLessThanOrEqual([self.client totalConnectionCount], 4,
+                             @"Total connections should not exceed pool limit (no leak)");
+
+    // 发起新请求验证池仍然健康（能创建新连接）
+    NSError *recoveryError = nil;
+    HttpdnsNWHTTPClientResponse *recoveryResponse = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                                                                    userAgent:@"RecoveryTest"
+                                                                                      timeout:15.0
+                                                                                        error:&recoveryError];
+    XCTAssertNotNil(recoveryResponse, @"Pool should recover and handle new requests after mixed timeout/success");
+    XCTAssertEqual(recoveryResponse.statusCode, 200, @"Recovery request should succeed");
+}
+
+// P.4 连续超时不导致连接泄漏
+- (void)testTimeout_ConsecutiveTimeouts_NoConnectionLeak {
+    [self.client resetPoolStatistics];
+    NSString *poolKey = @"127.0.0.1:11080:tcp";
+
+    // 连续发起 10 个超时请求
+    for (NSInteger i = 0; i < 10; i++) {
+        NSError *error = nil;
+        HttpdnsNWHTTPClientResponse *response = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/delay/10"
+                                                                                userAgent:@"LeakTest"
+                                                                                  timeout:0.5
+                                                                                    error:&error];
+        XCTAssertNil(response, @"Request %ld should timeout", (long)i);
+
+        // 等待清理
+        [NSThread sleepForTimeInterval:0.2];
+    }
+
+    // 验证池状态：无连接泄漏
+    XCTAssertEqual([self.client connectionPoolCountForKey:poolKey], 0,
+                   @"Pool should be empty after consecutive timeouts");
+    XCTAssertEqual([self.client totalConnectionCount], 0,
+                   @"No connections should leak");
+
+    // 验证统计：每次都创建新连接（因为超时的被移除）
+    XCTAssertEqual(self.client.connectionCreationCount, 10,
+                   @"Should have created 10 connections (all timed out and removed)");
+    XCTAssertEqual(self.client.connectionReuseCount, 0,
+                   @"No reuse for timed-out connections");
+}
+
+// P.5 超时不阻塞连接池（并发正常请求不受影响）
+- (void)testTimeout_NonBlocking_ConcurrentNormalRequestSucceeds {
+    [self.client resetPoolStatistics];
+
+    XCTestExpectation *timeoutExpectation = [self expectationWithDescription:@"Timeout request"];
+    XCTestExpectation *successExpectation = [self expectationWithDescription:@"Success request"];
+
+    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
+
+    // 请求 A：超时（delay 10s, timeout 2s）
+    dispatch_async(queue, ^{
+        NSError *error = nil;
+        HttpdnsNWHTTPClientResponse *response = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/delay/10"
+                                                                                userAgent:@"TimeoutRequest"
+                                                                                  timeout:2.0
+                                                                                    error:&error];
+        XCTAssertNil(response, @"Request A should timeout");
+        [timeoutExpectation fulfill];
+    });
+
+    // 请求 B：正常（应该不受 A 阻塞）
+    dispatch_async(queue, ^{
+        // 稍微延迟，确保 A 先开始
+        [NSThread sleepForTimeInterval:0.1];
+
+        CFAbsoluteTime startTime = CFAbsoluteTimeGetCurrent();
+        NSError *error = nil;
+        HttpdnsNWHTTPClientResponse *response = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                                                                userAgent:@"NormalRequest"
+                                                                                  timeout:15.0
+                                                                                    error:&error];
+        CFAbsoluteTime elapsed = CFAbsoluteTimeGetCurrent() - startTime;
+
+        XCTAssertNotNil(response, @"Request B should succeed despite A timing out");
+        XCTAssertEqual(response.statusCode, 200);
+
+        // 验证请求 B 没有被请求 A 阻塞（应该很快完成）
+        XCTAssertLessThan(elapsed, 5.0,
+                          @"Request B should complete quickly, not blocked by A's timeout");
+
+        [successExpectation fulfill];
+    });
+
+    [self waitForExpectations:@[timeoutExpectation, successExpectation] timeout:20.0];
+
+    // 等待连接归还
+    [NSThread sleepForTimeInterval:0.5];
+
+    // 验证池状态：只有请求 B 的连接
+    NSString *poolKey = @"127.0.0.1:11080:tcp";
+    XCTAssertEqual([self.client connectionPoolCountForKey:poolKey], 1,
+                   @"Pool should have 1 connection from successful request B");
+}
+
+// P.6 多端口场景下的超时隔离
+- (void)testTimeout_MultiPort_IsolatedPoolCleaning {
+    [self.client resetPoolStatistics];
+
+    NSString *poolKey11443 = @"127.0.0.1:11443:tls";
+    NSString *poolKey11444 = @"127.0.0.1:11444:tls";
+
+    // 端口 11443：超时请求
+    NSError *error1 = nil;
+    HttpdnsNWHTTPClientResponse *response1 = [self.client performRequestWithURLString:@"https://127.0.0.1:11443/delay/10"
+                                                                             userAgent:@"Port11443Timeout"
+                                                                               timeout:1.0
+                                                                                 error:&error1];
+    XCTAssertNil(response1, @"Port 11443 request should timeout");
+
+    // 端口 11444：正常请求
+    NSError *error2 = nil;
+    HttpdnsNWHTTPClientResponse *response2 = [self.client performRequestWithURLString:@"https://127.0.0.1:11444/get"
+                                                                             userAgent:@"Port11444Success"
+                                                                               timeout:15.0
+                                                                                 error:&error2];
+    XCTAssertNotNil(response2, @"Port 11444 request should succeed");
+    XCTAssertEqual(response2.statusCode, 200);
+
+    // 等待连接归还
+    [NSThread sleepForTimeInterval:0.5];
+
+    // 验证端口隔离：端口 11443 无连接，端口 11444 有 1 个连接
+    XCTAssertEqual([self.client connectionPoolCountForKey:poolKey11443], 0,
+                   @"Port 11443 pool should be empty (timed out)");
+    XCTAssertEqual([self.client connectionPoolCountForKey:poolKey11444], 1,
+                   @"Port 11444 pool should have 1 connection");
+
+    // 验证总连接数
+    XCTAssertEqual([self.client totalConnectionCount], 1,
+                   @"Total should be 1 (only from port 11444)");
+
+    // 再次请求端口 11444：应该复用连接
+    NSError *error3 = nil;
+    HttpdnsNWHTTPClientResponse *response3 = [self.client performRequestWithURLString:@"https://127.0.0.1:11444/get"
+                                                                             userAgent:@"Port11444Reuse"
+                                                                               timeout:15.0
+                                                                                 error:&error3];
+    XCTAssertNotNil(response3);
+    XCTAssertEqual(response3.statusCode, 200);
+
+    // 验证复用发生
+    XCTAssertEqual(self.client.connectionReuseCount, 1,
+                   @"Second request to port 11444 should reuse connection");
+}
+
+#pragma mark - R. Connection 头部处理测试
+
+// R.1 Connection: close 导致连接被立即失效
+- (void)testConnectionHeader_Close_ConnectionInvalidated {
+    [self.client resetPoolStatistics];
+    NSString *poolKey = @"127.0.0.1:11080:tcp";
+
+    // 请求 1：服务器返回 Connection: close
+    NSError *error1 = nil;
+    HttpdnsNWHTTPClientResponse *response1 = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/connection-test?mode=close"
+                                                                            userAgent:@"CloseTest"
+                                                                              timeout:15.0
+                                                                                error:&error1];
+    XCTAssertNotNil(response1, @"Request with Connection: close should succeed");
+    XCTAssertEqual(response1.statusCode, 200);
+
+    // 等待异步 returnConnection 完成
+    [NSThread sleepForTimeInterval:0.5];
+
+    // 验证：连接不在池中（已失效）
+    XCTAssertEqual([self.client connectionPoolCountForKey:poolKey], 0,
+                   @"Connection with 'Connection: close' header should be invalidated and not returned to pool");
+
+    // 请求 2：应该创建新连接（第一个连接已失效）
+    NSError *error2 = nil;
+    HttpdnsNWHTTPClientResponse *response2 = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/connection-test?mode=keep-alive"
+                                                                            userAgent:@"KeepAliveTest"
+                                                                              timeout:15.0
+                                                                                error:&error2];
+    XCTAssertNotNil(response2);
+    XCTAssertEqual(response2.statusCode, 200);
+
+    // 验证统计：创建了 2 个连接（第一个被 close，第二个正常）
+    XCTAssertEqual(self.client.connectionCreationCount, 2,
+                   @"Should have created 2 connections (first closed by server)");
+    XCTAssertEqual(self.client.connectionReuseCount, 0,
+                   @"No reuse after Connection: close");
+}
+
+// R.2 Connection: keep-alive 允许连接复用
+- (void)testConnectionHeader_KeepAlive_ConnectionReused {
+    [self.client resetPoolStatistics];
+    NSString *poolKey = @"127.0.0.1:11080:tcp";
+
+    // 请求 1：服务器返回 Connection: keep-alive
+    NSError *error1 = nil;
+    HttpdnsNWHTTPClientResponse *response1 = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/connection-test?mode=keep-alive"
+                                                                            userAgent:@"KeepAlive1"
+                                                                              timeout:15.0
+                                                                                error:&error1];
+    XCTAssertNotNil(response1);
+    XCTAssertEqual(response1.statusCode, 200);
+
+    // 等待连接归还
+    [NSThread sleepForTimeInterval:0.5];
+
+    // 验证：连接在池中
+    XCTAssertEqual([self.client connectionPoolCountForKey:poolKey], 1,
+                   @"Connection with 'Connection: keep-alive' should be returned to pool");
+
+    // 请求 2：应该复用第一个连接
+    NSError *error2 = nil;
+    HttpdnsNWHTTPClientResponse *response2 = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/connection-test?mode=keep-alive"
+                                                                            userAgent:@"KeepAlive2"
+                                                                              timeout:15.0
+                                                                                error:&error2];
+    XCTAssertNotNil(response2);
+    XCTAssertEqual(response2.statusCode, 200);
+
+    // 验证统计：只创建了 1 个连接，第二个请求复用了它
+    XCTAssertEqual(self.client.connectionCreationCount, 1,
+                   @"Should have created only 1 connection");
+    XCTAssertEqual(self.client.connectionReuseCount, 1,
+                   @"Second request should reuse the first connection");
+}
+
+// R.3 Proxy-Connection: close 也会导致连接失效
+- (void)testConnectionHeader_ProxyClose_ConnectionInvalidated {
+    [self.client resetPoolStatistics];
+    NSString *poolKey = @"127.0.0.1:11080:tcp";
+
+    // 请求 1：服务器返回 Proxy-Connection: close (+ Connection: keep-alive)
+    NSError *error1 = nil;
+    HttpdnsNWHTTPClientResponse *response1 = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/connection-test?mode=proxy-close"
+                                                                            userAgent:@"ProxyCloseTest"
+                                                                              timeout:15.0
+                                                                                error:&error1];
+    XCTAssertNotNil(response1, @"Request with Proxy-Connection: close should succeed");
+    XCTAssertEqual(response1.statusCode, 200);
+
+    // 等待异步 returnConnection 完成
+    [NSThread sleepForTimeInterval:0.5];
+
+    // 验证：连接不在池中（Proxy-Connection: close 应该失效连接）
+    XCTAssertEqual([self.client connectionPoolCountForKey:poolKey], 0,
+                   @"Connection with 'Proxy-Connection: close' header should be invalidated");
+
+    // 请求 2：应该创建新连接
+    NSError *error2 = nil;
+    HttpdnsNWHTTPClientResponse *response2 = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/connection-test?mode=keep-alive"
+                                                                            userAgent:@"RecoveryTest"
+                                                                              timeout:15.0
+                                                                                error:&error2];
+    XCTAssertNotNil(response2);
+    XCTAssertEqual(response2.statusCode, 200);
+
+    // 验证统计：创建了 2 个连接
+    XCTAssertEqual(self.client.connectionCreationCount, 2,
+                   @"Should have created 2 connections (first closed by proxy header)");
+    XCTAssertEqual(self.client.connectionReuseCount, 0,
+                   @"No reuse after Proxy-Connection: close");
+}
+
+// R.4 Connection 头部大小写不敏感
+- (void)testConnectionHeader_CaseInsensitive_AllVariantsWork {
+    [self.client resetPoolStatistics];
+    NSString *poolKey = @"127.0.0.1:11080:tcp";
+
+    // 测试 1：CONNECTION: CLOSE (全大写)
+    NSError *error1 = nil;
+    HttpdnsNWHTTPClientResponse *response1 = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/connection-test?mode=close-uppercase"
+                                                                            userAgent:@"UppercaseTest"
+                                                                              timeout:15.0
+                                                                                error:&error1];
+    XCTAssertNotNil(response1);
+    XCTAssertEqual(response1.statusCode, 200);
+
+    [NSThread sleepForTimeInterval:0.5];
+
+    // 验证：连接不在池中（大写 CLOSE 也应生效）
+    XCTAssertEqual([self.client connectionPoolCountForKey:poolKey], 0,
+                   @"'CONNECTION: CLOSE' (uppercase) should also close connection");
+
+    // 测试 2：Connection: Close (混合大小写)
+    NSError *error2 = nil;
+    HttpdnsNWHTTPClientResponse *response2 = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/connection-test?mode=close-mixed"
+                                                                            userAgent:@"MixedCaseTest"
+                                                                              timeout:15.0
+                                                                                error:&error2];
+    XCTAssertNotNil(response2);
+    XCTAssertEqual(response2.statusCode, 200);
+
+    [NSThread sleepForTimeInterval:0.5];
+
+    // 验证：连接不在池中（混合大小写也应生效）
+    XCTAssertEqual([self.client connectionPoolCountForKey:poolKey], 0,
+                   @"'Connection: Close' (mixed case) should also close connection");
+
+    // 验证统计：创建了 2 个连接，都被 close
+    XCTAssertEqual(self.client.connectionCreationCount, 2,
+                   @"Should have created 2 connections (both closed due to case-insensitive matching)");
+    XCTAssertEqual(self.client.connectionReuseCount, 0,
+                   @"No reuse for any closed connections");
+}
+
+// R.5 并发场景：混合 close 和 keep-alive
+- (void)testConnectionHeader_ConcurrentMixed_CloseAndKeepAliveIsolated {
+    [self.client resetPoolStatistics];
+    NSString *poolKey = @"127.0.0.1:11080:tcp";
+
+    NSMutableArray<XCTestExpectation *> *expectations = [NSMutableArray array];
+    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
+
+    NSLock *closeCountLock = [[NSLock alloc] init];
+    NSLock *keepAliveCountLock = [[NSLock alloc] init];
+    __block NSInteger closeCount = 0;
+    __block NSInteger keepAliveCount = 0;
+
+    // 发起 10 个请求：5 个 close，5 个 keep-alive
+    for (NSInteger i = 0; i < 10; i++) {
+        XCTestExpectation *expectation = [self expectationWithDescription:[NSString stringWithFormat:@"Request %ld", (long)i]];
+        [expectations addObject:expectation];
+
+        dispatch_async(queue, ^{
+            NSError *error = nil;
+            NSString *urlString;
+
+            if (i % 2 == 0) {
+                // 偶数：close
+                urlString = @"http://127.0.0.1:11080/connection-test?mode=close";
+            } else {
+                // 奇数：keep-alive
+                urlString = @"http://127.0.0.1:11080/connection-test?mode=keep-alive";
+            }
+
+            HttpdnsNWHTTPClientResponse *response = [self.client performRequestWithURLString:urlString
+                                                                                    userAgent:@"ConcurrentMixed"
+                                                                                      timeout:15.0
+                                                                                        error:&error];
+
+            if (response && response.statusCode == 200) {
+                if (i % 2 == 0) {
+                    [closeCountLock lock];
+                    closeCount++;
+                    [closeCountLock unlock];
+                } else {
+                    [keepAliveCountLock lock];
+                    keepAliveCount++;
+                    [keepAliveCountLock unlock];
+                }
+            }
+
+            [expectation fulfill];
+        });
+    }
+
+    [self waitForExpectations:expectations timeout:30.0];
+
+    // 验证结果
+    XCTAssertEqual(closeCount, 5, @"5 close requests should succeed");
+    XCTAssertEqual(keepAliveCount, 5, @"5 keep-alive requests should succeed");
+
+    // 等待所有连接归还
+    [NSThread sleepForTimeInterval:1.0];
+
+    // 验证池状态：
+    // - close 连接全部被失效（不在池中）
+    // - keep-alive 连接可能在池中（取决于并发时序和 remote close）
+    // - 关键是：总数不超过 4（池限制），无泄漏
+    NSInteger poolSize = [self.client connectionPoolCountForKey:poolKey];
+    XCTAssertLessThanOrEqual(poolSize, 4,
+                             @"Pool size should not exceed limit (no leak from close connections)");
+
+    // 验证统计：close 连接不应该被复用
+    // 创建数应该 >= 6 (至少 5 个 close + 1 个 keep-alive，因为 close 不能复用)
+    XCTAssertGreaterThanOrEqual(self.client.connectionCreationCount, 6,
+                                @"Should have created at least 6 connections (5 close + at least 1 keep-alive)");
+
+    // 后续请求验证池仍然健康
+    NSError *recoveryError = nil;
+    HttpdnsNWHTTPClientResponse *recoveryResponse = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                                                                    userAgent:@"RecoveryTest"
+                                                                                      timeout:15.0
+                                                                                        error:&recoveryError];
+    XCTAssertNotNil(recoveryResponse, @"Pool should still be healthy after mixed close/keep-alive scenario");
+    XCTAssertEqual(recoveryResponse.statusCode, 200);
+}
+
+@end

EdgeHttpDNS/sdk/ios/AlicloudHttpDNSTests/Network/HttpdnsNWHTTPClient_PoolManagementTests.m

@@ -0,0 +1,774 @@
+//
+//  HttpdnsNWHTTPClient_PoolManagementTests.m
+//  AlicloudHttpDNSTests
+//
+//  @author Created by Claude Code on 2025-11-01
+//  Copyright © 2025 alibaba-inc.com. All rights reserved.
+//
+//  连接池管理测试 - 包含多端口隔离 (K)、端口池耗尽 (L)、池验证 (O)、空闲超时 (S) 测试组
+//  测试总数：16 个（K:5 + L:3 + O:3 + S:5）
+//
+
+#import "HttpdnsNWHTTPClientTestBase.h"
+
+@interface HttpdnsNWHTTPClient_PoolManagementTests : HttpdnsNWHTTPClientTestBase
+
+@end
+
+@implementation HttpdnsNWHTTPClient_PoolManagementTests
+
+#pragma mark - K. 多端口连接隔离测试
+
+// K.1 不同 HTTPS 端口使用不同连接池
+- (void)testMultiPort_DifferentHTTPSPorts_SeparatePoolKeys {
+    XCTestExpectation *expectation = [self expectationWithDescription:@"Different ports use different pools"];
+
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+        // 请求端口 11443
+        NSError *error1 = nil;
+        HttpdnsNWHTTPClientResponse *response1 = [self.client performRequestWithURLString:@"https://127.0.0.1:11443/get"
+                                                                                 userAgent:@"Port11443"
+                                                                                   timeout:15.0
+                                                                                     error:&error1];
+        XCTAssertNotNil(response1, @"First request to port 11443 should succeed");
+        XCTAssertEqual(response1.statusCode, 200);
+
+        // 请求端口 11444（应该创建新连接，不复用 11443 的）
+        NSError *error2 = nil;
+        HttpdnsNWHTTPClientResponse *response2 = [self.client performRequestWithURLString:@"https://127.0.0.1:11444/get"
+                                                                                 userAgent:@"Port11444"
+                                                                                   timeout:15.0
+                                                                                     error:&error2];
+        XCTAssertNotNil(response2, @"First request to port 11444 should succeed");
+        XCTAssertEqual(response2.statusCode, 200);
+
+        // 再次请求端口 11443（应该复用之前的连接）
+        NSError *error3 = nil;
+        HttpdnsNWHTTPClientResponse *response3 = [self.client performRequestWithURLString:@"https://127.0.0.1:11443/get"
+                                                                                 userAgent:@"Port11443Again"
+                                                                                   timeout:15.0
+                                                                                     error:&error3];
+        XCTAssertNotNil(response3, @"Second request to port 11443 should reuse connection");
+        XCTAssertEqual(response3.statusCode, 200);
+
+        [expectation fulfill];
+    });
+
+    [self waitForExpectations:@[expectation] timeout:50.0];
+}
+
+// K.2 三个不同 HTTPS 端口的并发请求
+- (void)testMultiPort_ConcurrentThreePorts_AllSucceed {
+    NSInteger requestsPerPort = 10;
+    NSArray<NSNumber *> *ports = @[@11443, @11444, @11445];
+    NSMutableArray<XCTestExpectation *> *expectations = [NSMutableArray array];
+    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
+
+    NSLock *successCountLock = [[NSLock alloc] init];
+    __block NSInteger successCount = 0;
+
+    for (NSNumber *port in ports) {
+        for (NSInteger i = 0; i < requestsPerPort; i++) {
+            XCTestExpectation *expectation = [self expectationWithDescription:[NSString stringWithFormat:@"Port %@ Request %ld", port, (long)i]];
+            [expectations addObject:expectation];
+
+            dispatch_async(queue, ^{
+                NSString *urlString = [NSString stringWithFormat:@"https://127.0.0.1:%@/get", port];
+                NSError *error = nil;
+                HttpdnsNWHTTPClientResponse *response = [self.client performRequestWithURLString:urlString
+                                                                                        userAgent:@"ConcurrentMultiPort"
+                                                                                          timeout:15.0
+                                                                                            error:&error];
+
+                if (response && response.statusCode == 200) {
+                    [successCountLock lock];
+                    successCount++;
+                    [successCountLock unlock];
+                }
+
+                [expectation fulfill];
+            });
+        }
+    }
+
+    [self waitForExpectations:expectations timeout:60.0];
+
+    // 验证所有请求都成功
+    XCTAssertEqual(successCount, ports.count * requestsPerPort, @"All 30 requests should succeed");
+}
+
+// K.3 快速切换端口模式
+- (void)testMultiPort_SequentialPortSwitching_ConnectionReusePerPort {
+    XCTestExpectation *expectation = [self expectationWithDescription:@"Sequential port switching"];
+
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+        NSArray<NSString *> *urls = @[
+            @"https://127.0.0.1:11443/get",  // 第一次访问 11443
+            @"https://127.0.0.1:11444/get",  // 第一次访问 11444
+            @"https://127.0.0.1:11445/get",  // 第一次访问 11445
+            @"https://127.0.0.1:11443/get",  // 第二次访问 11443（应复用）
+            @"https://127.0.0.1:11444/get",  // 第二次访问 11444（应复用）
+        ];
+
+        NSMutableArray<NSNumber *> *responseTimes = [NSMutableArray array];
+
+        for (NSString *url in urls) {
+            CFAbsoluteTime startTime = CFAbsoluteTimeGetCurrent();
+            NSError *error = nil;
+            HttpdnsNWHTTPClientResponse *response = [self.client performRequestWithURLString:url
+                                                                                    userAgent:@"SwitchingPorts"
+                                                                                      timeout:15.0
+                                                                                        error:&error];
+            CFAbsoluteTime elapsed = CFAbsoluteTimeGetCurrent() - startTime;
+
+            XCTAssertNotNil(response, @"Request to %@ should succeed", url);
+            XCTAssertEqual(response.statusCode, 200);
+            [responseTimes addObject:@(elapsed)];
+        }
+
+        // 验证所有请求都完成
+        XCTAssertEqual(responseTimes.count, urls.count);
+
+        [expectation fulfill];
+    });
+
+    [self waitForExpectations:@[expectation] timeout:80.0];
+}
+
+// K.4 每个端口独立的连接池限制
+- (void)testMultiPort_PerPortPoolLimit_IndependentPools {
+    XCTestExpectation *expectation = [self expectationWithDescription:@"Per-port pool limits"];
+
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+        // 向端口 11443 发送 10 个请求
+        for (NSInteger i = 0; i < 10; i++) {
+            NSError *error = nil;
+            HttpdnsNWHTTPClientResponse *response = [self.client performRequestWithURLString:@"https://127.0.0.1:11443/get"
+                                                                                    userAgent:@"Pool11443"
+                                                                                      timeout:15.0
+                                                                                        error:&error];
+            XCTAssertTrue(response != nil || error != nil);
+        }
+
+        // 向端口 11444 发送 10 个请求（应该有独立的池）
+        for (NSInteger i = 0; i < 10; i++) {
+            NSError *error = nil;
+            HttpdnsNWHTTPClientResponse *response = [self.client performRequestWithURLString:@"https://127.0.0.1:11444/get"
+                                                                                    userAgent:@"Pool11444"
+                                                                                      timeout:15.0
+                                                                                        error:&error];
+            XCTAssertTrue(response != nil || error != nil);
+        }
+
+        // 等待连接归还
+        [NSThread sleepForTimeInterval:1.0];
+
+        // 验证两个端口都仍然可用
+        NSError *error1 = nil;
+        HttpdnsNWHTTPClientResponse *response1 = [self.client performRequestWithURLString:@"https://127.0.0.1:11443/get"
+                                                                                 userAgent:@"Verify11443"
+                                                                                   timeout:15.0
+                                                                                     error:&error1];
+        XCTAssertNotNil(response1, @"Port 11443 should still work after heavy usage");
+
+        NSError *error2 = nil;
+        HttpdnsNWHTTPClientResponse *response2 = [self.client performRequestWithURLString:@"https://127.0.0.1:11444/get"
+                                                                                 userAgent:@"Verify11444"
+                                                                                   timeout:15.0
+                                                                                     error:&error2];
+        XCTAssertNotNil(response2, @"Port 11444 should still work after heavy usage");
+
+        [expectation fulfill];
+    });
+
+    [self waitForExpectations:@[expectation] timeout:150.0];
+}
+
+// K.5 交错访问多个端口
+- (void)testMultiPort_InterleavedRequests_AllPortsAccessible {
+    XCTestExpectation *expectation = [self expectationWithDescription:@"Interleaved multi-port requests"];
+
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+        NSArray<NSNumber *> *ports = @[@11443, @11444, @11445, @11446];
+        NSInteger totalRequests = 20;
+        NSInteger successCount = 0;
+
+        // 交错请求：依次循环访问所有端口
+        for (NSInteger i = 0; i < totalRequests; i++) {
+            NSNumber *port = ports[i % ports.count];
+            NSString *urlString = [NSString stringWithFormat:@"https://127.0.0.1:%@/get", port];
+
+            NSError *error = nil;
+            HttpdnsNWHTTPClientResponse *response = [self.client performRequestWithURLString:urlString
+                                                                                    userAgent:@"Interleaved"
+                                                                                      timeout:15.0
+                                                                                        error:&error];
+
+            if (response && response.statusCode == 200) {
+                successCount++;
+            }
+        }
+
+        XCTAssertEqual(successCount, totalRequests, @"All interleaved requests should succeed");
+
+        [expectation fulfill];
+    });
+
+    [self waitForExpectations:@[expectation] timeout:120.0];
+}
+
+#pragma mark - L. 基于端口的池耗尽测试
+
+// L.1 四个端口同时承载高负载
+- (void)testPoolExhaustion_FourPortsSimultaneous_AllSucceed {
+    NSInteger requestsPerPort = 10;
+    NSArray<NSNumber *> *ports = @[@11443, @11444, @11445, @11446];
+    NSMutableArray<XCTestExpectation *> *expectations = [NSMutableArray array];
+    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
+
+    NSLock *successCountLock = [[NSLock alloc] init];
+    __block NSInteger successCount = 0;
+
+    // 向 4 个端口各发起 10 个并发请求（共 40 个）
+    for (NSNumber *port in ports) {
+        for (NSInteger i = 0; i < requestsPerPort; i++) {
+            XCTestExpectation *expectation = [self expectationWithDescription:[NSString stringWithFormat:@"Port %@ Request %ld", port, (long)i]];
+            [expectations addObject:expectation];
+
+            dispatch_async(queue, ^{
+                NSString *urlString = [NSString stringWithFormat:@"https://127.0.0.1:%@/get", port];
+                NSError *error = nil;
+                HttpdnsNWHTTPClientResponse *response = [self.client performRequestWithURLString:urlString
+                                                                                        userAgent:@"FourPortLoad"
+                                                                                          timeout:15.0
+                                                                                            error:&error];
+
+                if (response && response.statusCode == 200) {
+                    [successCountLock lock];
+                    successCount++;
+                    [successCountLock unlock];
+                }
+
+                [expectation fulfill];
+            });
+        }
+    }
+
+    [self waitForExpectations:expectations timeout:80.0];
+
+    // 验证成功率 > 95%（允许少量因并发导致的失败）
+    XCTAssertGreaterThan(successCount, 38, @"At least 95%% of 40 requests should succeed");
+}
+
+// L.2 单个端口耗尽时其他端口不受影响
+- (void)testPoolExhaustion_SinglePortExhausted_OthersUnaffected {
+    NSMutableArray<XCTestExpectation *> *expectations = [NSMutableArray array];
+    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
+
+    __block NSInteger port11444SuccessCount = 0;
+    NSLock *countLock = [[NSLock alloc] init];
+
+    // 向端口 11443 发起 20 个并发请求（可能导致池耗尽）
+    for (NSInteger i = 0; i < 20; i++) {
+        XCTestExpectation *expectation = [self expectationWithDescription:[NSString stringWithFormat:@"Exhaust11443 %ld", (long)i]];
+        [expectations addObject:expectation];
+
+        dispatch_async(queue, ^{
+            NSError *error = nil;
+            [self.client performRequestWithURLString:@"https://127.0.0.1:11443/get"
+                                            userAgent:@"Exhaust11443"
+                                              timeout:15.0
+                                                error:&error];
+            [expectation fulfill];
+        });
+    }
+
+    // 同时向端口 11444 发起 5 个请求（应该不受 11443 影响）
+    for (NSInteger i = 0; i < 5; i++) {
+        XCTestExpectation *expectation = [self expectationWithDescription:[NSString stringWithFormat:@"Port11444 %ld", (long)i]];
+        [expectations addObject:expectation];
+
+        dispatch_async(queue, ^{
+            CFAbsoluteTime startTime = CFAbsoluteTimeGetCurrent();
+            NSError *error = nil;
+            HttpdnsNWHTTPClientResponse *response = [self.client performRequestWithURLString:@"https://127.0.0.1:11444/get"
+                                                                                    userAgent:@"Independent11444"
+                                                                                      timeout:15.0
+                                                                                        error:&error];
+            CFAbsoluteTime elapsed = CFAbsoluteTimeGetCurrent() - startTime;
+
+            if (response && response.statusCode == 200) {
+                [countLock lock];
+                port11444SuccessCount++;
+                [countLock unlock];
+            }
+
+            // 验证响应时间合理（不应因 11443 负载而显著延迟）
+            XCTAssertLessThan(elapsed, 10.0, @"Port 11444 should not be delayed by port 11443 load");
+
+            [expectation fulfill];
+        });
+    }
+
+    [self waitForExpectations:expectations timeout:60.0];
+
+    // 验证端口 11444 的请求都成功
+    XCTAssertEqual(port11444SuccessCount, 5, @"All port 11444 requests should succeed despite 11443 load");
+}
+
+// L.3 多端口使用后的连接清理
+- (void)testPoolExhaustion_MultiPortCleanup_ExpiredConnectionsPruned {
+    if (getenv("SKIP_SLOW_TESTS")) {
+        return;
+    }
+
+    XCTestExpectation *expectation = [self expectationWithDescription:@"Multi-port connection cleanup"];
+
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+        NSArray<NSNumber *> *ports = @[@11443, @11444, @11445];
+
+        // 向三个端口各发起一个请求
+        for (NSNumber *port in ports) {
+            NSString *urlString = [NSString stringWithFormat:@"https://127.0.0.1:%@/get", port];
+            NSError *error = nil;
+            HttpdnsNWHTTPClientResponse *response = [self.client performRequestWithURLString:urlString
+                                                                                    userAgent:@"Initial"
+                                                                                      timeout:15.0
+                                                                                        error:&error];
+            XCTAssertTrue(response != nil || error != nil);
+        }
+
+        // 等待超过 30 秒，让所有连接过期
+        [NSThread sleepForTimeInterval:31.0];
+
+        // 再次向三个端口发起请求（应该创建新连接）
+        for (NSNumber *port in ports) {
+            NSString *urlString = [NSString stringWithFormat:@"https://127.0.0.1:%@/get", port];
+            NSError *error = nil;
+            HttpdnsNWHTTPClientResponse *response = [self.client performRequestWithURLString:urlString
+                                                                                    userAgent:@"AfterExpiry"
+                                                                                      timeout:15.0
+                                                                                        error:&error];
+            XCTAssertTrue(response != nil || error != nil, @"Requests should succeed after expiry");
+        }
+
+        [expectation fulfill];
+    });
+
+    [self waitForExpectations:@[expectation] timeout:80.0];
+}
+
+#pragma mark - O. 连接池验证测试（使用新增的检查 API）
+
+// O.1 综合连接池验证 - 演示所有检查能力
+- (void)testPoolVerification_ComprehensiveCheck_AllAspectsVerified {
+    [self.client resetPoolStatistics];
+    NSString *poolKey = @"127.0.0.1:11080:tcp";
+
+    // 初始状态：无连接
+    XCTAssertEqual([self.client connectionPoolCountForKey:poolKey], 0,
+                   @"Pool should be empty initially");
+    XCTAssertEqual([self.client totalConnectionCount], 0,
+                   @"Total connections should be 0 initially");
+    XCTAssertEqual(self.client.connectionCreationCount, 0,
+                   @"Creation count should be 0 initially");
+    XCTAssertEqual(self.client.connectionReuseCount, 0,
+                   @"Reuse count should be 0 initially");
+
+    // 发送 5 个请求到同一端点
+    for (NSInteger i = 0; i < 5; i++) {
+        NSError *error = nil;
+        HttpdnsNWHTTPClientResponse *response = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                                                                userAgent:@"PoolVerificationTest"
+                                                                                  timeout:15.0
+                                                                                    error:&error];
+        XCTAssertNotNil(response, @"Request %ld should succeed", (long)i);
+        XCTAssertEqual(response.statusCode, 200, @"Request %ld should return 200", (long)i);
+    }
+
+    // 验证连接池状态
+    XCTAssertEqual([self.client connectionPoolCountForKey:poolKey], 1,
+                   @"Should have exactly 1 connection in pool for key: %@", poolKey);
+    XCTAssertEqual([self.client totalConnectionCount], 1,
+                   @"Total connection count should be 1");
+
+    // 验证统计计数
+    XCTAssertEqual(self.client.connectionCreationCount, 1,
+                   @"Should create only 1 connection");
+    XCTAssertEqual(self.client.connectionReuseCount, 4,
+                   @"Should reuse connection 4 times");
+
+    // 验证连接复用率
+    CGFloat reuseRate = (CGFloat)self.client.connectionReuseCount /
+                        (self.client.connectionCreationCount + self.client.connectionReuseCount);
+    XCTAssertGreaterThanOrEqual(reuseRate, 0.8,
+                                @"Reuse rate should be at least 80%% (actual: %.1f%%)", reuseRate * 100);
+
+    // 验证 pool keys
+    NSArray<NSString *> *allKeys = [self.client allConnectionPoolKeys];
+    XCTAssertEqual(allKeys.count, 1, @"Should have exactly 1 pool key");
+    XCTAssertTrue([allKeys containsObject:poolKey], @"Should contain the expected pool key");
+}
+
+// O.2 多端口连接池隔离验证
+- (void)testPoolVerification_MultiPort_IndependentPools {
+    [self.client resetPoolStatistics];
+
+    NSString *key11443 = @"127.0.0.1:11443:tls";
+    NSString *key11444 = @"127.0.0.1:11444:tls";
+
+    // 初始：两个池都为空
+    XCTAssertEqual([self.client connectionPoolCountForKey:key11443], 0);
+    XCTAssertEqual([self.client connectionPoolCountForKey:key11444], 0);
+
+    // 向端口 11443 发送 3 个请求
+    for (NSInteger i = 0; i < 3; i++) {
+        NSError *error = nil;
+        HttpdnsNWHTTPClientResponse *response = [self.client performRequestWithURLString:@"https://127.0.0.1:11443/get"
+                                                                                userAgent:@"Port11443"
+                                                                                  timeout:15.0
+                                                                                    error:&error];
+        XCTAssertNotNil(response);
+    }
+
+    // 验证端口 11443 的池状态
+    XCTAssertEqual([self.client connectionPoolCountForKey:key11443], 1,
+                   @"Port 11443 should have 1 connection");
+    XCTAssertEqual([self.client connectionPoolCountForKey:key11444], 0,
+                   @"Port 11444 should still be empty");
+
+    // 向端口 11444 发送 3 个请求
+    for (NSInteger i = 0; i < 3; i++) {
+        NSError *error = nil;
+        HttpdnsNWHTTPClientResponse *response = [self.client performRequestWithURLString:@"https://127.0.0.1:11444/get"
+                                                                                userAgent:@"Port11444"
+                                                                                  timeout:15.0
+                                                                                    error:&error];
+        XCTAssertNotNil(response);
+    }
+
+    // 验证两个端口的池都存在且独立
+    XCTAssertEqual([self.client connectionPoolCountForKey:key11443], 1,
+                   @"Port 11443 should still have 1 connection");
+    XCTAssertEqual([self.client connectionPoolCountForKey:key11444], 1,
+                   @"Port 11444 should now have 1 connection");
+    XCTAssertEqual([self.client totalConnectionCount], 2,
+                   @"Total should be 2 connections (one per port)");
+
+    // 验证统计：应该创建了 2 个连接，复用了 4 次
+    XCTAssertEqual(self.client.connectionCreationCount, 2,
+                   @"Should create 2 connections (one per port)");
+    XCTAssertEqual(self.client.connectionReuseCount, 4,
+                   @"Should reuse connections 4 times total");
+
+    // 验证 pool keys
+    NSArray<NSString *> *allKeys = [self.client allConnectionPoolKeys];
+    XCTAssertEqual(allKeys.count, 2, @"Should have 2 pool keys");
+    XCTAssertTrue([allKeys containsObject:key11443], @"Should contain key for port 11443");
+    XCTAssertTrue([allKeys containsObject:key11444], @"Should contain key for port 11444");
+}
+
+// O.3 连接池容量限制验证
+- (void)testPoolVerification_PoolCapacity_MaxFourConnections {
+    [self.client resetPoolStatistics];
+    NSString *poolKey = @"127.0.0.1:11080:tcp";
+
+    // 发送 10 个连续请求（每个请求都会归还连接到池）
+    for (NSInteger i = 0; i < 10; i++) {
+        NSError *error = nil;
+        HttpdnsNWHTTPClientResponse *response = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                                                                userAgent:@"CapacityTest"
+                                                                                  timeout:15.0
+                                                                                    error:&error];
+        XCTAssertNotNil(response);
+    }
+
+    // 等待连接归还
+    [NSThread sleepForTimeInterval:1.0];
+
+    // 验证池大小不超过 4（kHttpdnsNWHTTPClientMaxIdleConnectionsPerKey）
+    NSUInteger poolSize = [self.client connectionPoolCountForKey:poolKey];
+    XCTAssertLessThanOrEqual(poolSize, 4,
+                            @"Pool size should not exceed 4 (actual: %lu)", (unsigned long)poolSize);
+
+    // 验证统计：应该只创建了 1 个连接（因为串行请求，每次都复用）
+    XCTAssertEqual(self.client.connectionCreationCount, 1,
+                   @"Should create only 1 connection for sequential requests");
+    XCTAssertEqual(self.client.connectionReuseCount, 9,
+                   @"Should reuse connection 9 times");
+}
+
+#pragma mark - S. 空闲超时详细测试
+
+// S.1 混合过期和有效连接 - 选择性清理
+- (void)testIdleTimeout_MixedExpiredValid_SelectivePruning {
+    [self.client resetPoolStatistics];
+    NSString *poolKey = @"127.0.0.1:11080:tcp";
+
+    // 创建第一个连接
+    NSError *error1 = nil;
+    HttpdnsNWHTTPClientResponse *response1 = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                                                            userAgent:@"ConnectionA"
+                                                                              timeout:15.0
+                                                                                error:&error1];
+    XCTAssertNotNil(response1);
+    XCTAssertEqual(response1.statusCode, 200);
+
+    // 等待连接归还
+    [NSThread sleepForTimeInterval:0.5];
+
+    // 使用 DEBUG API 获取连接 A 并设置为过期（35 秒前）
+    NSArray<HttpdnsNWReusableConnection *> *connections = [self.client connectionsInPoolForKey:poolKey];
+    XCTAssertEqual(connections.count, 1, @"Should have 1 connection in pool");
+
+    HttpdnsNWReusableConnection *connectionA = connections.firstObject;
+    NSDate *expiredDate = [NSDate dateWithTimeIntervalSinceNow:-35.0];
+    [connectionA debugSetLastUsedDate:expiredDate];
+
+    // 创建第二个连接（通过并发请求）
+    NSError *error2 = nil;
+    HttpdnsNWHTTPClientResponse *response2 = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                                                            userAgent:@"ConnectionB"
+                                                                              timeout:15.0
+                                                                                error:&error2];
+    XCTAssertNotNil(response2);
+
+    // 等待归还
+    [NSThread sleepForTimeInterval:0.5];
+
+    // 验证：应该有 1 个连接（connectionA 过期被移除，connectionB 留下）
+    connections = [self.client connectionsInPoolForKey:poolKey];
+    XCTAssertEqual(connections.count, 1,
+                   @"Should have only 1 connection (expired A removed, valid B kept)");
+
+    // 第三个请求应该复用 connectionB
+    [self.client resetPoolStatistics];
+    NSError *error3 = nil;
+    HttpdnsNWHTTPClientResponse *response3 = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                                                            userAgent:@"ReuseB"
+                                                                              timeout:15.0
+                                                                                error:&error3];
+    XCTAssertNotNil(response3);
+
+    // 验证：复用了 connectionB（没有创建新连接）
+    XCTAssertEqual(self.client.connectionCreationCount, 0,
+                   @"Should not create new connection (reuse existing valid connection)");
+    XCTAssertEqual(self.client.connectionReuseCount, 1,
+                   @"Should reuse the valid connection B");
+}
+
+// S.2 In-Use 保护 - 使用中的连接不会过期
+- (void)testIdleTimeout_InUseProtection_ActiveConnectionNotPruned {
+    [self.client resetPoolStatistics];
+    NSString *poolKey = @"127.0.0.1:11080:tcp";
+
+    // 创建第一个连接
+    NSError *error1 = nil;
+    HttpdnsNWHTTPClientResponse *response1 = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                                                            userAgent:@"Initial"
+                                                                              timeout:15.0
+                                                                                error:&error1];
+    XCTAssertNotNil(response1);
+
+    [NSThread sleepForTimeInterval:0.5];
+
+    // 借出连接并保持 inUse=YES
+    NSArray<HttpdnsNWReusableConnection *> *connections = [self.client connectionsInPoolForKey:poolKey];
+    XCTAssertEqual(connections.count, 1);
+
+    HttpdnsNWReusableConnection *conn = connections.firstObject;
+
+    // 手动设置为 60 秒前（远超 30 秒超时）
+    NSDate *veryOldDate = [NSDate dateWithTimeIntervalSinceNow:-60.0];
+    [conn debugSetLastUsedDate:veryOldDate];
+
+    // 将连接标记为使用中
+    [conn debugSetInUse:YES];
+
+    // 触发清理（通过发起另一个并发请求）
+    dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
+    __block NSInteger connectionsBefore = 0;
+    __block NSInteger connectionsAfter = 0;
+
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+        connectionsBefore = [self.client totalConnectionCount];
+
+        // 发起请求（会触发 pruneConnectionPool）
+        NSError *error2 = nil;
+        [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                        userAgent:@"TriggerPrune"
+                                          timeout:15.0
+                                            error:&error2];
+
+        [NSThread sleepForTimeInterval:0.5];
+        connectionsAfter = [self.client totalConnectionCount];
+
+        dispatch_semaphore_signal(semaphore);
+    });
+
+    dispatch_semaphore_wait(semaphore, dispatch_time(DISPATCH_TIME_NOW, 20 * NSEC_PER_SEC));
+
+    // 清理：重置 inUse 状态
+    [conn debugSetInUse:NO];
+
+    // 验证：inUse=YES 的连接不应该被清理
+    // connectionsBefore = 1 (旧连接), connectionsAfter = 2 (旧连接 + 新连接)
+    XCTAssertEqual(connectionsBefore, 1,
+                   @"Should have 1 connection before (in-use protected)");
+    XCTAssertEqual(connectionsAfter, 2,
+                   @"Should have 2 connections after (in-use connection NOT pruned, new connection added)");
+}
+
+// S.3 所有连接过期 - 批量清理
+- (void)testIdleTimeout_AllExpired_BulkPruning {
+    [self.client resetPoolStatistics];
+    NSString *poolKey = @"127.0.0.1:11080:tcp";
+
+    // 创建 4 个连接（填满池）
+    NSMutableArray<XCTestExpectation *> *expectations = [NSMutableArray array];
+    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
+
+    for (NSInteger i = 0; i < 4; i++) {
+        XCTestExpectation *expectation = [self expectationWithDescription:[NSString stringWithFormat:@"Request %ld", (long)i]];
+        [expectations addObject:expectation];
+
+        dispatch_async(queue, ^{
+            NSError *error = nil;
+            HttpdnsNWHTTPClientResponse *response = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                                                                    userAgent:@"FillPool"
+                                                                                      timeout:15.0
+                                                                                        error:&error];
+            XCTAssertNotNil(response);
+            [expectation fulfill];
+        });
+    }
+
+    [self waitForExpectations:expectations timeout:30.0];
+
+    // 等待所有连接归还
+    [NSThread sleepForTimeInterval:1.0];
+
+    // 验证池已满
+    NSUInteger poolSizeBefore = [self.client connectionPoolCountForKey:poolKey];
+    XCTAssertGreaterThan(poolSizeBefore, 0, @"Pool should have connections");
+
+    // 将所有连接设置为过期（31 秒前）
+    NSArray<HttpdnsNWReusableConnection *> *connections = [self.client connectionsInPoolForKey:poolKey];
+    NSDate *expiredDate = [NSDate dateWithTimeIntervalSinceNow:-31.0];
+    for (HttpdnsNWReusableConnection *conn in connections) {
+        [conn debugSetLastUsedDate:expiredDate];
+    }
+
+    // 发起新请求（触发批量清理）
+    NSError *errorNew = nil;
+    HttpdnsNWHTTPClientResponse *responseNew = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                                                               userAgent:@"AfterBulkExpiry"
+                                                                                 timeout:15.0
+                                                                                   error:&errorNew];
+    XCTAssertNotNil(responseNew, @"Request should succeed after bulk pruning");
+    XCTAssertEqual(responseNew.statusCode, 200);
+
+    // 等待归还
+    [NSThread sleepForTimeInterval:0.5];
+
+    // 验证：池中只有新连接（所有旧连接被清理）
+    NSUInteger poolSizeAfter = [self.client connectionPoolCountForKey:poolKey];
+    XCTAssertEqual(poolSizeAfter, 1,
+                   @"Pool should have only 1 connection (new one after bulk pruning)");
+}
+
+// S.4 过期后池状态验证
+- (void)testIdleTimeout_PoolStateAfterExpiry_DirectVerification {
+    [self.client resetPoolStatistics];
+    NSString *poolKey = @"127.0.0.1:11080:tcp";
+
+    // 创建连接
+    NSError *error1 = nil;
+    HttpdnsNWHTTPClientResponse *response1 = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                                                            userAgent:@"CreateConnection"
+                                                                              timeout:15.0
+                                                                                error:&error1];
+    XCTAssertNotNil(response1);
+
+    [NSThread sleepForTimeInterval:0.5];
+
+    // 验证连接在池中
+    XCTAssertEqual([self.client connectionPoolCountForKey:poolKey], 1,
+                   @"Pool should have 1 connection");
+
+    // 设置连接为过期
+    NSArray<HttpdnsNWReusableConnection *> *connections = [self.client connectionsInPoolForKey:poolKey];
+    HttpdnsNWReusableConnection *conn = connections.firstObject;
+    [conn debugSetLastUsedDate:[NSDate dateWithTimeIntervalSinceNow:-31.0]];
+
+    // 发起请求（触发清理）
+    NSError *error2 = nil;
+    HttpdnsNWHTTPClientResponse *response2 = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                                                            userAgent:@"TriggerPrune"
+                                                                              timeout:15.0
+                                                                                error:&error2];
+    XCTAssertNotNil(response2);
+
+    [NSThread sleepForTimeInterval:0.5];
+
+    // 直接验证池状态：过期连接已被移除，新连接已加入
+    NSUInteger poolSizeAfter = [self.client connectionPoolCountForKey:poolKey];
+    XCTAssertEqual(poolSizeAfter, 1,
+                   @"Pool should have 1 connection (expired removed, new added)");
+
+    // 验证统计：创建了新连接（旧连接过期不可复用）
+    XCTAssertGreaterThanOrEqual(self.client.connectionCreationCount, 1,
+                                @"Should have created at least 1 new connection");
+}
+
+// S.5 快速过期测试（无需等待）- 演示最佳实践
+- (void)testIdleTimeout_FastExpiry_NoWaiting {
+    [self.client resetPoolStatistics];
+    NSString *poolKey = @"127.0.0.1:11080:tcp";
+
+    CFAbsoluteTime startTime = CFAbsoluteTimeGetCurrent();
+
+    // 第一个请求：创建连接
+    NSError *error1 = nil;
+    HttpdnsNWHTTPClientResponse *response1 = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                                                            userAgent:@"FastTest1"
+                                                                              timeout:15.0
+                                                                                error:&error1];
+    XCTAssertNotNil(response1);
+    XCTAssertEqual(response1.statusCode, 200);
+    XCTAssertEqual(self.client.connectionCreationCount, 1, @"Should create 1 connection");
+
+    [NSThread sleepForTimeInterval:0.5];
+
+    // 使用 DEBUG 辅助函数模拟 31 秒过期（无需实际等待）
+    NSArray<HttpdnsNWReusableConnection *> *connections = [self.client connectionsInPoolForKey:poolKey];
+    XCTAssertEqual(connections.count, 1);
+
+    HttpdnsNWReusableConnection *conn = connections.firstObject;
+    NSDate *expiredDate = [NSDate dateWithTimeIntervalSinceNow:-31.0];
+    [conn debugSetLastUsedDate:expiredDate];
+
+    // 第二个请求：应该检测到过期并创建新连接
+    [self.client resetPoolStatistics];
+    NSError *error2 = nil;
+    HttpdnsNWHTTPClientResponse *response2 = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                                                            userAgent:@"FastTest2"
+                                                                              timeout:15.0
+                                                                                error:&error2];
+    XCTAssertNotNil(response2);
+    XCTAssertEqual(response2.statusCode, 200);
+
+    // 验证：创建了新连接（而非复用过期的）
+    XCTAssertEqual(self.client.connectionCreationCount, 1,
+                   @"Should create new connection (expired connection not reused)");
+    XCTAssertEqual(self.client.connectionReuseCount, 0,
+                   @"Should not reuse expired connection");
+
+    CFAbsoluteTime elapsed = CFAbsoluteTimeGetCurrent() - startTime;
+
+    // 关键验证：测试应该很快完成（< 5 秒），而非等待 30+ 秒
+    XCTAssertLessThan(elapsed, 5.0,
+                      @"Fast expiry test should complete quickly (%.1fs) without 30s wait", elapsed);
+}
+
+@end

EdgeHttpDNS/sdk/ios/AlicloudHttpDNSTests/Network/HttpdnsNWHTTPClient_StateMachineTests.m

@@ -0,0 +1,591 @@
+//
+//  HttpdnsNWHTTPClient_StateMachineTests.m
+//  AlicloudHttpDNSTests
+//
+//  @author Created by Claude Code on 2025-11-01
+//  Copyright © 2025 alibaba-inc.com. All rights reserved.
+//
+//  状态机测试 - 包含状态机与异常场景 (Q) 测试组
+//  测试总数：17 个（Q:17）
+//
+
+#import "HttpdnsNWHTTPClientTestBase.h"
+
+@interface HttpdnsNWHTTPClient_StateMachineTests : HttpdnsNWHTTPClientTestBase
+
+@end
+
+@implementation HttpdnsNWHTTPClient_StateMachineTests
+
+#pragma mark - Q. 状态机与异常场景测试
+
+// Q1.1 池溢出时LRU移除策略验证
+- (void)testStateMachine_PoolOverflowLRU_RemovesOldestByLastUsedDate {
+    [self.client resetPoolStatistics];
+    NSString *poolKey = @"127.0.0.1:11080:tcp";
+
+    // 需要并发创建5个连接（串行请求会复用）
+    NSMutableArray<XCTestExpectation *> *expectations = [NSMutableArray array];
+    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
+
+    // 并发发起5个请求
+    for (NSInteger i = 0; i < 5; i++) {
+        XCTestExpectation *expectation = [self expectationWithDescription:[NSString stringWithFormat:@"Request %ld", (long)i]];
+        [expectations addObject:expectation];
+
+        dispatch_async(queue, ^{
+            NSError *error = nil;
+            // 使用 /delay/2 确保所有请求同时在飞行中，强制创建多个连接
+            [self.client performRequestWithURLString:@"http://127.0.0.1:11080/delay/2"
+                                            userAgent:[NSString stringWithFormat:@"Request%ld", (long)i]
+                                              timeout:15.0
+                                                error:&error];
+            [expectation fulfill];
+        });
+        [NSThread sleepForTimeInterval:0.05];  // 小间隔避免完全同时启动
+    }
+
+    [self waitForExpectations:expectations timeout:20.0];
+
+    // 等待所有连接归还
+    [NSThread sleepForTimeInterval:1.0];
+
+    // 验证：池大小 ≤ 4（LRU移除溢出部分）
+    NSUInteger poolCount = [self.client connectionPoolCountForKey:poolKey];
+    XCTAssertLessThanOrEqual(poolCount, 4,
+                             @"Pool should enforce max 4 connections (LRU)");
+
+    // 验证：创建了多个连接
+    XCTAssertGreaterThanOrEqual(self.client.connectionCreationCount, 3,
+                                @"Should create multiple concurrent connections");
+}
+
+// Q2.1 快速连续请求不产生重复连接（间接验证双重归还防护）
+- (void)testAbnormal_RapidSequentialRequests_NoDuplicates {
+    [self.client resetPoolStatistics];
+    NSString *poolKey = @"127.0.0.1:11080:tcp";
+
+    // 快速连续发起10个请求（测试连接归还的幂等性）
+    for (NSInteger i = 0; i < 10; i++) {
+        NSError *error = nil;
+        HttpdnsNWHTTPClientResponse *response = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                                                                userAgent:@"RapidTest"
+                                                                                  timeout:15.0
+                                                                                    error:&error];
+        XCTAssertNotNil(response);
+    }
+
+    // 等待连接归还
+    [NSThread sleepForTimeInterval:1.0];
+
+    // 验证：池中最多1个连接（因为串行请求复用同一连接）
+    NSUInteger poolCount = [self.client connectionPoolCountForKey:poolKey];
+    XCTAssertLessThanOrEqual(poolCount, 1,
+                             @"Pool should have at most 1 connection (rapid sequential reuse)");
+
+    // 验证：创建次数应该是1（所有请求复用同一连接）
+    XCTAssertEqual(self.client.connectionCreationCount, 1,
+                   @"Should create only 1 connection for sequential requests");
+}
+
+// Q2.2 不同端口请求不互相污染池
+- (void)testAbnormal_DifferentPorts_IsolatedPools {
+    [self.client resetPoolStatistics];
+    NSString *poolKey11080 = @"127.0.0.1:11080:tcp";
+    NSString *poolKey11443 = @"127.0.0.1:11443:tls";
+
+    // 向端口11080发起请求
+    NSError *error1 = nil;
+    HttpdnsNWHTTPClientResponse *response1 = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                                                             userAgent:@"Port11080"
+                                                                               timeout:15.0
+                                                                                 error:&error1];
+    XCTAssertNotNil(response1);
+
+    // 向端口11443发起请求
+    NSError *error2 = nil;
+    HttpdnsNWHTTPClientResponse *response2 = [self.client performRequestWithURLString:@"https://127.0.0.1:11443/get"
+                                                                             userAgent:@"Port11443"
+                                                                               timeout:15.0
+                                                                                 error:&error2];
+    XCTAssertNotNil(response2);
+
+    // 等待连接归还
+    [NSThread sleepForTimeInterval:0.5];
+
+    // 验证：两个池各自有1个连接
+    XCTAssertEqual([self.client connectionPoolCountForKey:poolKey11080], 1,
+                   @"Port 11080 pool should have 1 connection");
+    XCTAssertEqual([self.client connectionPoolCountForKey:poolKey11443], 1,
+                   @"Port 11443 pool should have 1 connection");
+
+    // 验证：总共2个连接（池完全隔离）
+    XCTAssertEqual([self.client totalConnectionCount], 2,
+                   @"Total should be 2 (one per pool)");
+}
+
+// Q3.1 池大小不变式：任何时候池大小都不超过限制
+- (void)testInvariant_PoolSize_NeverExceedsLimit {
+    [self.client resetPoolStatistics];
+
+    // 快速连续发起20个请求到同一端点
+    for (NSInteger i = 0; i < 20; i++) {
+        NSError *error = nil;
+        [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                        userAgent:@"InvariantTest"
+                                          timeout:15.0
+                                            error:&error];
+    }
+
+    // 等待所有连接归还
+    [NSThread sleepForTimeInterval:1.5];
+
+    // 验证：每个池的大小不超过4
+    NSArray<NSString *> *allKeys = [self.client allConnectionPoolKeys];
+    for (NSString *key in allKeys) {
+        NSUInteger poolCount = [self.client connectionPoolCountForKey:key];
+        XCTAssertLessThanOrEqual(poolCount, 4,
+                                 @"Pool %@ size should never exceed 4 (actual: %lu)",
+                                 key, (unsigned long)poolCount);
+    }
+
+    // 验证：总连接数也不超过4（因为只有一个池）
+    XCTAssertLessThanOrEqual([self.client totalConnectionCount], 4,
+                             @"Total connections should not exceed 4");
+}
+
+// Q3.3 无重复连接不变式：并发请求不产生重复
+- (void)testInvariant_NoDuplicates_ConcurrentRequests {
+    [self.client resetPoolStatistics];
+    NSString *poolKey = @"127.0.0.1:11080:tcp";
+
+    NSMutableArray<XCTestExpectation *> *expectations = [NSMutableArray array];
+    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
+
+    // 并发发起15个请求（可能复用连接）
+    for (NSInteger i = 0; i < 15; i++) {
+        XCTestExpectation *expectation = [self expectationWithDescription:[NSString stringWithFormat:@"Request %ld", (long)i]];
+        [expectations addObject:expectation];
+
+        dispatch_async(queue, ^{
+            NSError *error = nil;
+            [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                            userAgent:@"ConcurrentTest"
+                                              timeout:15.0
+                                                error:&error];
+            [expectation fulfill];
+        });
+    }
+
+    [self waitForExpectations:expectations timeout:30.0];
+
+    // 等待连接归还
+    [NSThread sleepForTimeInterval:1.0];
+
+    // 验证：池大小 ≤ 4（不变式）
+    NSUInteger poolCount = [self.client connectionPoolCountForKey:poolKey];
+    XCTAssertLessThanOrEqual(poolCount, 4,
+                             @"Pool should not have duplicates (max 4 connections)");
+
+    // 验证：创建的连接数合理（≤15，因为可能有复用）
+    XCTAssertLessThanOrEqual(self.client.connectionCreationCount, 15,
+                             @"Should not create excessive connections");
+}
+
+// Q4.1 边界条件：恰好30秒后连接过期
+- (void)testBoundary_Exactly30Seconds_ConnectionExpired {
+    if (getenv("SKIP_SLOW_TESTS")) {
+        return;
+    }
+
+    [self.client resetPoolStatistics];
+
+    // 第一个请求
+    NSError *error1 = nil;
+    HttpdnsNWHTTPClientResponse *response1 = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                                                             userAgent:@"InitialRequest"
+                                                                               timeout:15.0
+                                                                                 error:&error1];
+    XCTAssertNotNil(response1);
+
+    // 等待恰好30.5秒（超过30秒过期时间）
+    [NSThread sleepForTimeInterval:30.5];
+
+    // 第二个请求：应该创建新连接（旧连接已过期）
+    NSError *error2 = nil;
+    HttpdnsNWHTTPClientResponse *response2 = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                                                             userAgent:@"AfterExpiry"
+                                                                               timeout:15.0
+                                                                                 error:&error2];
+    XCTAssertNotNil(response2);
+
+    // 验证：创建了2个连接（旧连接过期，无法复用）
+    XCTAssertEqual(self.client.connectionCreationCount, 2,
+                   @"Should create 2 connections (first expired after 30s)");
+    XCTAssertEqual(self.client.connectionReuseCount, 0,
+                   @"Should not reuse expired connection");
+}
+
+// Q4.2 边界条件：29秒内连接未过期
+- (void)testBoundary_Under30Seconds_ConnectionNotExpired {
+    [self.client resetPoolStatistics];
+
+    // 第一个请求
+    NSError *error1 = nil;
+    HttpdnsNWHTTPClientResponse *response1 = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                                                             userAgent:@"InitialRequest"
+                                                                               timeout:15.0
+                                                                                 error:&error1];
+    XCTAssertNotNil(response1);
+
+    // 等待29秒（未到30秒过期时间）
+    [NSThread sleepForTimeInterval:29.0];
+
+    // 第二个请求：应该复用连接
+    NSError *error2 = nil;
+    HttpdnsNWHTTPClientResponse *response2 = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                                                             userAgent:@"BeforeExpiry"
+                                                                               timeout:15.0
+                                                                                 error:&error2];
+    XCTAssertNotNil(response2);
+
+    // 验证：只创建了1个连接（复用了）
+    XCTAssertEqual(self.client.connectionCreationCount, 1,
+                   @"Should create only 1 connection (reused within 30s)");
+    XCTAssertEqual(self.client.connectionReuseCount, 1,
+                   @"Should reuse connection within 30s");
+}
+
+// Q4.3 边界条件：恰好4个连接全部保留
+- (void)testBoundary_ExactlyFourConnections_AllKept {
+    [self.client resetPoolStatistics];
+    NSString *poolKey = @"127.0.0.1:11080:tcp";
+
+    // 并发发起4个请求（使用延迟确保同时在飞行中，创建4个独立连接）
+    NSMutableArray<XCTestExpectation *> *expectations = [NSMutableArray array];
+    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
+
+    for (NSInteger i = 0; i < 4; i++) {
+        XCTestExpectation *expectation = [self expectationWithDescription:
+            [NSString stringWithFormat:@"Request %ld", (long)i]];
+        [expectations addObject:expectation];
+
+        dispatch_async(queue, ^{
+            NSError *error = nil;
+            // 使用 /delay/2 确保所有请求同时在飞行中
+            [self.client performRequestWithURLString:@"http://127.0.0.1:11080/delay/2"
+                                            userAgent:[NSString stringWithFormat:@"Request%ld", (long)i]
+                                              timeout:15.0
+                                                error:&error];
+            [expectation fulfill];
+        });
+
+        [NSThread sleepForTimeInterval:0.05];  // 小间隔避免完全同时启动
+    }
+
+    [self waitForExpectations:expectations timeout:20.0];
+
+    // 等待连接归还
+    [NSThread sleepForTimeInterval:1.0];
+
+    // 验证：池恰好有4个连接（全部保留）
+    NSUInteger poolCount = [self.client connectionPoolCountForKey:poolKey];
+    XCTAssertEqual(poolCount, 4,
+                   @"Pool should keep all 4 connections (not exceeding limit)");
+
+    // 验证：恰好创建4个连接
+    XCTAssertEqual(self.client.connectionCreationCount, 4,
+                   @"Should create exactly 4 connections");
+}
+
+// Q1.2 正常状态序列验证
+- (void)testStateMachine_NormalSequence_StateTransitionsCorrect {
+    [self.client resetPoolStatistics];
+    NSString *poolKey = @"127.0.0.1:11080:tcp";
+
+    // 第1步：创建并使用连接 (CREATING → IN_USE → IDLE)
+    HttpdnsNWHTTPClientResponse *response1 = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                                                            userAgent:@"StateTest"
+                                                                              timeout:15.0
+                                                                                error:nil];
+    XCTAssertNotNil(response1, @"First request should succeed");
+
+    [NSThread sleepForTimeInterval:1.0];  // 等待归还
+
+    // 验证：池中有1个连接
+    XCTAssertEqual([self.client connectionPoolCountForKey:poolKey], 1,
+                   @"Connection should be in pool");
+
+    // 第2步：复用连接 (IDLE → IN_USE → IDLE)
+    HttpdnsNWHTTPClientResponse *response2 = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                                                            userAgent:@"StateTest"
+                                                                              timeout:15.0
+                                                                                error:nil];
+    XCTAssertNotNil(response2, @"Second request should reuse connection");
+
+    // 验证：复用计数增加
+    XCTAssertEqual(self.client.connectionReuseCount, 1,
+                   @"Should have reused connection once");
+}
+
+// Q1.3 inUse 标志维护验证
+- (void)testStateMachine_InUseFlag_CorrectlyMaintained {
+    [self.client resetPoolStatistics];
+    NSString *poolKey = @"127.0.0.1:11080:tcp";
+
+    // 发起请求并归还
+    [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                    userAgent:@"InUseTest"
+                                      timeout:15.0
+                                        error:nil];
+
+    [NSThread sleepForTimeInterval:1.0];  // 等待归还
+
+    // 获取池中连接
+    NSArray<HttpdnsNWReusableConnection *> *connections = [self.client connectionsInPoolForKey:poolKey];
+    XCTAssertEqual(connections.count, 1, @"Should have 1 connection in pool");
+
+    // 验证：池中连接的 inUse 应为 NO
+    for (HttpdnsNWReusableConnection *conn in connections) {
+        XCTAssertFalse(conn.inUse, @"Connection in pool should not be marked as inUse");
+    }
+}
+
+// Q2.3 Nil lastUsedDate 处理验证
+- (void)testAbnormal_NilLastUsedDate_HandledGracefully {
+    [self.client resetPoolStatistics];
+    NSString *poolKey = @"127.0.0.1:11080:tcp";
+
+    // 发起请求创建连接
+    [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                    userAgent:@"NilDateTest"
+                                      timeout:15.0
+                                        error:nil];
+
+    [NSThread sleepForTimeInterval:1.0];
+
+    // 获取连接并设置 lastUsedDate 为 nil
+    NSArray<HttpdnsNWReusableConnection *> *connections = [self.client connectionsInPoolForKey:poolKey];
+    XCTAssertEqual(connections.count, 1, @"Should have connection");
+
+    HttpdnsNWReusableConnection *conn = connections.firstObject;
+    [conn debugSetLastUsedDate:nil];
+
+    // 发起新请求触发 prune（内部应使用 distantPast 处理 nil）
+    HttpdnsNWHTTPClientResponse *response = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                                                            userAgent:@"NilDateTest"
+                                                                              timeout:15.0
+                                                                                error:nil];
+
+    // 验证：不崩溃，正常工作
+    XCTAssertNotNil(response, @"Should handle nil lastUsedDate gracefully");
+}
+
+// Q3.2 池中无失效连接不变式
+- (void)testInvariant_NoInvalidatedInPool {
+    [self.client resetPoolStatistics];
+    NSString *poolKey = @"127.0.0.1:11080:tcp";
+
+    // 发起多个请求（包括成功和超时）
+    for (NSInteger i = 0; i < 3; i++) {
+        [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                        userAgent:@"InvariantTest"
+                                          timeout:15.0
+                                            error:nil];
+    }
+
+    // 发起1个超时请求
+    [self.client performRequestWithURLString:@"http://127.0.0.1:11080/delay/10"
+                                    userAgent:@"TimeoutTest"
+                                      timeout:0.5
+                                        error:nil];
+
+    [NSThread sleepForTimeInterval:2.0];
+
+    // 获取池中所有连接
+    NSArray<HttpdnsNWReusableConnection *> *connections = [self.client connectionsInPoolForKey:poolKey];
+
+    // 验证：池中无失效连接
+    for (HttpdnsNWReusableConnection *conn in connections) {
+        XCTAssertFalse(conn.isInvalidated, @"Pool should not contain invalidated connections");
+    }
+}
+
+// Q3.4 lastUsedDate 单调性验证
+- (void)testInvariant_LastUsedDate_Monotonic {
+    [self.client resetPoolStatistics];
+    NSString *poolKey = @"127.0.0.1:11080:tcp";
+
+    // 第1次使用
+    [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                    userAgent:@"MonotonicTest"
+                                      timeout:15.0
+                                        error:nil];
+
+    [NSThread sleepForTimeInterval:1.0];
+
+    NSArray<HttpdnsNWReusableConnection *> *connections1 = [self.client connectionsInPoolForKey:poolKey];
+    XCTAssertEqual(connections1.count, 1, @"Should have connection");
+    NSDate *date1 = connections1.firstObject.lastUsedDate;
+    XCTAssertNotNil(date1, @"lastUsedDate should be set");
+
+    // 等待1秒确保时间推进
+    [NSThread sleepForTimeInterval:1.0];
+
+    // 第2次使用同一连接
+    [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                    userAgent:@"MonotonicTest"
+                                      timeout:15.0
+                                        error:nil];
+
+    [NSThread sleepForTimeInterval:1.0];
+
+    NSArray<HttpdnsNWReusableConnection *> *connections2 = [self.client connectionsInPoolForKey:poolKey];
+    XCTAssertEqual(connections2.count, 1, @"Should still have 1 connection");
+    NSDate *date2 = connections2.firstObject.lastUsedDate;
+
+    // 验证：lastUsedDate 递增
+    XCTAssertTrue([date2 timeIntervalSinceDate:date1] > 0,
+                  @"lastUsedDate should increase after reuse");
+}
+
+// Q5.1 超时+池溢出复合场景
+- (void)testCompound_TimeoutDuringPoolOverflow_Handled {
+    [self.client resetPoolStatistics];
+    NSString *poolKey = @"127.0.0.1:11080:tcp";
+
+    // 先填满池（4个成功连接）
+    NSMutableArray<XCTestExpectation *> *expectations = [NSMutableArray array];
+    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
+
+    for (NSInteger i = 0; i < 4; i++) {
+        XCTestExpectation *expectation = [self expectationWithDescription:
+            [NSString stringWithFormat:@"Fill pool %ld", (long)i]];
+        [expectations addObject:expectation];
+
+        dispatch_async(queue, ^{
+            [self.client performRequestWithURLString:@"http://127.0.0.1:11080/delay/2"
+                                            userAgent:@"CompoundTest"
+                                              timeout:15.0
+                                                error:nil];
+            [expectation fulfill];
+        });
+        [NSThread sleepForTimeInterval:0.05];
+    }
+
+    [self waitForExpectations:expectations timeout:20.0];
+    [NSThread sleepForTimeInterval:1.0];
+
+    NSUInteger poolCountBefore = [self.client connectionPoolCountForKey:poolKey];
+    XCTAssertLessThanOrEqual(poolCountBefore, 4, @"Pool should have ≤4 connections");
+
+    // 第5个请求超时
+    NSError *error = nil;
+    HttpdnsNWHTTPClientResponse *response = [self.client performRequestWithURLString:@"http://127.0.0.1:11080/delay/10"
+                                                                            userAgent:@"TimeoutRequest"
+                                                                              timeout:0.5
+                                                                                error:&error];
+
+    XCTAssertNil(response, @"Timeout request should return nil");
+    XCTAssertNotNil(error, @"Should have error");
+
+    [NSThread sleepForTimeInterval:1.0];
+
+    // 验证：超时连接未加入池
+    NSUInteger poolCountAfter = [self.client connectionPoolCountForKey:poolKey];
+    XCTAssertLessThanOrEqual(poolCountAfter, 4, @"Timed-out connection should not be added to pool");
+}
+
+// Q2.4 打开失败不加入池
+- (void)testAbnormal_OpenFailure_NotAddedToPool {
+    [self.client resetPoolStatistics];
+
+    // 尝试连接无效端口（连接拒绝）
+    NSError *error = nil;
+    HttpdnsNWHTTPClientResponse *response = [self.client performRequestWithURLString:@"http://127.0.0.1:99999/get"
+                                                                            userAgent:@"FailureTest"
+                                                                              timeout:2.0
+                                                                                error:&error];
+
+    // 验证：请求失败
+    XCTAssertNil(response, @"Should fail to connect to invalid port");
+
+    // 验证：无连接加入池
+    XCTAssertEqual([self.client totalConnectionCount], 0,
+                   @"Failed connection should not be added to pool");
+}
+
+// Q2.5 多次 invalidate 幂等性
+- (void)testAbnormal_MultipleInvalidate_Idempotent {
+    [self.client resetPoolStatistics];
+    NSString *poolKey = @"127.0.0.1:11080:tcp";
+
+    // 创建连接
+    [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                    userAgent:@"InvalidateTest"
+                                      timeout:15.0
+                                        error:nil];
+
+    [NSThread sleepForTimeInterval:1.0];
+
+    NSArray<HttpdnsNWReusableConnection *> *connections = [self.client connectionsInPoolForKey:poolKey];
+    XCTAssertEqual(connections.count, 1, @"Should have connection");
+
+    HttpdnsNWReusableConnection *conn = connections.firstObject;
+
+    // 多次 invalidate
+    [conn debugInvalidate];
+    [conn debugInvalidate];
+    [conn debugInvalidate];
+
+    // 验证：不崩溃
+    XCTAssertTrue(conn.isInvalidated, @"Connection should be invalidated");
+}
+
+// Q5.2 并发 dequeue 竞态测试
+- (void)testCompound_ConcurrentDequeueDuringPrune_Safe {
+    [self.client resetPoolStatistics];
+
+    // 在两个端口创建连接
+    [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                    userAgent:@"RaceTest"
+                                      timeout:15.0
+                                        error:nil];
+
+    [self.client performRequestWithURLString:@"http://127.0.0.1:11443/get"
+                                    userAgent:@"RaceTest"
+                                      timeout:15.0
+                                        error:nil];
+
+    [NSThread sleepForTimeInterval:1.0];
+
+    // 等待30秒让连接过期
+    [NSThread sleepForTimeInterval:30.5];
+
+    // 并发触发两个端口的 dequeue（会触发 prune）
+    dispatch_group_t group = dispatch_group_create();
+    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
+
+    dispatch_group_async(group, queue, ^{
+        [self.client performRequestWithURLString:@"http://127.0.0.1:11080/get"
+                                        userAgent:@"Race1"
+                                          timeout:15.0
+                                            error:nil];
+    });
+
+    dispatch_group_async(group, queue, ^{
+        [self.client performRequestWithURLString:@"http://127.0.0.1:11443/get"
+                                        userAgent:@"Race2"
+                                          timeout:15.0
+                                            error:nil];
+    });
+
+    // 等待完成
+    dispatch_group_wait(group, dispatch_time(DISPATCH_TIME_NOW, 20 * NSEC_PER_SEC));
+
+    // 验证：无崩溃，连接池正常工作
+    NSUInteger totalCount = [self.client totalConnectionCount];
+    XCTAssertLessThanOrEqual(totalCount, 4, @"Pool should remain stable after concurrent prune");
+}
+
+@end

EdgeHttpDNS/sdk/ios/AlicloudHttpDNSTests/Network/MOCK_SERVER.md

@@ -0,0 +1,253 @@
+# HTTP Mock Server for Integration Tests
+
+本目录包含用于 `HttpdnsNWHTTPClient` 集成测试的 HTTP/HTTPS mock server，用于替代 httpbin.org。
+
+---
+
+## 为什么需要 Mock Server？
+
+1. **可靠性**: httpbin.org 在高并发测试下表现不稳定，经常返回非预期的 HTTP 状态码（如 429 Too Many Requests）
+2. **速度**: 本地服务器响应更快，缩短测试执行时间
+3. **离线测试**: 无需网络连接即可运行集成测试
+4. **可控性**: 完全掌控测试环境，便于调试和复现问题
+
+---
+
+## 快速开始
+
+### 1. 启动 Mock Server
+
+```bash
+# 进入测试目录
+cd AlicloudHttpDNSTests/Network
+
+# 启动服务器（无需 sudo 权限，使用非特权端口）
+python3 mock_server.py
+```
+
+**注意**:
+- **无需 root 权限**（使用非特权端口 11080/11443-11446）
+- 首次运行会自动生成自签名证书 (`server.pem`)
+- 按 `Ctrl+C` 停止服务器
+
+### 2. 运行集成测试
+
+在另一个终端窗口:
+
+```bash
+cd ~/Project/iOS/alicloud-ios-sdk-httpdns
+
+# 运行所有集成测试
+xcodebuild test \
+  -workspace AlicloudHttpDNS.xcworkspace \
+  -scheme AlicloudHttpDNSTests \
+  -destination 'platform=iOS Simulator,name=iPhone 15' \
+  -only-testing:AlicloudHttpDNSTests/HttpdnsNWHTTPClientIntegrationTests
+
+# 运行单个测试
+xcodebuild test \
+  -workspace AlicloudHttpDNS.xcworkspace \
+  -scheme AlicloudHttpDNSTests \
+  -destination 'platform=iOS Simulator,name=iPhone 15' \
+  -only-testing:AlicloudHttpDNSTests/HttpdnsNWHTTPClientIntegrationTests/testConcurrency_ParallelRequestsSameHost_AllSucceed
+```
+
+---
+
+## 支持的 Endpoints
+
+Mock server 实现了以下 httpbin.org 兼容的 endpoints:
+
+| Endpoint | 功能 | 示例 |
+|----------|------|------|
+| `GET /get` | 返回请求信息（headers, args, origin） | `http://127.0.0.1:11080/get` |
+| `GET /status/{code}` | 返回指定状态码（100-599） | `http://127.0.0.1:11080/status/404` |
+| `GET /stream-bytes/{n}` | 返回 chunked 编码的 N 字节数据 | `http://127.0.0.1:11080/stream-bytes/1024` |
+| `GET /delay/{seconds}` | 延迟指定秒数后返回（最多10秒） | `http://127.0.0.1:11080/delay/5` |
+| `GET /headers` | 返回所有请求头部 | `http://127.0.0.1:11080/headers` |
+| `GET /uuid` | 返回随机 UUID | `http://127.0.0.1:11080/uuid` |
+| `GET /user-agent` | 返回 User-Agent 头部 | `http://127.0.0.1:11080/user-agent` |
+
+**端口配置**:
+- **HTTP**: `127.0.0.1:11080`
+- **HTTPS**: `127.0.0.1:11443`, `11444`, `11445`, `11446`（4个端口用于测试连接池隔离）
+
+所有 endpoints 在 HTTP 和 HTTPS 端口上均可访问。
+
+---
+
+## 实现细节
+
+### 架构
+
+- **HTTP 服务器**: 监听 `127.0.0.1:11080`
+- **HTTPS 服务器**: 监听 `127.0.0.1:11443`, `11444`, `11445`, `11446`（4个端口，使用自签名证书）
+- **多端口目的**: 测试连接池的端口隔离机制，确保不同端口使用独立的连接池
+- **并发模型**: 多线程（`ThreadingMixIn`），支持高并发请求
+
+### TLS 证书
+
+- 自动生成自签名证书（RSA 2048位，有效期 365 天）
+- CN (Common Name): `localhost`
+- 证书文件: `server.pem`（同时包含密钥和证书）
+
+**重要**: 集成测试通过环境变量 `HTTPDNS_SKIP_TLS_VERIFY=1` 跳过 TLS 验证，这是安全的，因为：
+1. 仅在测试环境生效
+2. 不影响生产代码
+3. 连接限制为本地 loopback (127.0.0.1)
+
+### 响应格式
+
+所有 JSON 响应遵循 httpbin.org 格式，例如:
+
+```json
+{
+  "args": {},
+  "headers": {
+    "Host": "127.0.0.1",
+    "User-Agent": "HttpdnsNWHTTPClient/1.0"
+  },
+  "origin": "127.0.0.1",
+  "url": "GET /get"
+}
+```
+
+Chunked 编码响应示例 (`/stream-bytes/10`):
+```
+HTTP/1.1 200 OK
+Transfer-Encoding: chunked
+
+a
+XXXXXXXXXX
+0
+
+```
+
+---
+
+## 故障排除
+
+### 端口已被占用
+
+**错误信息**:
+```
+✗ 端口 80 已被占用，请关闭占用端口的进程或使用其他端口
+```
+
+**解决方法**:
+
+1. 查找占用进程:
+```bash
+sudo lsof -i :80
+sudo lsof -i :443
+```
+
+2. 终止占用进程:
+```bash
+sudo kill -9 <PID>
+```
+
+3. 或修改 mock_server.py 使用其他端口:
+```python
+# 修改端口号（同时需要更新测试代码中的 URL）
+run_http_server(port=8080)
+run_https_server(port=8443)
+```
+
+### 缺少 OpenSSL
+
+**错误信息**:
+```
+✗ 未找到 openssl 命令，请安装 OpenSSL
+```
+
+**解决方法**:
+
+```bash
+# macOS (通常已预装)
+brew install openssl
+
+# Ubuntu/Debian
+sudo apt-get install openssl
+
+# CentOS/RHEL
+sudo yum install openssl
+```
+
+### 权限被拒绝
+
+**错误信息**:
+```
+✗ 错误: 需要 root 权限以绑定 80/443 端口
+```
+
+**解决方法**:
+
+必须使用 `sudo` 运行:
+```bash
+sudo python3 mock_server.py
+```
+
+---
+
+## 切换回 httpbin.org
+
+如需使用真实的 httpbin.org 进行测试（例如验证兼容性）:
+
+1. 编辑 `HttpdnsNWHTTPClientIntegrationTests.m`
+2. 将所有 `127.0.0.1` 替换回 `httpbin.org`
+3. 注释掉 setUp/tearDown 中的环境变量设置
+
+---
+
+## 开发与扩展
+
+### 添加新 Endpoint
+
+在 `mock_server.py` 的 `MockHTTPHandler.do_GET()` 方法中添加:
+
+```python
+def do_GET(self):
+    path = urlparse(self.path).path
+
+    if path == '/your-new-endpoint':
+        self._handle_your_endpoint()
+    # ... 其他 endpoints
+
+def _handle_your_endpoint(self):
+    """处理自定义 endpoint"""
+    data = {'custom': 'data'}
+    self._send_json(200, data)
+```
+
+### 调试模式
+
+取消注释 `log_message` 方法以启用详细日志:
+
+```python
+def log_message(self, format, *args):
+    print(f"[{self.address_string()}] {format % args}")
+```
+
+---
+
+## 技术栈
+
+- **Python 3.7+** (标准库，无需额外依赖)
+- **http.server**: HTTP 服务器实现
+- **ssl**: TLS/SSL 支持
+- **socketserver.ThreadingMixIn**: 多线程并发
+
+---
+
+## 安全注意事项
+
+1. **仅用于测试**: 此服务器设计用于本地测试，不适合生产环境
+2. **自签名证书**: HTTPS 使用不受信任的自签名证书
+3. **无身份验证**: 不实现任何身份验证机制
+4. **本地绑定**: 服务器仅绑定到 `127.0.0.1`，不接受外部连接
+
+---
+
+**最后更新**: 2025-11-01
+**维护者**: Claude Code

EdgeHttpDNS/sdk/ios/AlicloudHttpDNSTests/Network/README.md

@@ -0,0 +1,282 @@
+# HttpdnsNWHTTPClient 测试套件
+
+本目录包含 `HttpdnsNWHTTPClient` 和 `HttpdnsNWReusableConnection` 的完整测试套件。
+
+## 测试文件结构
+
+```
+AlicloudHttpDNSTests/Network/
+├── HttpdnsNWHTTPClientTests.m              # 主单元测试（44个）
+├── HttpdnsNWHTTPClientIntegrationTests.m   # 集成测试（7个）
+├── HttpdnsNWHTTPClientTestHelper.h/m       # 测试辅助工具类
+└── README.md                               # 本文件
+```
+
+## 测试覆盖范围
+
+### 单元测试 (HttpdnsNWHTTPClientTests.m)
+
+#### A. HTTP 解析逻辑测试 (25个)
+- **A1. Header 解析 (9个)**
+  - 正常响应解析
+  - 多个头部字段
+  - 不完整数据处理
+  - 无效状态行
+  - 空格处理与 trim
+  - 空值头部
+  - 非数字状态码
+  - 状态码为零
+  - 无效头部行
+
+- **A2. Chunked 编码检查 (8个)**
+  - 单个 chunk
+  - 多个 chunks
+  - 不完整 chunk
+  - Chunk extension 支持
+  - 无效十六进制 size
+  - Chunk size 溢出
+  - 缺少 CRLF 终止符
+  - 带 trailers 的 chunked
+
+- **A3. Chunked 解码 (2个)**
+  - 多个 chunks 正确解码
+  - 无效格式返回 nil
+
+- **A4. 完整响应解析 (6个)**
+  - Content-Length 响应
+  - Chunked 编码响应
+  - 空 body
+  - Content-Length 不匹配
+  - 空数据错误
+  - 只有 headers 无 body
+
+#### C. 请求构建测试 (7个)
+- 基本 GET 请求格式
+- 查询参数处理
+- User-Agent 头部
+- HTTP 默认端口处理
+- HTTPS 默认端口处理
+- 非默认端口显示
+- 固定头部验证
+
+#### E. TLS 验证测试 (4个占位符)
+- 有效证书返回 YES
+- Proceed 结果返回 YES
+- 无效证书返回 NO
+- 指定域名使用 SSL Policy
+
+*注：TLS 测试需要真实的 SecTrustRef 或复杂 mock，当前为占位符*
+
+#### F. 边缘情况测试 (8个)
+- 超长 URL 处理
+- 空 User-Agent
+- 超大响应体（5MB）
+- Chunked 解码失败回退
+- 连接池 key - 不同 hosts
+- 连接池 key - 不同 ports
+- 连接池 key - HTTP vs HTTPS
+
+### 集成测试 (HttpdnsNWHTTPClientIntegrationTests.m)
+
+使用 httpbin.org 进行真实网络测试 (22个)：
+
+**G. 基础集成测试 (7个)**
+- HTTP GET 请求
+- HTTPS GET 请求
+- HTTP 404 响应
+- 连接复用（两次请求）
+- Chunked 响应处理
+- 请求超时测试
+- 自定义头部验证
+
+**H. 并发测试 (5个)**
+- 并发请求同一主机（10个线程）
+- 并发请求不同路径（5个不同endpoint）
+- 混合 HTTP + HTTPS 并发（各5个线程）
+- 高负载压力测试（50个并发请求）
+- 混合串行+并发模式
+
+**I. 竞态条件测试 (5个)**
+- 连接池容量测试（超过4个连接上限）
+- 同时归还连接（5个并发）
+- 获取-归还-再获取竞态
+- 超时与活跃连接冲突（需31秒，可跳过）
+- 错误恢复后连接池健康状态
+
+**J. 高级连接复用测试 (5个)**
+- 连接过期与清理（31秒，可跳过）
+- 连接池容量限制验证（10个连续请求）
+- 不同路径复用连接（4个不同路径）
+- HTTP vs HTTPS 使用不同连接池key
+- 长连接保持测试（20个请求间隔1秒，可跳过）
+
+## 运行测试
+
+### 运行所有单元测试
+```bash
+xcodebuild test \
+  -workspace AlicloudHttpDNS.xcworkspace \
+  -scheme AlicloudHttpDNSTests \
+  -destination 'platform=iOS Simulator,name=iPhone 15' \
+  -only-testing:AlicloudHttpDNSTests/HttpdnsNWHTTPClientTests
+```
+
+### 运行集成测试（需要网络）
+```bash
+xcodebuild test \
+  -workspace AlicloudHttpDNS.xcworkspace \
+  -scheme AlicloudHttpDNSTests \
+  -destination 'platform=iOS Simulator,name=iPhone 15' \
+  -only-testing:AlicloudHttpDNSTests/HttpdnsNWHTTPClientIntegrationTests
+```
+
+### 运行单个测试
+```bash
+xcodebuild test \
+  -workspace AlicloudHttpDNS.xcworkspace \
+  -scheme AlicloudHttpDNSTests \
+  -destination 'platform=iOS Simulator,name=iPhone 15' \
+  -only-testing:AlicloudHttpDNSTests/HttpdnsNWHTTPClientTests/testParseHTTPHeaders_ValidResponse_Success
+```
+
+## 测试辅助工具
+
+### HttpdnsNWHTTPClientTestHelper
+
+提供以下工具方法：
+
+#### HTTP 响应构造
+```objc
+// 构造标准 HTTP 响应
++ (NSData *)createHTTPResponseWithStatus:(NSInteger)statusCode
+                              statusText:(NSString *)statusText
+                                 headers:(NSDictionary *)headers
+                                    body:(NSData *)body;
+
+// 构造 chunked 响应
++ (NSData *)createChunkedHTTPResponseWithStatus:(NSInteger)statusCode
+                                        headers:(NSDictionary *)headers
+                                         chunks:(NSArray<NSData *> *)chunks;
+```
+
+#### Chunked 编码工具
+```objc
++ (NSData *)encodeChunk:(NSData *)data;
++ (NSData *)encodeLastChunk;
+```
+
+#### 数据生成
+```objc
++ (NSData *)randomDataWithSize:(NSUInteger)size;
++ (NSData *)jsonBodyWithDictionary:(NSDictionary *)dictionary;
+```
+
+## 测试统计
+
+| 测试类别 | 测试数量 | 覆盖范围 |
+|---------|---------|---------|
+| HTTP 解析 | 25 | HTTP 头部、Chunked 编码、完整响应 |
+| 请求构建 | 7 | URL 处理、头部生成 |
+| TLS 验证 | 4 (占位符) | 证书验证 |
+| 边缘情况 | 8 | 异常输入、连接池 key |
+| **单元测试合计** | **43** | - |
+| 基础集成测试 (G) | 7 | 真实网络请求、基本场景 |
+| 并发测试 (H) | 5 | 多线程并发、高负载 |
+| 竞态条件测试 (I) | 5 | 连接池竞态、错误恢复 |
+| 连接复用测试 (J) | 5 | 连接过期、长连接、协议隔离 |
+| 多端口连接隔离 (K) | 5 | 不同端口独立连接池 |
+| 端口池耗尽测试 (L) | 3 | 多端口高负载、池隔离 |
+| 边界条件验证 (M) | 4 | 端口迁移、高端口数量 |
+| 并发多端口场景 (N) | 3 | 并行 keep-alive、轮询分配 |
+| **集成测试合计** | **37** | - |
+| **总计** | **80** | - |
+
+## 待实现测试（可选）
+
+以下测试组涉及复杂的 Mock 场景，可根据需要添加：
+
+### B. 连接池管理测试 (18个)
+需要 Mock `HttpdnsNWReusableConnection` 的完整生命周期
+
+### D. 完整流程测试 (13个)
+需要 Mock 连接池和网络层的集成场景
+
+## Mock Server 使用
+
+集成测试使用本地 mock server (127.0.0.1) 替代 httpbin.org，提供稳定可靠的测试环境。
+
+### 启动 Mock Server
+
+```bash
+cd AlicloudHttpDNSTests/Network
+python3 mock_server.py
+```
+
+**注意**：使用非特权端口（11080/11443-11446），无需 `sudo` 权限。
+
+### 运行集成测试
+
+在另一个终端窗口：
+
+```bash
+xcodebuild test \
+  -workspace AlicloudHttpDNS.xcworkspace \
+  -scheme AlicloudHttpDNSTests \
+  -destination 'platform=iOS Simulator,name=iPhone 15' \
+  -only-testing:AlicloudHttpDNSTests/HttpdnsNWHTTPClientIntegrationTests
+```
+
+### Mock Server 特性
+
+- **HTTP**: 监听 `127.0.0.1:11080`
+- **HTTPS**: 监听 `127.0.0.1:11443`, `11444`, `11445`, `11446` (自签名证书)
+- **多端口目的**: 测试连接池的端口隔离机制
+- **并发支持**: 多线程处理，适合并发测试
+- **零延迟**: 本地响应，测试速度快
+
+详见 [MOCK_SERVER.md](./MOCK_SERVER.md)
+
+## 注意事项
+
+1. **集成测试依赖 Mock Server**：`HttpdnsNWHTTPClientIntegrationTests` 使用本地 mock server (127.0.0.1)。测试前需先启动 `mock_server.py`。
+
+2. **慢测试跳过**：部分测试需要等待31秒（测试连接过期），可设置环境变量 `SKIP_SLOW_TESTS=1` 跳过这些测试：
+   - `testRaceCondition_ExpiredConnectionPruning_CreatesNewConnection`
+   - `testConnectionReuse_Expiry31Seconds_NewConnectionCreated`
+   - `testConnectionReuse_TwentyRequestsOneSecondApart_ConnectionKeptAlive`
+
+3. **并发测试容错**：并发和压力测试允许部分失败（例如 H.4 要求80%成功率），因为高负载下仍可能出现网络波动。
+
+4. **TLS 测试占位符**：E 组 TLS 测试需要真实的 `SecTrustRef` 或高级 mock 框架，当前仅为占位符。
+
+5. **新文件添加到 Xcode**：创建的测试文件需要手动添加到 `AlicloudHttpDNSTests` target。
+
+6. **测试数据**：使用 `HttpdnsNWHTTPClientTestHelper` 生成测试数据，确保测试的可重复性。
+
+## 文件依赖
+
+测试文件依赖以下源文件：
+- `HttpdnsNWHTTPClient.h/m` - 主要被测试类
+- `HttpdnsNWHTTPClient_Internal.h` - 内部方法暴露（测试专用）
+- `HttpdnsNWReusableConnection.h/m` - 连接管理
+- `HttpdnsNWHTTPClientResponse` - 响应模型
+
+## 贡献指南
+
+添加新测试时，请遵循：
+1. 命名规范：`test<Component>_<Scenario>_<ExpectedResult>`
+2. 使用 `#pragma mark` 组织测试分组
+3. 添加清晰的注释说明测试目的
+4. 验证测试覆盖率并更新本文档
+
+---
+
+**最后更新**: 2025-11-01
+**测试框架**: XCTest + OCMock
+**维护者**: Claude Code
+
+**更新日志**:
+- 2025-11-01: 新增 15 个多端口连接复用测试（K、L、M、N组），测试总数增至 37 个
+- 2025-11-01: Mock server 新增 3 个 HTTPS 端口（11444-11446）用于测试连接池隔离
+- 2025-11-01: 新增本地 mock server，替代 httpbin.org，提供稳定测试环境
+- 2025-11-01: 新增 15 个并发、竞态和连接复用集成测试（H、I、J组）

EdgeHttpDNS/sdk/ios/AlicloudHttpDNSTests/Network/STATE_MACHINE_ANALYSIS.md

@@ -0,0 +1,514 @@
+# 连接池状态机验证分析
+
+## 用户核心问题
+
+**"have we verified that the state machine of connection in the pool has been correctly maintained? what abnormal situation have we designed? ultrathink"**
+
+---
+
+## 连接状态机定义
+
+### 状态属性
+
+**HttpdnsNWReusableConnection.h:9-11**
+```objc
+@property (nonatomic, strong) NSDate *lastUsedDate;  // 最后使用时间
+@property (nonatomic, assign) BOOL inUse;            // 是否正在被使用
+@property (nonatomic, assign, getter=isInvalidated, readonly) BOOL invalidated;  // 是否已失效
+```
+
+### 状态枚举
+
+虽然没有显式枚举，但连接实际存在以下逻辑状态：
+
+| 状态 | `inUse` | `invalidated` | `pool` | 描述 |
+|------|---------|---------------|--------|------|
+| **CREATING** | - | NO | ✗ | 新创建，尚未打开 |
+| **IN_USE** | YES | NO | ✓ | 已借出，正在使用 |
+| **IDLE** | NO | NO | ✓ | 空闲，可复用 |
+| **EXPIRED** | NO | NO | ✓ | 空闲超30秒，待清理 |
+| **INVALIDATED** | - | YES | ✗ | 已失效，已移除 |
+
+---
+
+## 状态转换图
+
+```
+  ┌─────────┐
+  │CREATING │ (new connection)
+  └────┬────┘
+       │ openWithTimeout success
+       ▼
+  ┌─────────┐
+  │ IN_USE  │ (inUse=YES, in pool)
+  └────┬────┘
+       │
+       ├──success──► returnConnection(shouldClose=NO)
+       │             │
+       │             ▼
+       │        ┌─────────┐
+       │        │  IDLE   │ (inUse=NO, in pool)
+       │        └────┬────┘
+       │             │
+       │             ├──dequeue──► IN_USE (reuse)
+       │             │
+       │             ├──idle 30s──► EXPIRED
+       │             │              │
+       │             │              └──prune──► INVALIDATED
+       │             │
+       │             └──!isViable──► INVALIDATED (skip in dequeue)
+       │
+       ├──error/timeout──► returnConnection(shouldClose=YES)
+       │                   │
+       │                   ▼
+       └──────────► ┌──────────────┐
+                    │ INVALIDATED  │ (removed from pool)
+                    └──────────────┘
+```
+
+---
+
+## 代码中的状态转换
+
+### 1. CREATING → IN_USE (新连接)
+
+**HttpdnsNWHTTPClient.m:248-249**
+```objc
+newConnection.inUse = YES;
+newConnection.lastUsedDate = now;
+[pool addObject:newConnection];  // 加入池
+```
+
+**何时触发:**
+- `dequeueConnectionForHost` 找不到可复用连接
+- 创建新连接并成功打开
+
+### 2. IDLE → IN_USE (复用)
+
+**HttpdnsNWHTTPClient.m:210-214**
+```objc
+for (HttpdnsNWReusableConnection *candidate in pool) {
+    if (!candidate.inUse && [candidate isViable]) {
+        candidate.inUse = YES;
+        candidate.lastUsedDate = now;
+        connection = candidate;
+        break;
+    }
+}
+```
+
+**关键检查:**
+- `!candidate.inUse` - 必须是空闲状态
+- `[candidate isViable]` - 连接必须仍然有效
+
+### 3. IN_USE → IDLE (正常归还)
+
+**HttpdnsNWHTTPClient.m:283-288**
+```objc
+if (shouldClose || connection.isInvalidated) {
+    // → INVALIDATED (见#4)
+} else {
+    connection.inUse = NO;
+    connection.lastUsedDate = now;
+    if (![pool containsObject:connection]) {
+        [pool addObject:connection];  // 防止双重添加
+    }
+    [self pruneConnectionPool:pool referenceDate:now];
+}
+```
+
+**防护措施:**
+- Line 285: `if (![pool containsObject:connection])` - 防止重复添加
+
+### 4. IN_USE/IDLE → INVALIDATED (失效)
+
+**HttpdnsNWHTTPClient.m:279-281**
+```objc
+if (shouldClose || connection.isInvalidated) {
+    [connection invalidate];
+    [pool removeObject:connection];
+}
+```
+
+**触发条件:**
+- `shouldClose=YES` (timeout, error, parse failure, remote close)
+- `connection.isInvalidated=YES` (连接已失效)
+
+### 5. EXPIRED → INVALIDATED (过期清理)
+
+**HttpdnsNWHTTPClient.m:297-312**
+```objc
+- (void)pruneConnectionPool:(NSMutableArray<HttpdnsNWReusableConnection *> *)pool referenceDate:(NSDate *)referenceDate {
+    // ...
+    NSMutableArray<HttpdnsNWReusableConnection *> *toRemove = [NSMutableArray array];
+    for (HttpdnsNWReusableConnection *conn in pool) {
+        if (conn.inUse) continue;  // 跳过使用中的
+
+        NSTimeInterval idle = [referenceDate timeIntervalSinceDate:conn.lastUsedDate];
+        if (idle > kHttpdnsNWHTTPClientConnectionIdleTimeout) {  // 30秒
+            [toRemove addObject:conn];
+        }
+    }
+
+    for (HttpdnsNWReusableConnection *conn in toRemove) {
+        [conn invalidate];
+        [pool removeObject:conn];
+    }
+
+    // 限制池大小 ≤ 4
+    while (pool.count > kHttpdnsNWHTTPClientMaxIdleConnectionsPerHost) {
+        HttpdnsNWReusableConnection *oldest = pool.firstObject;
+        [oldest invalidate];
+        [pool removeObject:oldest];
+    }
+}
+```
+
+---
+
+## 当前测试覆盖情况
+
+### ✅ 已测试的正常流程
+
+| 状态转换 | 测试 | 覆盖 |
+|----------|------|------|
+| CREATING → IN_USE → IDLE | G.1-G.7, O.1 | ✅ |
+| IDLE → IN_USE (复用) | G.2, O.1-O.3, J.1-J.5 | ✅ |
+| IN_USE → INVALIDATED (timeout) | P.1-P.6 | ✅ |
+| EXPIRED → INVALIDATED (30s) | J.2, M.4, I.4 | ✅ |
+| 池容量限制 (max 4) | O.3, J.3 | ✅ |
+| 并发状态访问 | I.1-I.5, M.3 | ✅ |
+
+### ❌ 未测试的异常场景
+
+#### 1. **连接在池中失效（Stale Connection）**
+
+**场景:**
+- 连接空闲 29 秒（未到 30 秒过期）
+- 服务器主动关闭连接
+- `dequeue` 时 `isViable` 返回 NO
+
+**当前代码行为:**
+```objc
+for (HttpdnsNWReusableConnection *candidate in pool) {
+    if (!candidate.inUse && [candidate isViable]) {  // ← isViable 检查
+        // 只复用有效连接
+    }
+}
+// 如果所有连接都 !isViable，会创建新连接
+```
+
+**风险:** 未验证 `isViable` 检查是否真的工作
+
+**测试需求:** Q.1
+```objc
+testStateTransition_StaleConnectionInPool_SkipsAndCreatesNew
+```
+
+---
+
+#### 2. **双重归还（Double Return）**
+
+**场景:**
+- 连接被归还
+- 代码错误，再次归还同一连接
+
+**当前代码防护:**
+```objc
+if (![pool containsObject:connection]) {
+    [pool addObject:connection];  // ← 防止重复添加
+}
+```
+
+**风险:** 未验证防护是否有效
+
+**测试需求:** Q.2
+```objc
+testStateTransition_DoubleReturn_Idempotent
+```
+
+---
+
+#### 3. **归还错误的池键（Wrong Pool Key）**
+
+**场景:**
+- 从池A借出连接
+- 归还到池B（错误的key）
+
+**当前代码行为:**
+```objc
+- (void)returnConnection:(HttpdnsNWReusableConnection *)connection
+                   forKey:(NSString *)key
+              shouldClose:(BOOL)shouldClose {
+    // ...
+    NSMutableArray<HttpdnsNWReusableConnection *> *pool = self.connectionPool[key];
+    // 会添加到错误的池!
+}
+```
+
+**风险:** 可能导致池污染
+
+**测试需求:** Q.3
+```objc
+testStateTransition_ReturnToWrongPool_Isolated
+```
+
+---
+
+#### 4. **连接在使用中变为失效**
+
+**场景:**
+- 连接被借出 (inUse=YES)
+- `sendRequestData` 过程中网络错误
+- 连接被标记 invalidated
+
+**当前代码行为:**
+```objc
+NSData *rawResponse = [connection sendRequestData:requestData ...];
+if (!rawResponse) {
+    [self returnConnection:connection forKey:poolKey shouldClose:YES];  // ← invalidated
+}
+```
+
+**测试需求:** Q.4
+```objc
+testStateTransition_ErrorDuringUse_Invalidated
+```
+
+---
+
+#### 5. **池容量超限时的移除策略**
+
+**场景:**
+- 池已有 4 个连接
+- 第 5 个连接被归还
+
+**当前代码行为:**
+```objc
+while (pool.count > kHttpdnsNWHTTPClientMaxIdleConnectionsPerHost) {
+    HttpdnsNWReusableConnection *oldest = pool.firstObject;  // ← 移除最老的
+    [oldest invalidate];
+    [pool removeObject:oldest];
+}
+```
+
+**问题:**
+- 移除 `pool.firstObject` - 是按添加顺序还是使用顺序？
+- NSMutableArray 顺序是否能保证？
+
+**测试需求:** Q.5
+```objc
+testStateTransition_PoolOverflow_RemovesOldest
+```
+
+---
+
+#### 6. **并发状态竞态**
+
+**场景:**
+- Thread A: dequeue 连接，设置 `inUse=YES`
+- Thread B: 同时 prune 过期连接
+- 竞态：连接同时被标记 inUse 和被移除
+
+**当前代码防护:**
+```objc
+- (void)pruneConnectionPool:... {
+    for (HttpdnsNWReusableConnection *conn in pool) {
+        if (conn.inUse) continue;  // ← 跳过使用中的
+    }
+}
+```
+
+**测试需求:** Q.6 (可能已被 I 组部分覆盖)
+```objc
+testStateTransition_ConcurrentDequeueAndPrune_NoCorruption
+```
+
+---
+
+#### 7. **连接打开失败**
+
+**场景:**
+- 创建连接
+- `openWithTimeout` 失败
+
+**当前代码行为:**
+```objc
+if (![newConnection openWithTimeout:timeout error:error]) {
+    [newConnection invalidate];  // ← 立即失效
+    return nil;                  // ← 不加入池
+}
+```
+
+**测试需求:** Q.7
+```objc
+testStateTransition_OpenFails_NotAddedToPool
+```
+
+---
+
+## 状态不变式（State Invariants）
+
+### 应该始终成立的约束
+
+1. **互斥性:**
+   ```
+   ∀ connection: (inUse=YES) ⇒ (dequeue count ≤ 1)
+   ```
+   同一连接不能被多次借出
+
+2. **池完整性:**
+   ```
+   ∀ pool: ∑(connections) ≤ maxPoolSize (4)
+   ```
+   每个池最多 4 个连接
+
+3. **状态一致性:**
+   ```
+   ∀ connection in pool: !invalidated
+   ```
+   池中不应有失效连接
+
+4. **时间单调性:**
+   ```
+   ∀ connection: lastUsedDate 随每次使用递增
+   ```
+
+5. **失效不可逆:**
+   ```
+   invalidated=YES ⇒ connection removed from pool
+   ```
+   失效连接必须从池中移除
+
+---
+
+## 测试设计建议
+
+### Q 组：状态机异常转换测试（7个新测试）
+
+| 测试 | 验证内容 | 难度 |
+|------|---------|------|
+| **Q.1** | Stale connection 被 `isViable` 检测并跳过 | 🔴 高（需要模拟服务器关闭） |
+| **Q.2** | 双重归还是幂等的 | 🟢 低 |
+| **Q.3** | 归还到错误池键不污染其他池 | 🟡 中 |
+| **Q.4** | 使用中错误导致连接失效 | 🟢 低（已有 P 组部分覆盖） |
+| **Q.5** | 池溢出时移除最旧连接 | 🟡 中 |
+| **Q.6** | 并发 dequeue/prune 竞态 | 🔴 高（需要精确时序） |
+| **Q.7** | 打开失败的连接不加入池 | 🟢 低 |
+
+---
+
+## 状态机验证策略
+
+### 方法1: 直接状态检查
+
+```objc
+// 验证状态属性
+XCTAssertTrue(connection.inUse);
+XCTAssertFalse(connection.isInvalidated);
+XCTAssertEqual([poolCount], expectedCount);
+```
+
+### 方法2: 状态转换序列
+
+```objc
+// 验证转换序列
+[client resetPoolStatistics];
+
+// CREATING → IN_USE
+response1 = [client performRequest...];
+XCTAssertEqual(creationCount, 1);
+
+// IN_USE → IDLE
+[NSThread sleepForTimeInterval:0.5];
+XCTAssertEqual(poolCount, 1);
+
+// IDLE → IN_USE (reuse)
+response2 = [client performRequest...];
+XCTAssertEqual(reuseCount, 1);
+```
+
+### 方法3: 不变式验证
+
+```objc
+// 验证池不变式
+NSArray *keys = [client allConnectionPoolKeys];
+for (NSString *key in keys) {
+    NSUInteger count = [client connectionPoolCountForKey:key];
+    XCTAssertLessThanOrEqual(count, 4, @"Pool invariant: max 4 connections");
+}
+```
+
+---
+
+## 当前覆盖率评估
+
+### 状态转换覆盖矩阵
+
+| From ↓ / To → | CREATING | IN_USE | IDLE | EXPIRED | INVALIDATED |
+|---------------|----------|--------|------|---------|-------------|
+| **CREATING**  | - | ✅ | ❌ | ❌ | ✅ (Q.7 needed) |
+| **IN_USE**    | ❌ | - | ✅ | ❌ | ✅ |
+| **IDLE**      | ❌ | ✅ | - | ✅ | ❌ (Q.1 needed) |
+| **EXPIRED**   | ❌ | ❌ | ❌ | - | ✅ |
+| **INVALIDATED** | ❌ | ❌ | ❌ | ❌ | - |
+
+**覆盖率:** 6/25 transitions = 24%
+**有效覆盖率:** 6/10 valid transitions = 60%
+
+### 异常场景覆盖
+
+| 异常场景 | 当前测试 | 覆盖 |
+|----------|---------|------|
+| Stale connection | ❌ | 0% |
+| Double return | ❌ | 0% |
+| Wrong pool key | ❌ | 0% |
+| Error during use | P.1-P.6 | 100% |
+| Pool overflow | O.3, J.3 | 50% (未验证移除策略) |
+| Concurrent race | I.1-I.5 | 80% |
+| Open failure | ❌ | 0% |
+
+**总体异常覆盖:** ~40%
+
+---
+
+## 风险评估
+
+### 高风险未测试场景
+
+**风险等级 🔴 高:**
+1. **Stale Connection (Q.1)** - 可能导致请求失败
+2. **Concurrent Dequeue/Prune (Q.6)** - 可能导致状态不一致
+
+**风险等级 🟡 中:**
+3. **Wrong Pool Key (Q.3)** - 可能导致池污染
+4. **Pool Overflow Strategy (Q.5)** - LRU vs FIFO 影响性能
+
+**风险等级 🟢 低:**
+5. **Double Return (Q.2)** - 已有代码防护
+6. **Open Failure (Q.7)** - 已有错误处理
+
+---
+
+## 建议
+
+### 短期（关键）
+
+1. ✅ **添加 Q.2 测试** - 验证双重归还防护
+2. ✅ **添加 Q.5 测试** - 验证池溢出移除策略
+3. ✅ **添加 Q.7 测试** - 验证打开失败处理
+
+### 中期（增强）
+
+4. ⚠️ **添加 Q.3 测试** - 验证池隔离
+5. ⚠️ **添加 Q.1 测试** - 验证 stale connection（需要 mock）
+
+### 长期（完整）
+
+6. 🔬 **添加 Q.6 测试** - 验证并发竞态（复杂）
+
+---
+
+**创建时间**: 2025-11-01
+**作者**: Claude Code
+**状态**: 分析完成，待实现 Q 组测试

EdgeHttpDNS/sdk/ios/AlicloudHttpDNSTests/Network/TIMEOUT_ANALYSIS.md

@@ -0,0 +1,226 @@
+# 超时对连接复用的影响分析
+
+## 问题描述
+
+当前测试套件没有充分验证**超时与连接池交互**的"无形结果"（intangible outcomes），可能存在以下风险：
+- 超时后的连接泄漏
+- 连接池被超时连接污染
+- 连接池无法从超时中恢复
+- 并发场景下部分超时影响整体池健康
+
+---
+
+## 代码行为分析
+
+### 超时处理流程
+
+**HttpdnsNWHTTPClient.m:144-145**
+```objc
+if (!rawResponse) {
+    [self returnConnection:connection forKey:poolKey shouldClose:YES];
+    // 返回 nil，error 设置
+}
+```
+
+**returnConnection:forKey:shouldClose: (line 279-281)**
+```objc
+if (shouldClose || connection.isInvalidated) {
+    [connection invalidate];    // 取消底层 nw_connection
+    [pool removeObject:connection];  // 从池中移除
+}
+```
+
+**结论**：代码逻辑正确，超时连接**会被移除**而非留在池中。
+
+---
+
+## 当前测试覆盖情况
+
+### 已有测试：`testIntegration_RequestTimeout_ReturnsError`
+
+**验证内容：**
+- ✅ 超时返回 `nil` response
+- ✅ 超时设置 `error`
+
+**未验证内容（缺失）：**
+- ❌ 连接是否从池中移除
+- ❌ 池计数是否正确
+- ❌ 后续请求是否正常工作
+- ❌ 是否存在连接泄漏
+- ❌ 并发场景下部分超时的影响
+
+---
+
+## 需要验证的"无形结果"
+
+### 1. 单次超时后的池清理
+
+**场景**：
+1. 请求 A 超时（timeout=1s, endpoint=/delay/10）
+2. 验证池状态
+
+**应验证：**
+- Pool count = 0（连接已移除）
+- Total connection count 没有异常增长
+- 无连接泄漏
+
+**测试方法**：
+```objc
+[client resetPoolStatistics];
+
+// 发起超时请求
+NSError *error = nil;
+HttpdnsNWHTTPClientResponse *response = [client performRequestWithURLString:@"http://127.0.0.1:11080/delay/10"
+                                                                   userAgent:@"TimeoutTest"
+                                                                     timeout:1.0
+                                                                       error:&error];
+
+XCTAssertNil(response);
+XCTAssertNotNil(error);
+
+// 验证池状态
+NSString *poolKey = @"127.0.0.1:11080:tcp";
+XCTAssertEqual([client connectionPoolCountForKey:poolKey], 0, @"Timed-out connection should be removed");
+XCTAssertEqual([client totalConnectionCount], 0, @"No connections should remain");
+XCTAssertEqual(client.connectionCreationCount, 1, @"Should have created 1 connection");
+XCTAssertEqual(client.connectionReuseCount, 0, @"No reuse for timed-out connection");
+```
+
+---
+
+### 2. 超时后的池恢复能力
+
+**场景**：
+1. 请求 A 超时
+2. 请求 B 正常（验证池恢复）
+3. 请求 C 复用 B 的连接
+
+**应验证：**
+- 请求 B 成功（池已恢复）
+- 请求 C 复用连接（connectionReuseCount = 1）
+- Pool count = 1（只有 B/C 的连接）
+
+---
+
+### 3. 并发场景：部分超时不影响成功请求
+
+**场景**：
+1. 并发发起 10 个请求
+2. 5 个正常（timeout=15s）
+3. 5 个超时（timeout=0.5s, endpoint=/delay/10）
+
+**应验证：**
+- 5 个正常请求成功
+- 5 个超时请求失败
+- Pool count ≤ 5（只保留成功的连接）
+- Total connection count ≤ 5（无泄漏）
+- connectionCreationCount ≤ 10（合理范围）
+- 成功的请求可以复用连接
+
+---
+
+### 4. 连续超时不导致资源泄漏
+
+**场景**：
+1. 连续 20 次超时请求
+2. 验证连接池没有累积"僵尸连接"
+
+**应验证：**
+- Pool count = 0
+- Total connection count = 0
+- connectionCreationCount = 20（每次都创建新连接，因为超时的被移除）
+- connectionReuseCount = 0（超时连接不可复用）
+- 无内存泄漏（虽然代码层面无法直接测试）
+
+---
+
+### 5. 超时不阻塞连接池
+
+**场景**：
+1. 请求 A 超时（endpoint=/delay/10, timeout=1s）
+2. 同时请求 B 正常（endpoint=/get, timeout=15s）
+
+**应验证：**
+- 请求 A 和 B 并发执行（不互相阻塞）
+- 请求 B 成功（不受 A 超时影响）
+- 请求 A 的超时连接被正确移除
+- Pool 中只有请求 B 的连接
+
+---
+
+### 6. 多端口场景下的超时隔离
+
+**场景**：
+1. 端口 11443 请求超时
+2. 端口 11444 请求正常
+3. 验证端口间隔离
+
+**应验证：**
+- 端口 11443 pool count = 0
+- 端口 11444 pool count = 1
+- 两个端口的连接池互不影响
+
+---
+
+## 测试实现建议
+
+### P 组：超时与连接池交互测试
+
+**P.1 单次超时清理验证**
+- `testTimeout_SingleRequest_ConnectionRemovedFromPool`
+
+**P.2 超时后池恢复**
+- `testTimeout_PoolRecovery_SubsequentRequestSucceeds`
+
+**P.3 并发部分超时**
+- `testTimeout_ConcurrentPartialTimeout_SuccessfulRequestsReuse`
+
+**P.4 连续超时无泄漏**
+- `testTimeout_ConsecutiveTimeouts_NoConnectionLeak`
+
+**P.5 超时不阻塞池**
+- `testTimeout_NonBlocking_ConcurrentNormalRequestSucceeds`
+
+**P.6 多端口超时隔离**
+- `testTimeout_MultiPort_IsolatedPoolCleaning`
+
+---
+
+## Mock Server 支持
+
+需要添加可配置延迟的 endpoint：
+- `/delay/10` - 延迟 10 秒（已有）
+- 测试时设置短 timeout（如 0.5s-2s）触发超时
+
+---
+
+## 预期测试结果
+
+| 验证项 | 当前状态 | 目标状态 |
+|--------|---------|---------|
+| 超时连接移除 | 未验证 | ✅ 验证池计数=0 |
+| 池恢复能力 | 未验证 | ✅ 后续请求成功 |
+| 并发超时隔离 | 未验证 | ✅ 成功请求不受影响 |
+| 无连接泄漏 | 未验证 | ✅ 总连接数稳定 |
+| 超时不阻塞 | 未验证 | ✅ 并发执行不阻塞 |
+| 多端口隔离 | 未验证 | ✅ 端口间独立清理 |
+
+---
+
+## 风险评估
+
+**如果不测试这些场景的风险：**
+1. **连接泄漏**：超时连接可能未正确清理，导致内存泄漏
+2. **池污染**：超时连接留在池中，被后续请求复用导致失败
+3. **级联故障**：部分超时影响整体连接池健康
+4. **资源耗尽**：连续超时累积连接，最终耗尽系统资源
+
+**当前代码逻辑正确性：** ✅ 高（代码分析显示正确处理）
+**测试验证覆盖率：** ❌ 低（缺少池交互验证）
+
+**建议：** 添加 P 组测试以提供**可观测的证据**证明超时处理正确。
+
+---
+
+**创建时间**: 2025-11-01
+**维护者**: Claude Code

EdgeHttpDNS/sdk/ios/AlicloudHttpDNSTests/Network/mock_server.py

@@ -0,0 +1,347 @@
+#!/usr/bin/env python3
+"""
+HTTP/HTTPS Mock Server for HttpdnsNWHTTPClient Integration Tests
+
+模拟 httpbin.org 的核心功能，用于替代不稳定的外部依赖。
+支持 HTTP (端口 11080) 和多个 HTTPS 端口 (11443-11446，自签名证书)。
+
+使用方法:
+    python3 mock_server.py
+
+端口配置:
+    - HTTP:  127.0.0.1:11080
+    - HTTPS: 127.0.0.1:11443, 11444, 11445, 11446
+
+注意:
+    - 使用非特权端口，无需 root 权限
+    - HTTPS 使用自签名证书，测试时需禁用 TLS 验证
+    - 多个 HTTPS 端口用于测试连接池隔离
+    - 按 Ctrl+C 停止服务器
+"""
+
+import json
+import time
+import uuid
+import ssl
+import os
+import subprocess
+import signal
+import sys
+from http.server import HTTPServer, BaseHTTPRequestHandler
+from urllib.parse import urlparse
+from threading import Thread
+from socketserver import ThreadingMixIn
+
+
+class ThreadedHTTPServer(ThreadingMixIn, HTTPServer):
+    """多线程 HTTP 服务器，支持并发请求"""
+    daemon_threads = True
+    allow_reuse_address = True
+
+
+class MockHTTPHandler(BaseHTTPRequestHandler):
+    """模拟 httpbin.org 的请求处理器"""
+
+    # 使用 HTTP/1.1 协议（支持 keep-alive）
+    protocol_version = 'HTTP/1.1'
+
+    # 禁用日志输出（可选，便于查看测试输出）
+    def log_message(self, format, *args):
+        # 取消注释以启用详细日志
+        # print(f"[{self.address_string()}] {format % args}")
+        pass
+
+    def do_GET(self):
+        """处理 GET 请求"""
+        path = urlparse(self.path).path
+
+        if path == '/get':
+            self._handle_get()
+        elif path.startswith('/status/'):
+            self._handle_status(path)
+        elif path.startswith('/stream-bytes/'):
+            self._handle_stream_bytes(path)
+        elif path.startswith('/delay/'):
+            self._handle_delay(path)
+        elif path == '/headers':
+            self._handle_headers()
+        elif path == '/uuid':
+            self._handle_uuid()
+        elif path == '/user-agent':
+            self._handle_user_agent()
+        elif path == '/connection-test':
+            self._handle_connection_test()
+        else:
+            self._handle_not_found()
+
+    def _handle_get(self):
+        """模拟 /get - 返回请求信息"""
+        data = {
+            'args': {},
+            'headers': dict(self.headers),
+            'origin': self.client_address[0],
+            'url': f'{self.command} {self.path}'
+        }
+        self._send_json(200, data)
+
+    def _handle_status(self, path):
+        """模拟 /status/{code} - 返回指定状态码"""
+        try:
+            status_code = int(path.split('/')[-1])
+            # 限制状态码范围在 100-599
+            if 100 <= status_code < 600:
+                self._send_json(status_code, {'status': status_code})
+            else:
+                self._send_json(400, {'error': 'Invalid status code'})
+        except (ValueError, IndexError):
+            self._send_json(400, {'error': 'Invalid status code format'})
+
+    def _handle_stream_bytes(self, path):
+        """模拟 /stream-bytes/{n} - 返回 chunked 编码的 n 字节数据"""
+        try:
+            n = int(path.split('/')[-1])
+        except (ValueError, IndexError):
+            self._send_json(400, {'error': 'Invalid byte count'})
+            return
+
+        # 发送 chunked 响应
+        self.send_response(200)
+        self.send_header('Content-Type', 'application/octet-stream')
+        self.send_header('Transfer-Encoding', 'chunked')
+        self.send_header('Connection', 'keep-alive')
+        self.end_headers()
+
+        # 发送 chunk
+        chunk_data = b'X' * n
+        chunk_size_hex = f'{n:x}\r\n'.encode('utf-8')
+        self.wfile.write(chunk_size_hex)
+        self.wfile.write(chunk_data)
+        self.wfile.write(b'\r\n')
+
+        # 发送最后一个 chunk (size=0)
+        self.wfile.write(b'0\r\n\r\n')
+        self.wfile.flush()  # 确保数据发送
+
+    def _handle_delay(self, path):
+        """模拟 /delay/{seconds} - 延迟指定秒数后返回"""
+        try:
+            seconds = int(path.split('/')[-1])
+        except (ValueError, IndexError):
+            self._send_json(400, {'error': 'Invalid delay value'})
+            return
+
+        # 最多延迟 10 秒（防止意外）
+        seconds = min(seconds, 10)
+        time.sleep(seconds)
+
+        data = {
+            'args': {},
+            'headers': dict(self.headers),
+            'origin': self.client_address[0],
+            'url': f'{self.command} {self.path}',
+            'delayed': seconds
+        }
+        self._send_json(200, data)
+
+    def _handle_headers(self):
+        """模拟 /headers - 返回所有请求头部"""
+        data = {
+            'headers': dict(self.headers)
+        }
+        self._send_json(200, data)
+
+    def _handle_uuid(self):
+        """模拟 /uuid - 返回随机 UUID"""
+        data = {
+            'uuid': str(uuid.uuid4())
+        }
+        self._send_json(200, data)
+
+    def _handle_user_agent(self):
+        """模拟 /user-agent - 返回 User-Agent 头部"""
+        data = {
+            'user-agent': self.headers.get('User-Agent', '')
+        }
+        self._send_json(200, data)
+
+    def _handle_connection_test(self):
+        """处理 /connection-test - 返回指定的 Connection 头部用于测试"""
+        from urllib.parse import parse_qs
+
+        # 解析查询参数
+        query_string = urlparse(self.path).query
+        params = parse_qs(query_string)
+        mode = params.get('mode', ['keep-alive'])[0]
+
+        data = {
+            'mode': mode,
+            'message': f'Connection header test with mode: {mode}'
+        }
+
+        body = json.dumps(data).encode('utf-8')
+        self.send_response(200)
+        self.send_header('Content-Type', 'application/json')
+        self.send_header('Content-Length', len(body))
+
+        # 根据 mode 参数设置不同的 Connection 头部
+        if mode == 'close':
+            self.send_header('Connection', 'close')
+        elif mode == 'proxy-close':
+            self.send_header('Proxy-Connection', 'close')
+            self.send_header('Connection', 'keep-alive')
+        elif mode == 'close-uppercase':
+            self.send_header('CONNECTION', 'CLOSE')
+        elif mode == 'close-mixed':
+            self.send_header('Connection', 'Close')
+        else:  # keep-alive (default)
+            self.send_header('Connection', 'keep-alive')
+
+        self.end_headers()
+        self.wfile.write(body)
+        self.wfile.flush()
+
+    def _handle_not_found(self):
+        """处理未知路径"""
+        self._send_json(404, {'error': 'Not Found', 'path': self.path})
+
+    def _send_json(self, status_code, data):
+        """发送 JSON 响应"""
+        try:
+            body = json.dumps(data).encode('utf-8')
+            self.send_response(status_code)
+            self.send_header('Content-Type', 'application/json')
+            self.send_header('Content-Length', len(body))
+            # 支持 HTTP/1.1 keep-alive
+            self.send_header('Connection', 'keep-alive')
+            self.end_headers()
+            self.wfile.write(body)
+            self.wfile.flush()  # 确保数据发送
+        except Exception as e:
+            print(f"Error sending response: {e}", file=sys.stderr)
+
+
+def create_self_signed_cert(cert_file='server.pem'):
+    """生成自签名证书（如果不存在）"""
+    if os.path.exists(cert_file):
+        print(f"✓ 使用现有证书: {cert_file}")
+        return cert_file
+
+    print(f"正在生成自签名证书: {cert_file} ...")
+    try:
+        subprocess.run([
+            'openssl', 'req', '-x509', '-newkey', 'rsa:2048',
+            '-keyout', cert_file, '-out', cert_file,
+            '-days', '365', '-nodes',
+            '-subj', '/CN=localhost'
+        ], check=True, capture_output=True)
+        print(f"✓ 证书生成成功")
+        return cert_file
+    except subprocess.CalledProcessError as e:
+        print(f"✗ 证书生成失败: {e.stderr.decode()}", file=sys.stderr)
+        sys.exit(1)
+    except FileNotFoundError:
+        print("✗ 未找到 openssl 命令，请安装 OpenSSL", file=sys.stderr)
+        sys.exit(1)
+
+
+def run_http_server(port=11080):
+    """运行 HTTP 服务器"""
+    try:
+        server = ThreadedHTTPServer(('127.0.0.1', port), MockHTTPHandler)
+        print(f"✓ HTTP 服务器运行在 http://127.0.0.1:{port}")
+        server.serve_forever()
+    except OSError as e:
+        if e.errno == 48:  # Address already in use
+            print(f"✗ 端口 {port} 已被占用，请关闭占用端口的进程或使用其他端口", file=sys.stderr)
+        else:
+            print(f"✗ HTTP 服务器启动失败: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+def run_https_server(port=11443, cert_file='server.pem'):
+    """运行 HTTPS 服务器（使用自签名证书）"""
+    try:
+        server = ThreadedHTTPServer(('127.0.0.1', port), MockHTTPHandler)
+
+        # 配置 SSL 上下文
+        context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+        context.load_cert_chain(cert_file)
+
+        # 包装 socket
+        server.socket = context.wrap_socket(server.socket, server_side=True)
+
+        print(f"✓ HTTPS 服务器运行在 https://127.0.0.1:{port} (自签名证书)")
+        server.serve_forever()
+    except OSError as e:
+        if e.errno == 48:  # Address already in use
+            print(f"✗ 端口 {port} 已被占用，请关闭占用端口的进程或使用其他端口", file=sys.stderr)
+        else:
+            print(f"✗ HTTPS 服务器启动失败: {e}", file=sys.stderr)
+        sys.exit(1)
+    except ssl.SSLError as e:
+        print(f"✗ SSL 配置失败: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+def signal_handler(sig, frame):
+    """处理 Ctrl+C 信号"""
+    print("\n\n✓ 服务器已停止")
+    sys.exit(0)
+
+
+def main():
+    """主函数"""
+    # 注册信号处理器
+    signal.signal(signal.SIGINT, signal_handler)
+
+    # 生成自签名证书
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    cert_file = os.path.join(script_dir, 'server.pem')
+    create_self_signed_cert(cert_file)
+
+    print("\n" + "="*60)
+    print("  HttpdnsNWHTTPClient Mock Server")
+    print("="*60)
+    print("\n支持的 endpoints:")
+    print("  GET /get              - 返回请求信息")
+    print("  GET /status/{code}    - 返回指定状态码")
+    print("  GET /stream-bytes/N   - 返回 chunked 编码的 N 字节数据")
+    print("  GET /delay/N          - 延迟 N 秒后返回")
+    print("  GET /headers          - 返回所有请求头部")
+    print("  GET /uuid             - 返回随机 UUID")
+    print("  GET /user-agent       - 返回 User-Agent 头部")
+    print("  GET /connection-test?mode={mode}")
+    print("                        - 返回指定 Connection 头部")
+    print("                          mode: close, keep-alive, proxy-close,")
+    print("                                close-uppercase, close-mixed")
+    print("\n按 Ctrl+C 停止服务器\n")
+    print("="*60 + "\n")
+
+    # 启动 HTTP 和 HTTPS 服务器（使用线程）
+    http_thread = Thread(target=run_http_server, args=(11080,), daemon=True)
+
+    # 启动多个 HTTPS 端口用于测试连接复用隔离
+    https_ports = [11443, 11444, 11445, 11446]
+    https_threads = []
+
+    http_thread.start()
+    time.sleep(0.5)  # 等待 HTTP 服务器启动
+
+    # 启动所有 HTTPS 服务器
+    for port in https_ports:
+        https_thread = Thread(target=run_https_server, args=(port, cert_file), daemon=True)
+        https_threads.append(https_thread)
+        https_thread.start()
+        time.sleep(0.1)  # 错峰启动避免端口冲突
+
+    # 主线程等待（保持服务器运行）
+    try:
+        http_thread.join()
+        for thread in https_threads:
+            thread.join()
+    except KeyboardInterrupt:
+        signal_handler(signal.SIGINT, None)
+
+
+if __name__ == '__main__':
+    main()