Reorganize crate structure and move documentation files

16 files changed, 967 insertions, 0 deletions

diff --git a/utils/tcp_connection/tcp_connection_test/Cargo.toml b/utils/tcp_connection/tcp_connection_test/Cargo.toml
new file mode 100644
index 0000000..19a6e9b
--- /dev/null
+++ b/utils/tcp_connection/tcp_connection_test/Cargo.toml
@@ -0,0 +1,9 @@
+[package]
+name = "tcp_connection_test"
+edition = "2024"
+version.workspace = true
+
+[dependencies]
+tcp_connection = { path = "../../tcp_connection" }
+tokio = { version = "1.48.0", features = ["full"] }
+serde = { version = "1.0.228", features = ["derive"] }
diff --git a/utils/tcp_connection/tcp_connection_test/res/image/test_transfer.png b/utils/tcp_connection/tcp_connection_test/res/image/test_transfer.png
new file mode 100644
index 0000000..5fa94f0
--- /dev/null
+++ b/utils/tcp_connection/tcp_connection_test/res/image/test_transfer.png
diff --git a/utils/tcp_connection/tcp_connection_test/res/key/test_key.pem b/utils/tcp_connection/tcp_connection_test/res/key/test_key.pem
new file mode 100644
index 0000000..e155876
--- /dev/null
+++ b/utils/tcp_connection/tcp_connection_test/res/key/test_key.pem
@@ -0,0 +1,13 @@
+-----BEGIN RSA PUBLIC KEY-----
+MIICCgKCAgEAl5vyIwGYiQ1zZpW2tg+LwOUV547T2SjlzKQjcms5je/epP4CnUfT
+5cmHCe8ZaSbnofcntCzi8FzMpQmzhNzFk5tCAe4tSrghfr2kYDO7aUL0G09KbNZ5
+iuMTkMaHx6LMjZ+Ljy8fC47yC2dFMUgLjGS7xS6rnIo4YtFuvMdwbLjs7mSn+vVc
+kcEV8RLlQg8wDbzpl66Jd1kiUgPfVLBRTLE/iL8kUCz1l8c+DvOzr3ATwJysM9CG
+LFahGLlTd3CZaj0QsEzf/AQsn79Su+rnCXhXqcvynhAcil0UW9RWp5Zsvp3Me3W8
+pJg6vZuAA6lQ062hkRLiJ91F2rpyqtkax5i/simLjelpsRzLKo6Xsz1bZht2+5d5
+ArgTBtZBxS044t8caZWLXetnPEcxEGz8KYUVKf7X9S7R53gy36y88Fbu9giqUr3m
+b3Da+SYzBT//hacGn55nhzLRdsJGaFFWcKCbpue6JHLsFhizhdEAjaec0hfphw29
+veY0adPdIFLQDmMKaNk4ulrz8Lbgpqn9gxx6fRssj9jqNJmW64a0eV+Rw7BCJazH
+xp3zz4A3rwdI8BjxLUb3YiCUcavA9WzJ1DUfdX1FSvbcFw4CEiGJjfpWGrm1jtc6
+DMOsoX/C6yFOyRpipsgqIToBClchLSNgrO6A7SIoSdIqNDEgIanFcjECAwEAAQ==
+-----END RSA PUBLIC KEY-----
diff --git a/utils/tcp_connection/tcp_connection_test/res/key/test_key_private.pem b/utils/tcp_connection/tcp_connection_test/res/key/test_key_private.pem
new file mode 100644
index 0000000..183d2d9
--- /dev/null
+++ b/utils/tcp_connection/tcp_connection_test/res/key/test_key_private.pem
@@ -0,0 +1,51 @@
+-----BEGIN RSA PRIVATE KEY-----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=
+-----END RSA PRIVATE KEY-----
diff --git a/utils/tcp_connection/tcp_connection_test/res/key/wrong_key_private.pem b/utils/tcp_connection/tcp_connection_test/res/key/wrong_key_private.pem
new file mode 100644
index 0000000..4b77eea
--- /dev/null
+++ b/utils/tcp_connection/tcp_connection_test/res/key/wrong_key_private.pem
@@ -0,0 +1,52 @@
+-----BEGIN PRIVATE KEY-----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+-----END PRIVATE KEY-----
diff --git a/utils/tcp_connection/tcp_connection_test/src/lib.rs b/utils/tcp_connection/tcp_connection_test/src/lib.rs
new file mode 100644
index 0000000..c9372d4
--- /dev/null
+++ b/utils/tcp_connection/tcp_connection_test/src/lib.rs
@@ -0,0 +1,17 @@
+#[cfg(test)]
+pub mod test_tcp_target_build;
+
+#[cfg(test)]
+pub mod test_connection;
+
+#[cfg(test)]
+pub mod test_challenge;
+
+#[cfg(test)]
+pub mod test_file_transfer;
+
+#[cfg(test)]
+pub mod test_msgpack;
+
+pub mod test_utils;
+pub use test_utils::*;
diff --git a/utils/tcp_connection/tcp_connection_test/src/test_challenge.rs b/utils/tcp_connection/tcp_connection_test/src/test_challenge.rs
new file mode 100644
index 0000000..9327b3e
--- /dev/null
+++ b/utils/tcp_connection/tcp_connection_test/src/test_challenge.rs
@@ -0,0 +1,160 @@
+use std::{env::current_dir, time::Duration};
+
+use tcp_connection::instance::ConnectionInstance;
+use tokio::{
+    join,
+    time::{sleep, timeout},
+};
+
+use crate::test_utils::{
+    handle::{ClientHandle, ServerHandle},
+    target::TcpServerTarget,
+    target_configure::ServerTargetConfig,
+};
+
+pub(crate) struct ExampleChallengeClientHandle;
+
+impl ClientHandle<ExampleChallengeServerHandle> for ExampleChallengeClientHandle {
+    async fn process(mut instance: ConnectionInstance) {
+        // Accept challenge with correct key
+        let key = current_dir()
+            .unwrap()
+            .join("res")
+            .join("key")
+            .join("test_key_private.pem");
+        let result = instance.accept_challenge(key, "test_key").await.unwrap();
+
+        // Sent success
+        assert!(result);
+        let response = instance.read_text().await.unwrap();
+
+        // Verify success
+        assert_eq!("OK", response);
+
+        // Accept challenge with wrong key
+        let key = current_dir()
+            .unwrap()
+            .join("res")
+            .join("key")
+            .join("wrong_key_private.pem");
+        let result = instance.accept_challenge(key, "test_key").await.unwrap();
+
+        // Sent success
+        assert!(result);
+        let response = instance.read_text().await.unwrap();
+
+        // Verify fail
+        assert_eq!("ERROR", response);
+
+        // Accept challenge with wrong name
+        let key = current_dir()
+            .unwrap()
+            .join("res")
+            .join("key")
+            .join("test_key_private.pem");
+        let result = instance.accept_challenge(key, "test_key__").await.unwrap();
+
+        // Sent success
+        assert!(result);
+        let response = instance.read_text().await.unwrap();
+
+        // Verify fail
+        assert_eq!("ERROR", response);
+    }
+}
+
+pub(crate) struct ExampleChallengeServerHandle;
+
+impl ServerHandle<ExampleChallengeClientHandle> for ExampleChallengeServerHandle {
+    async fn process(mut instance: ConnectionInstance) {
+        // Challenge with correct key
+        let key_dir = current_dir().unwrap().join("res").join("key");
+        let (result, key_id) = instance.challenge(key_dir).await.unwrap();
+        assert!(result);
+        assert_eq!(key_id, "test_key");
+
+        // Send response
+        instance
+            .write_text(if result { "OK" } else { "ERROR" })
+            .await
+            .unwrap();
+
+        // Challenge again
+        let key_dir = current_dir().unwrap().join("res").join("key");
+        let (result, key_id) = instance.challenge(key_dir).await.unwrap();
+        assert!(!result);
+        assert_eq!(key_id, "test_key");
+
+        // Send response
+        instance
+            .write_text(if result { "OK" } else { "ERROR" })
+            .await
+            .unwrap();
+
+        // Challenge again
+        let key_dir = current_dir().unwrap().join("res").join("key");
+        let (result, key_id) = instance.challenge(key_dir).await.unwrap();
+        assert!(!result);
+        assert_eq!(key_id, "test_key__");
+
+        // Send response
+        instance
+            .write_text(if result { "OK" } else { "ERROR" })
+            .await
+            .unwrap();
+    }
+}
+
+#[tokio::test]
+async fn test_connection_with_challenge_handle() -> Result<(), std::io::Error> {
+    let host = "localhost:5011";
+
+    // Server setup
+    let Ok(server_target) = TcpServerTarget::<
+        ExampleChallengeClientHandle,
+        ExampleChallengeServerHandle,
+    >::from_domain(host)
+    .await
+    else {
+        panic!("Test target built failed from a domain named `{}`", host);
+    };
+
+    // Client setup
+    let Ok(client_target) = TcpServerTarget::<
+        ExampleChallengeClientHandle,
+        ExampleChallengeServerHandle,
+    >::from_domain(host)
+    .await
+    else {
+        panic!("Test target built failed from a domain named `{}`", host);
+    };
+
+    let future_server = async move {
+        // Only process once
+        let configured_server = server_target.server_cfg(ServerTargetConfig::default().once());
+
+        // Listen here
+        let _ = configured_server.listen().await;
+    };
+
+    let future_client = async move {
+        // Wait for server start
+        let _ = sleep(Duration::from_secs_f32(1.5)).await;
+
+        // Connect here
+        let _ = client_target.connect().await;
+    };
+
+    let test_timeout = Duration::from_secs(10);
+
+    timeout(test_timeout, async { join!(future_client, future_server) })
+        .await
+        .map_err(|_| {
+            std::io::Error::new(
+                std::io::ErrorKind::TimedOut,
+                format!("Test timed out after {:?}", test_timeout),
+            )
+        })?;
+
+    Ok(())
+}
diff --git a/utils/tcp_connection/tcp_connection_test/src/test_connection.rs b/utils/tcp_connection/tcp_connection_test/src/test_connection.rs
new file mode 100644
index 0000000..8c3ab01
--- /dev/null
+++ b/utils/tcp_connection/tcp_connection_test/src/test_connection.rs
@@ -0,0 +1,78 @@
+use std::time::Duration;
+
+use tcp_connection::instance::ConnectionInstance;
+use tokio::{join, time::sleep};
+
+use crate::test_utils::{
+    handle::{ClientHandle, ServerHandle},
+    target::TcpServerTarget,
+    target_configure::ServerTargetConfig,
+};
+
+pub(crate) struct ExampleClientHandle;
+
+impl ClientHandle<ExampleServerHandle> for ExampleClientHandle {
+    async fn process(mut instance: ConnectionInstance) {
+        // Write name
+        let Ok(_) = instance.write_text("Peter").await else {
+            panic!("Write text failed!");
+        };
+        // Read msg
+        let Ok(result) = instance.read_text().await else {
+            return;
+        };
+        assert_eq!("Hello Peter!", result);
+    }
+}
+
+pub(crate) struct ExampleServerHandle;
+
+impl ServerHandle<ExampleClientHandle> for ExampleServerHandle {
+    async fn process(mut instance: ConnectionInstance) {
+        // Read name
+        let Ok(name) = instance.read_text().await else {
+            return;
+        };
+        // Write msg
+        let Ok(_) = instance.write_text(format!("Hello {}!", name)).await else {
+            panic!("Write text failed!");
+        };
+    }
+}
+
+#[tokio::test]
+async fn test_connection_with_example_handle() {
+    let host = "localhost:5012";
+
+    // Server setup
+    let Ok(server_target) =
+        TcpServerTarget::<ExampleClientHandle, ExampleServerHandle>::from_domain(host).await
+    else {
+        panic!("Test target built failed from a domain named `{}`", host);
+    };
+
+    // Client setup
+    let Ok(client_target) =
+        TcpServerTarget::<ExampleClientHandle, ExampleServerHandle>::from_domain(host).await
+    else {
+        panic!("Test target built failed from a domain named `{}`", host);
+    };
+
+    let future_server = async move {
+        // Only process once
+        let configured_server = server_target.server_cfg(ServerTargetConfig::default().once());
+
+        // Listen here
+        let _ = configured_server.listen().await;
+    };
+
+    let future_client = async move {
+        // Wait for server start
+        let _ = sleep(Duration::from_secs_f32(1.5)).await;
+
+        // Connect here
+        let _ = client_target.connect().await;
+    };
+
+    let _ = async { join!(future_client, future_server) }.await;
+}
diff --git a/utils/tcp_connection/tcp_connection_test/src/test_file_transfer.rs b/utils/tcp_connection/tcp_connection_test/src/test_file_transfer.rs
new file mode 100644
index 0000000..4237ea7
--- /dev/null
+++ b/utils/tcp_connection/tcp_connection_test/src/test_file_transfer.rs
@@ -0,0 +1,94 @@
+use std::{env::current_dir, time::Duration};
+
+use tcp_connection::instance::ConnectionInstance;
+use tokio::{
+    join,
+    time::{sleep, timeout},
+};
+
+use crate::test_utils::{
+    handle::{ClientHandle, ServerHandle},
+    target::TcpServerTarget,
+    target_configure::ServerTargetConfig,
+};
+
+pub(crate) struct ExampleFileTransferClientHandle;
+
+impl ClientHandle<ExampleFileTransferServerHandle> for ExampleFileTransferClientHandle {
+    async fn process(mut instance: ConnectionInstance) {
+        let image_path = current_dir()
+            .unwrap()
+            .join("res")
+            .join("image")
+            .join("test_transfer.png");
+        instance.write_file(image_path).await.unwrap();
+    }
+}
+
+pub(crate) struct ExampleFileTransferServerHandle;
+
+impl ServerHandle<ExampleFileTransferClientHandle> for ExampleFileTransferServerHandle {
+    async fn process(mut instance: ConnectionInstance) {
+        let save_path = current_dir()
+            .unwrap()
+            .join("res")
+            .join(".temp")
+            .join("image")
+            .join("test_transfer.png");
+        instance.read_file(save_path).await.unwrap();
+    }
+}
+
+#[tokio::test]
+async fn test_connection_with_challenge_handle() -> Result<(), std::io::Error> {
+    let host = "localhost:5010";
+
+    // Server setup
+    let Ok(server_target) = TcpServerTarget::<
+        ExampleFileTransferClientHandle,
+        ExampleFileTransferServerHandle,
+    >::from_domain(host)
+    .await
+    else {
+        panic!("Test target built failed from a domain named `{}`", host);
+    };
+
+    // Client setup
+    let Ok(client_target) = TcpServerTarget::<
+        ExampleFileTransferClientHandle,
+        ExampleFileTransferServerHandle,
+    >::from_domain(host)
+    .await
+    else {
+        panic!("Test target built failed from a domain named `{}`", host);
+    };
+
+    let future_server = async move {
+        // Only process once
+        let configured_server = server_target.server_cfg(ServerTargetConfig::default().once());
+
+        // Listen here
+        let _ = configured_server.listen().await;
+    };
+
+    let future_client = async move {
+        // Wait for server start
+        let _ = sleep(Duration::from_secs_f32(1.5)).await;
+
+        // Connect here
+        let _ = client_target.connect().await;
+    };
+
+    let test_timeout = Duration::from_secs(10);
+
+    timeout(test_timeout, async { join!(future_client, future_server) })
+        .await
+        .map_err(|_| {
+            std::io::Error::new(
+                std::io::ErrorKind::TimedOut,
+                format!("Test timed out after {:?}", test_timeout),
+            )
+        })?;
+
+    Ok(())
+}
diff --git a/utils/tcp_connection/tcp_connection_test/src/test_msgpack.rs b/utils/tcp_connection/tcp_connection_test/src/test_msgpack.rs
new file mode 100644
index 0000000..4c9c870
--- /dev/null
+++ b/utils/tcp_connection/tcp_connection_test/src/test_msgpack.rs
@@ -0,0 +1,103 @@
+use serde::{Deserialize, Serialize};
+use std::time::Duration;
+use tcp_connection::instance::ConnectionInstance;
+use tokio::{join, time::sleep};
+
+use crate::test_utils::{
+    handle::{ClientHandle, ServerHandle},
+    target::TcpServerTarget,
+    target_configure::ServerTargetConfig,
+};
+
+#[derive(Debug, PartialEq, Serialize, Deserialize, Default)]
+struct TestData {
+    id: u32,
+    name: String,
+}
+
+pub(crate) struct MsgPackClientHandle;
+
+impl ClientHandle<MsgPackServerHandle> for MsgPackClientHandle {
+    async fn process(mut instance: ConnectionInstance) {
+        // Test basic MessagePack serialization
+        let test_data = TestData {
+            id: 42,
+            name: "Test MessagePack".to_string(),
+        };
+
+        // Write MessagePack data
+        if let Err(e) = instance.write_msgpack(&test_data).await {
+            panic!("Write MessagePack failed: {}", e);
+        }
+
+        // Read response
+        let response: TestData = match instance.read_msgpack().await {
+            Ok(data) => data,
+            Err(e) => panic!("Read MessagePack response failed: {}", e),
+        };
+
+        // Verify response
+        assert_eq!(response.id, test_data.id * 2);
+        assert_eq!(response.name, format!("Processed: {}", test_data.name));
+    }
+}
+
+pub(crate) struct MsgPackServerHandle;
+
+impl ServerHandle<MsgPackClientHandle> for MsgPackServerHandle {
+    async fn process(mut instance: ConnectionInstance) {
+        // Read MessagePack data
+        let received_data: TestData = match instance.read_msgpack().await {
+            Ok(data) => data,
+            Err(_) => return,
+        };
+
+        // Process data
+        let response = TestData {
+            id: received_data.id * 2,
+            name: format!("Processed: {}", received_data.name),
+        };
+
+        // Write response as MessagePack
+        if let Err(e) = instance.write_msgpack(&response).await {
+            panic!("Write MessagePack response failed: {}", e);
+        }
+    }
+}
+
+#[tokio::test]
+async fn test_msgpack_basic() {
+    let host = "localhost:5013";
+
+    // Server setup
+    let Ok(server_target) =
+        TcpServerTarget::<MsgPackClientHandle, MsgPackServerHandle>::from_domain(host).await
+    else {
+        panic!("Test target built failed from a domain named `{}`", host);
+    };
+
+    // Client setup
+    let Ok(client_target) =
+        TcpServerTarget::<MsgPackClientHandle, MsgPackServerHandle>::from_domain(host).await
+    else {
+        panic!("Test target built failed from a domain named `{}`", host);
+    };
+
+    let future_server = async move {
+        // Only process once
+        let configured_server = server_target.server_cfg(ServerTargetConfig::default().once());
+
+        // Listen here
+        let _ = configured_server.listen().await;
+    };
+
+    let future_client = async move {
+        // Wait for server start
+        let _ = sleep(Duration::from_secs_f32(1.5)).await;
+
+        // Connect here
+        let _ = client_target.connect().await;
+    };
+
+    let _ = async { join!(future_client, future_server) }.await;
+}
diff --git a/utils/tcp_connection/tcp_connection_test/src/test_tcp_target_build.rs b/utils/tcp_connection/tcp_connection_test/src/test_tcp_target_build.rs
new file mode 100644
index 0000000..aa1ec74
--- /dev/null
+++ b/utils/tcp_connection/tcp_connection_test/src/test_tcp_target_build.rs
@@ -0,0 +1,32 @@
+use crate::{
+    test_connection::{ExampleClientHandle, ExampleServerHandle},
+    test_utils::target::TcpServerTarget,
+};
+
+#[test]
+fn test_tcp_test_target_build() {
+    let host = "127.0.0.1:8080";
+
+    // Test build target by string
+    let Ok(target) =
+        TcpServerTarget::<ExampleClientHandle, ExampleServerHandle>::from_address_str(host)
+    else {
+        panic!("Test target built failed from a target addr `{}`", host);
+    };
+    assert_eq!(target.to_string(), "127.0.0.1:8080");
+}
+
+#[tokio::test]
+async fn test_tcp_test_target_build_domain() {
+    let host = "localhost";
+
+    // Test build target by DomainName and Connection
+    let Ok(target) =
+        TcpServerTarget::<ExampleClientHandle, ExampleServerHandle>::from_domain(host).await
+    else {
+        panic!("Test target built failed from a domain named `{}`", host);
+    };
+
+    // Test into string
+    assert_eq!(target.to_string(), "127.0.0.1:8080");
+}
diff --git a/utils/tcp_connection/tcp_connection_test/src/test_utils.rs b/utils/tcp_connection/tcp_connection_test/src/test_utils.rs
new file mode 100644
index 0000000..badf27d
--- /dev/null
+++ b/utils/tcp_connection/tcp_connection_test/src/test_utils.rs
@@ -0,0 +1,4 @@
+pub mod handle;
+pub mod target;
+pub mod target_configure;
+pub mod target_connection;
diff --git a/utils/tcp_connection/tcp_connection_test/src/test_utils/handle.rs b/utils/tcp_connection/tcp_connection_test/src/test_utils/handle.rs
new file mode 100644
index 0000000..4f9bdbb
--- /dev/null
+++ b/utils/tcp_connection/tcp_connection_test/src/test_utils/handle.rs
@@ -0,0 +1,11 @@
+use std::future::Future;
+
+use tcp_connection::instance::ConnectionInstance;
+
+pub trait ClientHandle<RequestServer> {
+    fn process(instance: ConnectionInstance) -> impl Future<Output = ()> + Send;
+}
+
+pub trait ServerHandle<RequestClient> {
+    fn process(instance: ConnectionInstance) -> impl Future<Output = ()> + Send;
+}
diff --git a/utils/tcp_connection/tcp_connection_test/src/test_utils/target.rs b/utils/tcp_connection/tcp_connection_test/src/test_utils/target.rs
new file mode 100644
index 0000000..8972b2a
--- /dev/null
+++ b/utils/tcp_connection/tcp_connection_test/src/test_utils/target.rs
@@ -0,0 +1,201 @@
+use serde::{Deserialize, Serialize};
+use std::{
+    fmt::{Display, Formatter},
+    marker::PhantomData,
+    net::{AddrParseError, IpAddr, Ipv4Addr, SocketAddr},
+    str::FromStr,
+};
+use tokio::net::lookup_host;
+
+use crate::test_utils::{
+    handle::{ClientHandle, ServerHandle},
+    target_configure::{ClientTargetConfig, ServerTargetConfig},
+};
+
+const DEFAULT_PORT: u16 = 8080;
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct TcpServerTarget<Client, Server>
+where
+    Client: ClientHandle<Server>,
+    Server: ServerHandle<Client>,
+{
+    /// Client Config
+    client_cfg: Option<ClientTargetConfig>,
+
+    /// Server Config
+    server_cfg: Option<ServerTargetConfig>,
+
+    /// Server port
+    port: u16,
+
+    /// Bind addr
+    bind_addr: IpAddr,
+
+    /// Client Phantom Data
+    _client: PhantomData<Client>,
+
+    /// Server Phantom Data
+    _server: PhantomData<Server>,
+}
+
+impl<Client, Server> Default for TcpServerTarget<Client, Server>
+where
+    Client: ClientHandle<Server>,
+    Server: ServerHandle<Client>,
+{
+    fn default() -> Self {
+        Self {
+            client_cfg: None,
+            server_cfg: None,
+            port: DEFAULT_PORT,
+            bind_addr: IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)),
+            _client: PhantomData,
+            _server: PhantomData,
+        }
+    }
+}
+
+impl<Client, Server> From<SocketAddr> for TcpServerTarget<Client, Server>
+where
+    Client: ClientHandle<Server>,
+    Server: ServerHandle<Client>,
+{
+    /// Convert SocketAddr to TcpServerTarget
+    fn from(value: SocketAddr) -> Self {
+        Self {
+            port: value.port(),
+            bind_addr: value.ip(),
+            ..Self::default()
+        }
+    }
+}
+
+impl<Client, Server> From<TcpServerTarget<Client, Server>> for SocketAddr
+where
+    Client: ClientHandle<Server>,
+    Server: ServerHandle<Client>,
+{
+    /// Convert TcpServerTarget to SocketAddr
+    fn from(val: TcpServerTarget<Client, Server>) -> Self {
+        SocketAddr::new(val.bind_addr, val.port)
+    }
+}
+
+impl<Client, Server> Display for TcpServerTarget<Client, Server>
+where
+    Client: ClientHandle<Server>,
+    Server: ServerHandle<Client>,
+{
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}:{}", self.bind_addr, self.port)
+    }
+}
+
+impl<Client, Server> TcpServerTarget<Client, Server>
+where
+    Client: ClientHandle<Server>,
+    Server: ServerHandle<Client>,
+{
+    /// Create target by address
+    pub fn from_addr(addr: impl Into<IpAddr>, port: impl Into<u16>) -> Self {
+        Self {
+            port: port.into(),
+            bind_addr: addr.into(),
+            ..Self::default()
+        }
+    }
+
+    /// Try to create target by string
+    pub fn from_address_str<'a>(addr_str: impl Into<&'a str>) -> Result<Self, AddrParseError> {
+        let socket_addr = SocketAddr::from_str(addr_str.into());
+        match socket_addr {
+            Ok(socket_addr) => Ok(Self::from_addr(socket_addr.ip(), socket_addr.port())),
+            Err(err) => Err(err),
+        }
+    }
+
+    /// Try to create target by domain name
+    pub async fn from_domain<'a>(domain: impl Into<&'a str>) -> Result<Self, std::io::Error> {
+        match domain_to_addr(domain).await {
+            Ok(domain_addr) => Ok(Self::from(domain_addr)),
+            Err(e) => Err(e),
+        }
+    }
+
+    /// Set client config
+    pub fn client_cfg(mut self, config: ClientTargetConfig) -> Self {
+        self.client_cfg = Some(config);
+        self
+    }
+
+    /// Set server config
+    pub fn server_cfg(mut self, config: ServerTargetConfig) -> Self {
+        self.server_cfg = Some(config);
+        self
+    }
+
+    /// Add client config
+    pub fn add_client_cfg(&mut self, config: ClientTargetConfig) {
+        self.client_cfg = Some(config);
+    }
+
+    /// Add server config
+    pub fn add_server_cfg(&mut self, config: ServerTargetConfig) {
+        self.server_cfg = Some(config);
+    }
+
+    /// Get client config ref
+    pub fn get_client_cfg(&self) -> Option<&ClientTargetConfig> {
+        self.client_cfg.as_ref()
+    }
+
+    /// Get server config ref
+    pub fn get_server_cfg(&self) -> Option<&ServerTargetConfig> {
+        self.server_cfg.as_ref()
+    }
+
+    /// Get SocketAddr of TcpServerTarget
+    pub fn get_addr(&self) -> SocketAddr {
+        SocketAddr::new(self.bind_addr, self.port)
+    }
+}
+
+/// Parse Domain Name to IpAddr via DNS
+async fn domain_to_addr<'a>(domain: impl Into<&'a str>) -> Result<SocketAddr, std::io::Error> {
+    let domain = domain.into();
+    let default_port: u16 = DEFAULT_PORT;
+
+    if let Ok(socket_addr) = domain.parse::<SocketAddr>() {
+        return Ok(match socket_addr.ip() {
+            IpAddr::V4(_) => socket_addr,
+            IpAddr::V6(_) => SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), socket_addr.port()),
+        });
+    }
+
+    if let Ok(_v6_addr) = domain.parse::<std::net::Ipv6Addr>() {
+        return Ok(SocketAddr::new(
+            IpAddr::V4(Ipv4Addr::LOCALHOST),
+            default_port,
+        ));
+    }
+
+    let (host, port_str) = if let Some((host, port)) = domain.rsplit_once(':') {
+        (host.trim_matches(|c| c == '[' || c == ']'), Some(port))
+    } else {
+        (domain, None)
+    };
+
+    let port = port_str
+        .and_then(|p| p.parse::<u16>().ok())
+        .map(|p| p.clamp(0, u16::MAX))
+        .unwrap_or(default_port);
+
+    let mut socket_iter = lookup_host((host, 0)).await?;
+
+    if let Some(addr) = socket_iter.find(|addr| addr.is_ipv4()) {
+        return Ok(SocketAddr::new(addr.ip(), port));
+    }
+
+    Ok(SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), port))
+}
diff --git a/utils/tcp_connection/tcp_connection_test/src/test_utils/target_configure.rs b/utils/tcp_connection/tcp_connection_test/src/test_utils/target_configure.rs
new file mode 100644
index 0000000..d739ac9
--- /dev/null
+++ b/utils/tcp_connection/tcp_connection_test/src/test_utils/target_configure.rs
@@ -0,0 +1,53 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Default, Debug, Clone, Copy, Serialize, Deserialize)]
+pub struct ServerTargetConfig {
+    /// Only process a single connection, then shut down the server.
+    once: bool,
+
+    /// Timeout duration in milliseconds. (0 is Closed)
+    timeout: u64,
+}
+
+impl ServerTargetConfig {
+    /// Set `once` to True
+    /// This method configures the `once` field of `ServerTargetConfig`.
+    pub fn once(mut self) -> Self {
+        self.once = true;
+        self
+    }
+
+    /// Set `timeout` to the given value
+    /// This method configures the `timeout` field of `ServerTargetConfig`.
+    pub fn timeout(mut self, timeout: u64) -> Self {
+        self.timeout = timeout;
+        self
+    }
+
+    /// Set `once` to the given value
+    /// This method configures the `once` field of `ServerTargetConfig`.
+    pub fn set_once(&mut self, enable: bool) {
+        self.once = enable;
+    }
+
+    /// Set `timeout` to the given value
+    /// This method configures the `timeout` field of `ServerTargetConfig`.
+    pub fn set_timeout(&mut self, timeout: u64) {
+        self.timeout = timeout;
+    }
+
+    /// Check if the server is configured to process only a single connection.
+    /// Returns `true` if the server will shut down after processing one connection.
+    pub fn is_once(&self) -> bool {
+        self.once
+    }
+
+    /// Get the current timeout value in milliseconds.
+    /// Returns the timeout duration. A value of 0 indicates the connection is closed.
+    pub fn get_timeout(&self) -> u64 {
+        self.timeout
+    }
+}
+
+#[derive(Default, Debug, Clone, Copy, Serialize, Deserialize)]
+pub struct ClientTargetConfig {}
diff --git a/utils/tcp_connection/tcp_connection_test/src/test_utils/target_connection.rs b/utils/tcp_connection/tcp_connection_test/src/test_utils/target_connection.rs
new file mode 100644
index 0000000..d5bf2c3
--- /dev/null
+++ b/utils/tcp_connection/tcp_connection_test/src/test_utils/target_connection.rs
@@ -0,0 +1,89 @@
+use tcp_connection::{error::TcpTargetError, instance::ConnectionInstance};
+use tokio::{
+    net::{TcpListener, TcpSocket},
+    spawn,
+};
+
+use crate::test_utils::{
+    handle::{ClientHandle, ServerHandle},
+    target::TcpServerTarget,
+    target_configure::ServerTargetConfig,
+};
+
+impl<Client, Server> TcpServerTarget<Client, Server>
+where
+    Client: ClientHandle<Server>,
+    Server: ServerHandle<Client>,
+{
+    /// Attempts to establish a connection to the TCP server.
+    ///
+    /// This function initiates a connection to the server address
+    /// specified in the target configuration.
+    ///
+    /// This is a Block operation.
+    pub async fn connect(&self) -> Result<(), TcpTargetError> {
+        let addr = self.get_addr();
+        let Ok(socket) = TcpSocket::new_v4() else {
+            return Err(TcpTargetError::from("Create tcp socket failed!"));
+        };
+        let stream = match socket.connect(addr).await {
+            Ok(stream) => stream,
+            Err(e) => {
+                let err = format!("Connect to `{}` failed: {}", addr, e);
+                return Err(TcpTargetError::from(err));
+            }
+        };
+        let instance = ConnectionInstance::from(stream);
+        Client::process(instance).await;
+        Ok(())
+    }
+
+    /// Attempts to establish a connection to the TCP server.
+    ///
+    /// This function initiates a connection to the server address
+    /// specified in the target configuration.
+    pub async fn listen(&self) -> Result<(), TcpTargetError> {
+        let addr = self.get_addr();
+        let listener = match TcpListener::bind(addr).await {
+            Ok(listener) => listener,
+            Err(_) => {
+                let err = format!("Bind to `{}` failed", addr);
+                return Err(TcpTargetError::from(err));
+            }
+        };
+
+        let cfg: ServerTargetConfig = match self.get_server_cfg() {
+            Some(cfg) => *cfg,
+            None => ServerTargetConfig::default(),
+        };
+
+        if cfg.is_once() {
+            // Process once (Blocked)
+            let (stream, _) = match listener.accept().await {
+                Ok(result) => result,
+                Err(e) => {
+                    let err = format!("Accept connection failed: {}", e);
+                    return Err(TcpTargetError::from(err));
+                }
+            };
+            let instance = ConnectionInstance::from(stream);
+            Server::process(instance).await;
+        } else {
+            loop {
+                // Process multiple times (Concurrent)
+                let (stream, _) = match listener.accept().await {
+                    Ok(result) => result,
+                    Err(e) => {
+                        let err = format!("Accept connection failed: {}", e);
+                        return Err(TcpTargetError::from(err));
+                    }
+                };
+                let instance = ConnectionInstance::from(stream);
+                spawn(async move {
+                    Server::process(instance).await;
+                });
+            }
+        }
+        Ok(())
+    }
+}