diff --git a/net/gclient/gclient_z_example_test.go b/net/gclient/gclient_z_example_test.go
index 230d57863..98bcb9c85 100644
--- a/net/gclient/gclient_z_example_test.go
+++ b/net/gclient/gclient_z_example_test.go
@@ -118,6 +118,26 @@ func ExampleNew() {
 	// {"id":1,"name":"john"}
 }
 
+func ExampleClient_Clone() {
+	var (
+		ctx    = gctx.New()
+		client = gclient.New()
+	)
+
+	client.SetCookie("key", "value")
+	cloneClient := client.Clone()
+
+	if r, err := cloneClient.Get(ctx, "http://127.0.0.1:8999/var/json"); err != nil {
+		panic(err)
+	} else {
+		defer r.Close()
+		fmt.Println(r.ReadAllString())
+	}
+
+	// Output:
+	// {"id":1,"name":"john"}
+}
+
 func ExampleNew_MultiConn_Recommend() {
 	var (
 		ctx    = gctx.New()
diff --git a/net/gclient/gclient_z_unit_test.go b/net/gclient/gclient_z_unit_test.go
index a1d8dc5c0..73ed9b9a8 100644
--- a/net/gclient/gclient_z_unit_test.go
+++ b/net/gclient/gclient_z_unit_test.go
@@ -9,7 +9,9 @@ package gclient_test
 import (
 	"bytes"
 	"context"
+	"crypto/tls"
 	"fmt"
+	"github.com/gogf/gf/v2/debug/gdebug"
 	"io/ioutil"
 	"net/http"
 	"testing"
@@ -532,3 +534,27 @@ func Test_WebSocketClient(t *testing.T) {
 		t.Assert(data, msg)
 	})
 }
+
+func TestLoadKeyCrt(t *testing.T) {
+	var (
+		testCrtFile = gfile.Dir(gdebug.CallerFilePath()) + gfile.Separator + "testdata/upload/file1.txt"
+		testKeyFile = gfile.Dir(gdebug.CallerFilePath()) + gfile.Separator + "testdata/upload/file2.txt"
+		crtFile     = gfile.Dir(gdebug.CallerFilePath()) + gfile.Separator + "testdata/server.crt"
+		keyFile     = gfile.Dir(gdebug.CallerFilePath()) + gfile.Separator + "testdata/server.key"
+		tlsConfig   = &tls.Config{}
+	)
+
+	gtest.C(t, func(t *gtest.T) {
+		tlsConfig, _ = gclient.LoadKeyCrt("crtFile", "keyFile")
+		t.AssertNil(tlsConfig)
+
+		tlsConfig, _ = gclient.LoadKeyCrt(crtFile, "keyFile")
+		t.AssertNil(tlsConfig)
+
+		tlsConfig, _ = gclient.LoadKeyCrt(testCrtFile, testKeyFile)
+		t.AssertNil(tlsConfig)
+
+		tlsConfig, _ = gclient.LoadKeyCrt(crtFile, keyFile)
+		t.AssertNE(tlsConfig, nil)
+	})
+}
diff --git a/net/gclient/testdata/server.crt b/net/gclient/testdata/server.crt
new file mode 100644
index 000000000..1132a2e55
--- /dev/null
+++ b/net/gclient/testdata/server.crt
@@ -0,0 +1,20 @@
+-----BEGIN CERTIFICATE-----
+MIIDVzCCAj+gAwIBAgIJAPRQQvW4UaTJMA0GCSqGSIb3DQEBCwUAMEIxCzAJBgNV
+BAYTAlhYMRUwEwYDVQQHDAxEZWZhdWx0IENpdHkxHDAaBgNVBAoME0RlZmF1bHQg
+Q29tcGFueSBMdGQwHhcNMTcxMTA2MDMwNjUzWhcNMjcxMTA0MDMwNjUzWjBCMQsw
+CQYDVQQGEwJYWDEVMBMGA1UEBwwMRGVmYXVsdCBDaXR5MRwwGgYDVQQKDBNEZWZh
+dWx0IENvbXBhbnkgTHRkMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA
+rvm9LVnIIPlimBCiNzhLmKqe8soWN7ZND+cN8myD8mcGVZblp01JZbR4n1btEekU
+rl3oNr/6aXhLml4ijre150Z73q31XMarlgBtbkbs4Lu22rlLZg/u2hzs9f1aF1VT
+qXzru+2ifcYR15Ptoyr8t12dYSQ9YXP7LwzghE9oWw52w0LxlNL0cNq2muSMTelQ
+xBU3OuAOdy7dPhiHvkpCCZ5SmwZuK8IpSX0/pJUgDkmd3zfKaaOE4JdLKJ5lWsGF
+RgM8leygKfvW4hwguEh7S1UG9CT/6jqPpyiPii3Qc4dxrogmiTPlFpYWY8bFNa9s
+iuwr8KFPPZIIwxZgDLAvywIDAQABo1AwTjAdBgNVHQ4EFgQUMsBb4Dhl4OZl+xw8
+Pl2wkRhUVi0wHwYDVR0jBBgwFoAUMsBb4Dhl4OZl+xw8Pl2wkRhUVi0wDAYDVR0T
+BAUwAwEB/zANBgkqhkiG9w0BAQsFAAOCAQEAQEaUz59HZHbPt4Etv4zASn3mFJeR
+QZHmUnKhVjB163xvHoN46GJmc4VnWahOd1a7i7b+qK6AnFzKI5zmZ4z5ZrjwqZiG
+epvAQ4FVbZy1nzMjBXQIyAkiDgbdjASvOUoE4OlKA3jLH7H204K3jhpaFTKVQNeY
+BGEALlKdveQUjlp5YTk38NrrZg0yzGDBUQ6X6PCYB+kdEOOpyx6061jxgIVKuBaY
+37I88vGcC9C3PVhYvDcilMkEcUPnp7DRMiZpXU7DraCWlWbr/b+47NkTPBWiNiLC
+nlfGdCGuL0ylZ16nEpkvZVUWiAijh3sUYbz1dbBACw+8dTG/+vlKUuz/hA==
+-----END CERTIFICATE-----
\ No newline at end of file
diff --git a/net/gclient/testdata/server.key b/net/gclient/testdata/server.key
new file mode 100644
index 000000000..d4d7923c3
--- /dev/null
+++ b/net/gclient/testdata/server.key
@@ -0,0 +1,27 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEowIBAAKCAQEArvm9LVnIIPlimBCiNzhLmKqe8soWN7ZND+cN8myD8mcGVZbl
+p01JZbR4n1btEekUrl3oNr/6aXhLml4ijre150Z73q31XMarlgBtbkbs4Lu22rlL
+Zg/u2hzs9f1aF1VTqXzru+2ifcYR15Ptoyr8t12dYSQ9YXP7LwzghE9oWw52w0Lx
+lNL0cNq2muSMTelQxBU3OuAOdy7dPhiHvkpCCZ5SmwZuK8IpSX0/pJUgDkmd3zfK
+aaOE4JdLKJ5lWsGFRgM8leygKfvW4hwguEh7S1UG9CT/6jqPpyiPii3Qc4dxrogm
+iTPlFpYWY8bFNa9siuwr8KFPPZIIwxZgDLAvywIDAQABAoIBAQCRYfXaWY/cPfm6
+qY9u3DqLpbCdwGWHctRC01MWSy2y2gE8Wj2ErcW/WJ0kn4Ao8oX5fxMzcn2o5ofC
+wlZqSKA+gqTnV5jXtkbZQo+qIgotjCqZP34zVie6WHBWz2PsoTv7Rk1D/2WUpV8r
+xMCdY1lJLeJW1Vqev1REOqnNpYDqrhBsCCNn0vvCOS+/UbTbJ2d4sw3BuqGfd2Uk
+eIXSlwkODKf2Tk3b4tktC7I0XZfBeO1DEpBJAYP+zPTt/we/Kne6FI/squdephJL
+JMj30bSZ0jpgP/K6otEiE3pfdzijTFPjw8ayU1yuZZMSRLJtFKbSfSNGUfXVHwZP
+6ygv91DJAoGBAOIawxKzSVJxz6yvaxh2Zxnib33TmpyWcDVKje/bk88hxEXm7C3Q
+OPMGbfy37mc6jDoH2erv2GFDFRCezHKS+OEN5heZnL3m/c6E0A4K/V9VUDSnABLi
+jmDRw45mDZq9edGxkvydHYMdJhH+hbbWrxr8LQtsBLuaDzLEkHa8cscdAoGBAMYc
+Wd4x3fBCA2/Xd98+ZTpYhtbYDvIYl2gfVLSiLuvf3ZgnWozibCOJg5DVh/0vCS+G
+ct4Ga3e17qRXZOXuSoZdBIh7nV2mQ0+zc+4ZE7UE0cAU4KYkGBabt1J4HdIxCOUB
+60smideKfFKurh5OCxSP76tIwOhcSXpduhmb/VYHAoGAfe7V89Zz4j2No+rYRXm9
+FwetfXGcTdbkjGoIAC5WdymhfiWOKj4tWf6cyANR/6D2dWPmFhqcdB++3dD0omQF
+xqPNIhvm10aO2rXSg9/PG4gS8iCJw/r3vilXODrTHPqnnQnAin6f72UOzTrsEtgk
+E22dUR1KzYqTKH2e0ONJMmkCgYBlcFzftd7zR4nk+YoKiDNi9bNNTOISOl9EVE6W
+Ezk9U6puXzAxVTqT07THM17nV+83I3urjdP3PvPLuGgUh7gnJnfMvqbsLdbnd3aT
+4slBdg9EcCw7Rd4DrYXnt1Nlre/k+t+U4k3QTLutxn2nTMTFqZHJvX3xPFfvTRCe
+Tk4gfwKBgDDo8/NvOZQJi+A5qJFooWkm5mFjsq2RTuOE5dZlgfNp3FzbJ1wcC0X5
+ifOWAMGIyw0m68Q07fL2rsfvfB69iB6oRv6WCuUXH2f5THgUeVxxYHHUfGJQQkcu
+XJXnZDH/OB1Pg674BzC6dGsHDM19kgWmr0aVQK4jueqxsm5pchEr
+-----END RSA PRIVATE KEY-----
\ No newline at end of file
diff --git a/net/ghttp/ghttp_z_unit_feature_request_file_test.go b/net/ghttp/ghttp_z_unit_feature_request_file_test.go
index 44dac9815..ae8babccb 100644
--- a/net/ghttp/ghttp_z_unit_feature_request_file_test.go
+++ b/net/ghttp/ghttp_z_unit_feature_request_file_test.go
@@ -224,18 +224,9 @@ func Test_Params_File_Upload_Required(t *testing.T) {
 	}
 	type Res struct{}
 
-	dstDirPath := gfile.Temp(gtime.TimestampNanoStr())
 	s := g.Server(guid.S())
+	s.Use(ghttp.MiddlewareHandlerResponse)
 	s.BindHandler("/upload/required", func(ctx context.Context, req *Req) (res *Res, err error) {
-		var (
-			r = g.RequestFromCtx(ctx)
-		)
-
-		file := req.File
-		if name, err := file.Save(dstDirPath); err == nil {
-			r.Response.WriteExit(name)
-		}
-		r.Response.WriteExit("upload failed")
 		return
 	})
 	s.SetDumpRouterMap(false)
@@ -246,9 +237,7 @@ func Test_Params_File_Upload_Required(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		client := g.Client()
 		client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", s.GetListenedPort()))
-		_, err := client.Post(ctx, "/upload/required")
-		if err != nil {
-			t.Assert(err.Error(), "upload file is required")
-		}
+		content := client.PostContent(ctx, "/upload/required")
+		t.Assert(content, `{"code":51,"message":"upload file is required","data":null}`)
 	})
 }
diff --git a/net/gtcp/gtcp_server.go b/net/gtcp/gtcp_server.go
index 01f1920b3..77f743f5b 100644
--- a/net/gtcp/gtcp_server.go
+++ b/net/gtcp/gtcp_server.go
@@ -84,6 +84,11 @@ func (s *Server) SetAddress(address string) {
 	s.address = address
 }
 
+// GetAddress get the listening address for server.
+func (s *Server) GetAddress() string {
+	return s.address
+}
+
 // SetHandler sets the connection handler for server.
 func (s *Server) SetHandler(handler func(*Conn)) {
 	s.handler = handler
diff --git a/net/gtcp/gtcp_z_example_test.go b/net/gtcp/gtcp_z_example_test.go
index 93dd6a91e..2c6ff4663 100644
--- a/net/gtcp/gtcp_z_example_test.go
+++ b/net/gtcp/gtcp_z_example_test.go
@@ -8,7 +8,6 @@ package gtcp_test
 
 import (
 	"fmt"
-
 	"github.com/gogf/gf/v2/net/gtcp"
 )
 
diff --git a/net/gtcp/gtcp_z_unit_conn_pkg_test.go b/net/gtcp/gtcp_z_unit_conn_pkg_test.go
index 8d216ade4..4bdba726f 100644
--- a/net/gtcp/gtcp_z_unit_conn_pkg_test.go
+++ b/net/gtcp/gtcp_z_unit_conn_pkg_test.go
@@ -8,6 +8,8 @@ package gtcp_test
 
 import (
 	"fmt"
+	"github.com/gogf/gf/v2/debug/gdebug"
+	"github.com/gogf/gf/v2/os/gfile"
 	"testing"
 	"time"
 
@@ -96,6 +98,34 @@ func Test_Package_Basic(t *testing.T) {
 	})
 }
 
+func Test_Package_Basic_HeaderSize1(t *testing.T) {
+	p, _ := gtcp.GetFreePort()
+	s := gtcp.NewServer(fmt.Sprintf(`:%d`, p), func(conn *gtcp.Conn) {
+		defer conn.Close()
+		for {
+			data, err := conn.RecvPkg(gtcp.PkgOption{HeaderSize: 1})
+			if err != nil {
+				break
+			}
+			conn.SendPkg(data)
+		}
+	})
+	go s.Run()
+	defer s.Close()
+	time.Sleep(100 * time.Millisecond)
+
+	// SendRecvPkg with empty data.
+	gtest.C(t, func(t *gtest.T) {
+		conn, err := gtcp.NewConn(fmt.Sprintf("127.0.0.1:%d", p))
+		t.AssertNil(err)
+		defer conn.Close()
+		data := make([]byte, 0)
+		result, err := conn.SendRecvPkg(data)
+		t.AssertNil(err)
+		t.AssertNil(result)
+	})
+}
+
 func Test_Package_Timeout(t *testing.T) {
 	p, _ := gtcp.GetFreePort()
 	s := gtcp.NewServer(fmt.Sprintf(`:%d`, p), func(conn *gtcp.Conn) {
@@ -130,6 +160,15 @@ func Test_Package_Timeout(t *testing.T) {
 		t.AssertNil(err)
 		t.Assert(result, data)
 	})
+	gtest.C(t, func(t *gtest.T) {
+		conn, err := gtcp.NewConn(fmt.Sprintf("127.0.0.1:%d", p))
+		t.AssertNil(err)
+		defer conn.Close()
+		data := []byte("10000")
+		result, err := conn.SendRecvPkgWithTimeout(data, time.Second*2, gtcp.PkgOption{HeaderSize: 5})
+		t.AssertNE(err, nil)
+		t.AssertNil(result)
+	})
 }
 
 func Test_Package_Option(t *testing.T) {
@@ -171,3 +210,151 @@ func Test_Package_Option(t *testing.T) {
 		t.Assert(result, data)
 	})
 }
+
+func Test_Package_Option_HeadSize3(t *testing.T) {
+	p, _ := gtcp.GetFreePort()
+	s := gtcp.NewServer(fmt.Sprintf(`:%d`, p), func(conn *gtcp.Conn) {
+		defer conn.Close()
+		option := gtcp.PkgOption{HeaderSize: 3}
+		for {
+			data, err := conn.RecvPkg(option)
+			if err != nil {
+				break
+			}
+			gtest.Assert(conn.SendPkg(data, option), nil)
+		}
+	})
+	go s.Run()
+	defer s.Close()
+	time.Sleep(100 * time.Millisecond)
+
+	gtest.C(t, func(t *gtest.T) {
+		conn, err := gtcp.NewConn(fmt.Sprintf("127.0.0.1:%d", p))
+		t.AssertNil(err)
+		defer conn.Close()
+		data := make([]byte, 0xFF)
+		data[100] = byte(65)
+		data[200] = byte(85)
+		result, err := conn.SendRecvPkg(data, gtcp.PkgOption{HeaderSize: 3})
+		t.AssertNil(err)
+		t.Assert(result, data)
+	})
+}
+
+func Test_Package_Option_HeadSize4(t *testing.T) {
+	p, _ := gtcp.GetFreePort()
+	s := gtcp.NewServer(fmt.Sprintf(`:%d`, p), func(conn *gtcp.Conn) {
+		defer conn.Close()
+		option := gtcp.PkgOption{HeaderSize: 4}
+		for {
+			data, err := conn.RecvPkg(option)
+			if err != nil {
+				break
+			}
+			gtest.Assert(conn.SendPkg(data, option), nil)
+		}
+	})
+	go s.Run()
+	defer s.Close()
+	time.Sleep(100 * time.Millisecond)
+	// SendRecvPkg with big data - failure.
+	gtest.C(t, func(t *gtest.T) {
+		conn, err := gtcp.NewConn(fmt.Sprintf("127.0.0.1:%d", p))
+		t.AssertNil(err)
+		defer conn.Close()
+		data := make([]byte, 0xFFFF+1)
+		_, err = conn.SendRecvPkg(data, gtcp.PkgOption{HeaderSize: 4})
+		t.Assert(err, nil)
+	})
+	// SendRecvPkg with big data - success.
+	gtest.C(t, func(t *gtest.T) {
+		conn, err := gtcp.NewConn(fmt.Sprintf("127.0.0.1:%d", p))
+		t.AssertNil(err)
+		defer conn.Close()
+		data := make([]byte, 0xFF)
+		data[100] = byte(65)
+		data[200] = byte(85)
+		result, err := conn.SendRecvPkg(data, gtcp.PkgOption{HeaderSize: 4})
+		t.AssertNil(err)
+		t.Assert(result, data)
+	})
+	// pkgOption.HeaderSize oversize
+	gtest.C(t, func(t *gtest.T) {
+		conn, err := gtcp.NewConn(fmt.Sprintf("127.0.0.1:%d", p))
+		t.AssertNil(err)
+		defer conn.Close()
+		data := make([]byte, 0xFF)
+		data[100] = byte(65)
+		data[200] = byte(85)
+		_, err = conn.SendRecvPkg(data, gtcp.PkgOption{HeaderSize: 5})
+		t.AssertNE(err, nil)
+	})
+}
+
+func Test_Server_NewServerKeyCrt(t *testing.T) {
+	var (
+		noCrtFile = "noCrtFile"
+		noKeyFile = "noKeyFile"
+		crtFile   = gfile.Dir(gdebug.CallerFilePath()) + gfile.Separator + "testdata/crtFile"
+		keyFile   = gfile.Dir(gdebug.CallerFilePath()) + gfile.Separator + "testdata/keyFile"
+	)
+	gtest.C(t, func(t *gtest.T) {
+		addr := "127.0.0.1:%d"
+		freePort, _ := gtcp.GetFreePort()
+		addr = fmt.Sprintf(addr, freePort)
+		s, err := gtcp.NewServerKeyCrt(addr, noCrtFile, noKeyFile, func(conn *gtcp.Conn) {
+		})
+		if err != nil {
+			t.AssertNil(s)
+		}
+	})
+	gtest.C(t, func(t *gtest.T) {
+		addr := "127.0.0.1:%d"
+		freePort, _ := gtcp.GetFreePort()
+		addr = fmt.Sprintf(addr, freePort)
+		s, err := gtcp.NewServerKeyCrt(addr, crtFile, noKeyFile, func(conn *gtcp.Conn) {
+		})
+		if err != nil {
+			t.AssertNil(s)
+		}
+	})
+	gtest.C(t, func(t *gtest.T) {
+		addr := "127.0.0.1:%d"
+		freePort, _ := gtcp.GetFreePort()
+		addr = fmt.Sprintf(addr, freePort)
+		s, err := gtcp.NewServerKeyCrt(addr, crtFile, keyFile, func(conn *gtcp.Conn) {
+		})
+		if err != nil {
+			t.AssertNil(s)
+		}
+	})
+}
+
+func Test_Conn_RecvPkgError(t *testing.T) {
+	p, _ := gtcp.GetFreePort()
+
+	s := gtcp.NewServer(fmt.Sprintf(`:%d`, p), func(conn *gtcp.Conn) {
+		defer conn.Close()
+		option := gtcp.PkgOption{HeaderSize: 5}
+		for {
+			_, err := conn.RecvPkg(option)
+			if err != nil {
+				break
+			}
+		}
+	})
+	go s.Run()
+	defer s.Close()
+
+	time.Sleep(100 * time.Millisecond)
+
+	gtest.C(t, func(t *gtest.T) {
+		conn, err := gtcp.NewConn(fmt.Sprintf("127.0.0.1:%d", p))
+		t.AssertNil(err)
+		defer conn.Close()
+		data := make([]byte, 65536)
+		result, err := conn.SendRecvPkg(data)
+		t.AssertNE(err, nil)
+		t.Assert(result, nil)
+	})
+}
diff --git a/net/gtcp/gtcp_z_unit_pool_pkg_test.go b/net/gtcp/gtcp_z_unit_pool_pkg_test.go
index 54df536aa..da7a4ec1b 100644
--- a/net/gtcp/gtcp_z_unit_pool_pkg_test.go
+++ b/net/gtcp/gtcp_z_unit_pool_pkg_test.go
@@ -170,4 +170,26 @@ func Test_Pool_Package_Option(t *testing.T) {
 		t.AssertNil(err)
 		t.Assert(result, data)
 	})
+	// SendRecvPkgWithTimeout with big data - failure.
+	gtest.C(t, func(t *gtest.T) {
+		conn, err := gtcp.NewPoolConn(fmt.Sprintf("127.0.0.1:%d", p))
+		t.AssertNil(err)
+		defer conn.Close()
+		data := make([]byte, 0xFF+1)
+		result, err := conn.SendRecvPkgWithTimeout(data, time.Second, gtcp.PkgOption{HeaderSize: 1})
+		t.AssertNE(err, nil)
+		t.Assert(result, nil)
+	})
+	// SendRecvPkgWithTimeout with big data - success.
+	gtest.C(t, func(t *gtest.T) {
+		conn, err := gtcp.NewPoolConn(fmt.Sprintf("127.0.0.1:%d", p))
+		t.AssertNil(err)
+		defer conn.Close()
+		data := make([]byte, 0xFF)
+		data[100] = byte(65)
+		data[200] = byte(85)
+		result, err := conn.SendRecvPkgWithTimeout(data, time.Second, gtcp.PkgOption{HeaderSize: 1})
+		t.AssertNil(err)
+		t.Assert(result, data)
+	})
 }
diff --git a/net/gtcp/gtcp_z_unit_pool_test.go b/net/gtcp/gtcp_z_unit_pool_test.go
index 6eae0bf44..7a0c3d465 100644
--- a/net/gtcp/gtcp_z_unit_pool_test.go
+++ b/net/gtcp/gtcp_z_unit_pool_test.go
@@ -8,6 +8,7 @@ package gtcp_test
 
 import (
 	"fmt"
+	"github.com/gogf/gf/v2/text/gstr"
 	"testing"
 	"time"
 
@@ -40,6 +41,11 @@ func Test_Pool_Basic1(t *testing.T) {
 		err = conn.SendPkgWithTimeout(data, time.Second)
 		t.AssertNil(err)
 	})
+
+	gtest.C(t, func(t *gtest.T) {
+		_, err := gtcp.NewPoolConn(fmt.Sprintf("127.0.0.1:80"))
+		t.AssertNE(err, nil)
+	})
 }
 
 func Test_Pool_Basic2(t *testing.T) {
@@ -64,3 +70,195 @@ func Test_Pool_Basic2(t *testing.T) {
 		t.AssertNE(err, nil)
 	})
 }
+
+func Test_Pool_Send(t *testing.T) {
+	p, _ := gtcp.GetFreePort()
+	s := gtcp.NewServer(fmt.Sprintf(`:%d`, p), func(conn *gtcp.Conn) {
+		for {
+			data, err := conn.Recv(-1)
+			if err != nil {
+				break
+			}
+			conn.Send(data)
+		}
+	})
+	go s.Run()
+	defer s.Close()
+	time.Sleep(100 * time.Millisecond)
+	gtest.C(t, func(t *gtest.T) {
+		conn, err := gtcp.NewPoolConn(fmt.Sprintf("127.0.0.1:%d", p))
+		t.AssertNil(err)
+		defer conn.Close()
+		data := []byte("9999")
+		err = conn.Send(data)
+		t.AssertNil(err)
+		recv, err := conn.Recv(-1)
+		t.AssertNil(err)
+		t.Assert(recv, data)
+	})
+}
+
+func Test_Pool_Recv(t *testing.T) {
+	p, _ := gtcp.GetFreePort()
+	s := gtcp.NewServer(fmt.Sprintf(`:%d`, p), func(conn *gtcp.Conn) {
+		for {
+			data, err := conn.Recv(-1)
+			if err != nil {
+				break
+			}
+			conn.Send(data)
+		}
+	})
+	go s.Run()
+	defer s.Close()
+	time.Sleep(100 * time.Millisecond)
+	gtest.C(t, func(t *gtest.T) {
+		conn, err := gtcp.NewPoolConn(fmt.Sprintf("127.0.0.1:%d", p))
+		t.AssertNil(err)
+		defer conn.Close()
+		data := []byte("9999")
+		err = conn.Send(data)
+		t.AssertNil(err)
+		time.Sleep(100 * time.Millisecond)
+		recv, err := conn.Recv(-1)
+		t.AssertNil(err)
+		t.Assert(recv, data)
+	})
+}
+
+func Test_Pool_RecvLine(t *testing.T) {
+	p, _ := gtcp.GetFreePort()
+	s := gtcp.NewServer(fmt.Sprintf(`:%d`, p), func(conn *gtcp.Conn) {
+		for {
+			data, err := conn.Recv(-1)
+			if err != nil {
+				break
+			}
+			conn.Send(data)
+		}
+	})
+	go s.Run()
+	defer s.Close()
+	time.Sleep(100 * time.Millisecond)
+	gtest.C(t, func(t *gtest.T) {
+		conn, err := gtcp.NewPoolConn(fmt.Sprintf("127.0.0.1:%d", p))
+		t.AssertNil(err)
+		defer conn.Close()
+		data := []byte("9999\n")
+		err = conn.Send(data)
+		t.AssertNil(err)
+		time.Sleep(100 * time.Millisecond)
+		recv, err := conn.RecvLine()
+		t.AssertNil(err)
+		splitData := gstr.Split(string(data), "\n")
+		t.Assert(recv, splitData[0])
+	})
+}
+
+func Test_Pool_RecvTill(t *testing.T) {
+	p, _ := gtcp.GetFreePort()
+	s := gtcp.NewServer(fmt.Sprintf(`:%d`, p), func(conn *gtcp.Conn) {
+		for {
+			data, err := conn.Recv(-1)
+			if err != nil {
+				break
+			}
+			conn.Send(data)
+		}
+	})
+	go s.Run()
+	defer s.Close()
+	time.Sleep(100 * time.Millisecond)
+	gtest.C(t, func(t *gtest.T) {
+		conn, err := gtcp.NewPoolConn(fmt.Sprintf("127.0.0.1:%d", p))
+		t.AssertNil(err)
+		defer conn.Close()
+		data := []byte("9999\n")
+		err = conn.Send(data)
+		t.AssertNil(err)
+		time.Sleep(100 * time.Millisecond)
+		recv, err := conn.RecvTill([]byte("\n"))
+		t.AssertNil(err)
+		t.Assert(recv, data)
+	})
+}
+
+func Test_Pool_RecvWithTimeout(t *testing.T) {
+	p, _ := gtcp.GetFreePort()
+	s := gtcp.NewServer(fmt.Sprintf(`:%d`, p), func(conn *gtcp.Conn) {
+		for {
+			data, err := conn.Recv(-1)
+			if err != nil {
+				break
+			}
+			conn.Send(data)
+		}
+	})
+	go s.Run()
+	defer s.Close()
+	time.Sleep(100 * time.Millisecond)
+	gtest.C(t, func(t *gtest.T) {
+		conn, err := gtcp.NewPoolConn(fmt.Sprintf("127.0.0.1:%d", p))
+		t.AssertNil(err)
+		defer conn.Close()
+		data := []byte("9999")
+		err = conn.Send(data)
+		t.AssertNil(err)
+		time.Sleep(100 * time.Millisecond)
+		recv, err := conn.RecvWithTimeout(-1, time.Millisecond*500)
+		t.AssertNil(err)
+		t.Assert(data, recv)
+	})
+}
+
+func Test_Pool_SendWithTimeout(t *testing.T) {
+	p, _ := gtcp.GetFreePort()
+	s := gtcp.NewServer(fmt.Sprintf(`:%d`, p), func(conn *gtcp.Conn) {
+		for {
+			data, err := conn.Recv(-1)
+			if err != nil {
+				break
+			}
+			conn.Send(data)
+		}
+	})
+	go s.Run()
+	defer s.Close()
+	time.Sleep(100 * time.Millisecond)
+	gtest.C(t, func(t *gtest.T) {
+		conn, err := gtcp.NewPoolConn(fmt.Sprintf("127.0.0.1:%d", p))
+		t.AssertNil(err)
+		defer conn.Close()
+		data := []byte("9999")
+		err = conn.SendWithTimeout(data, time.Millisecond*500)
+		t.AssertNil(err)
+		recv, err := conn.Recv(-1)
+		t.AssertNil(err)
+		t.Assert(data, recv)
+	})
+}
+
+func Test_Pool_SendRecvWithTimeout(t *testing.T) {
+	p, _ := gtcp.GetFreePort()
+	s := gtcp.NewServer(fmt.Sprintf(`:%d`, p), func(conn *gtcp.Conn) {
+		for {
+			data, err := conn.Recv(-1)
+			if err != nil {
+				break
+			}
+			conn.Send(data)
+		}
+	})
+	go s.Run()
+	defer s.Close()
+	time.Sleep(100 * time.Millisecond)
+	gtest.C(t, func(t *gtest.T) {
+		conn, err := gtcp.NewPoolConn(fmt.Sprintf("127.0.0.1:%d", p))
+		t.AssertNil(err)
+		defer conn.Close()
+		data := []byte("9999")
+		recv, err := conn.SendRecvWithTimeout(data, -1, time.Millisecond*500)
+		t.AssertNil(err)
+		t.Assert(data, recv)
+	})
+}
diff --git a/net/gtcp/gtcp_z_unit_test.go b/net/gtcp/gtcp_z_unit_test.go
new file mode 100644
index 000000000..e3dfbf7e6
--- /dev/null
+++ b/net/gtcp/gtcp_z_unit_test.go
@@ -0,0 +1,674 @@
+// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gtcp_test
+
+import (
+	"crypto/tls"
+	"fmt"
+	"github.com/gogf/gf/v2/debug/gdebug"
+	"github.com/gogf/gf/v2/net/gtcp"
+	"github.com/gogf/gf/v2/os/gfile"
+	"github.com/gogf/gf/v2/test/gtest"
+	"github.com/gogf/gf/v2/text/gstr"
+	"testing"
+	"time"
+)
+
+var (
+	simpleTimeout = time.Millisecond * 100
+	sendData      = []byte("hello")
+	invalidAddr   = "127.0.0.1:99999"
+	crtFile       = gfile.Dir(gdebug.CallerFilePath()) + gfile.Separator + "testdata/server.crt"
+	keyFile       = gfile.Dir(gdebug.CallerFilePath()) + gfile.Separator + "testdata/server.key"
+)
+
+func getFreePortAddr() string {
+	addr := "127.0.0.1:%d"
+	freePort, _ := gtcp.GetFreePort()
+	return fmt.Sprintf(addr, freePort)
+}
+
+func startTCPServer(addr string) {
+	s := gtcp.NewServer(addr, func(conn *gtcp.Conn) {
+		defer conn.Close()
+		for {
+			data, err := conn.Recv(-1)
+			if err != nil {
+				break
+			}
+			conn.Send(data)
+		}
+	})
+	go s.Run()
+	time.Sleep(simpleTimeout)
+}
+
+func startTCPPkgServer(addr string) {
+	s := gtcp.NewServer(addr, func(conn *gtcp.Conn) {
+		defer conn.Close()
+		for {
+			data, err := conn.RecvPkg()
+			if err != nil {
+				break
+			}
+			conn.SendPkg(data)
+		}
+	})
+	go s.Run()
+	time.Sleep(simpleTimeout)
+}
+
+func startTCPTLSServer(addr string) {
+	tlsConfig := &tls.Config{
+		InsecureSkipVerify: true,
+		Certificates: []tls.Certificate{
+			tls.Certificate{},
+		},
+	}
+	s := gtcp.NewServerTLS(addr, tlsConfig, func(conn *gtcp.Conn) {
+		defer conn.Close()
+		for {
+			data, err := conn.Recv(-1)
+			if err != nil {
+				break
+			}
+			conn.Send(data)
+		}
+	})
+	go s.Run()
+	time.Sleep(simpleTimeout)
+}
+
+func startTCPKeyCrtServer(addr string) {
+	s, _ := gtcp.NewServerKeyCrt(addr, crtFile, keyFile, func(conn *gtcp.Conn) {
+		defer conn.Close()
+		for {
+			data, err := conn.Recv(-1)
+			if err != nil {
+				break
+			}
+			conn.Send(data)
+		}
+	})
+	go s.Run()
+	time.Sleep(simpleTimeout)
+}
+
+func TestGetFreePorts(t *testing.T) {
+	ports, _ := gtcp.GetFreePorts(2)
+	gtest.C(t, func(t *gtest.T) {
+		t.AssertGT(ports[0], 0)
+		t.AssertGT(ports[1], 0)
+	})
+
+	addr := fmt.Sprintf("%s:%d", "127.0.0.1", ports[0])
+	startTCPServer(addr)
+	time.Sleep(simpleTimeout)
+
+	gtest.C(t, func(t *gtest.T) {
+		conn, err := gtcp.NewPoolConn(fmt.Sprintf("127.0.0.1:%d", ports[0]))
+		t.AssertNil(err)
+		defer conn.Close()
+		recv, err := conn.SendRecv(sendData, -1)
+		t.AssertNil(err)
+		t.Assert(recv, sendData)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		conn, err := gtcp.NewPoolConn(fmt.Sprintf("127.0.0.1:%d", 80))
+		t.AssertNE(err, nil)
+		t.AssertNil(conn)
+	})
+}
+
+func TestMustGetFreePort(t *testing.T) {
+	port := gtcp.MustGetFreePort()
+	addr := fmt.Sprintf("%s:%d", "127.0.0.1", port)
+	startTCPServer(addr)
+
+	gtest.C(t, func(t *gtest.T) {
+		recv, err := gtcp.SendRecv(addr, sendData, -1)
+		t.AssertNil(err)
+		t.Assert(sendData, recv)
+	})
+}
+
+func TestNewConn(t *testing.T) {
+	addr := getFreePortAddr()
+
+	gtest.C(t, func(t *gtest.T) {
+		conn, err := gtcp.NewConn(addr, simpleTimeout)
+		t.AssertNil(conn)
+		t.AssertNE(err, nil)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		startTCPServer(addr)
+
+		conn, err := gtcp.NewConn(addr, simpleTimeout)
+		t.AssertNil(err)
+		t.AssertNE(conn, nil)
+		defer conn.Close()
+		recv, err := conn.SendRecv(sendData, -1)
+		t.AssertNil(err)
+		t.Assert(recv, sendData)
+	})
+}
+
+//TODO
+func TestNewConnTLS(t *testing.T) {
+	addr := getFreePortAddr()
+
+	gtest.C(t, func(t *gtest.T) {
+		conn, err := gtcp.NewConnTLS(addr, &tls.Config{})
+		t.AssertNil(conn)
+		t.AssertNE(err, nil)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		startTCPTLSServer(addr)
+
+		conn, err := gtcp.NewConnTLS(addr, &tls.Config{
+			InsecureSkipVerify: true,
+			Certificates: []tls.Certificate{
+				tls.Certificate{},
+			},
+		})
+		t.AssertNil(conn)
+		t.AssertNE(err, nil)
+	})
+}
+
+func TestNewConnKeyCrt(t *testing.T) {
+	addr := getFreePortAddr()
+
+	gtest.C(t, func(t *gtest.T) {
+		conn, err := gtcp.NewConnKeyCrt(addr, crtFile, keyFile)
+		t.AssertNil(conn)
+		t.AssertNE(err, nil)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		startTCPKeyCrtServer(addr)
+
+		time.Sleep(simpleTimeout)
+
+		conn, err := gtcp.NewConnKeyCrt(addr, crtFile, keyFile)
+		t.AssertNil(conn)
+		t.AssertNE(err, nil)
+	})
+}
+
+func TestConn_Send(t *testing.T) {
+	addr := getFreePortAddr()
+
+	startTCPServer(addr)
+
+	gtest.C(t, func(t *gtest.T) {
+		conn, err := gtcp.NewConn(addr)
+		t.AssertNil(err)
+		t.AssertNE(conn, nil)
+		err = conn.Send(sendData, gtcp.Retry{Count: 1})
+		t.AssertNil(err)
+		recv, err := conn.Recv(-1)
+		t.AssertNil(err)
+		t.Assert(recv, sendData)
+	})
+}
+
+func TestConn_SendWithTimeout(t *testing.T) {
+	addr := getFreePortAddr()
+
+	startTCPServer(addr)
+
+	gtest.C(t, func(t *gtest.T) {
+		conn, err := gtcp.NewConn(addr)
+		t.AssertNil(err)
+		t.AssertNE(conn, nil)
+		err = conn.SendWithTimeout(sendData, time.Second, gtcp.Retry{Count: 1})
+		t.AssertNil(err)
+		recv, err := conn.Recv(-1)
+		t.AssertNil(err)
+		t.Assert(recv, sendData)
+	})
+}
+
+func TestConn_SendRecv(t *testing.T) {
+	addr := getFreePortAddr()
+
+	startTCPServer(addr)
+
+	gtest.C(t, func(t *gtest.T) {
+		conn, err := gtcp.NewConn(addr)
+		t.AssertNil(err)
+		t.AssertNE(conn, nil)
+		recv, err := conn.SendRecv(sendData, -1, gtcp.Retry{Count: 1})
+		t.AssertNil(err)
+		t.Assert(recv, sendData)
+	})
+}
+
+func TestConn_SendRecvWithTimeout(t *testing.T) {
+	addr := getFreePortAddr()
+
+	startTCPServer(addr)
+
+	gtest.C(t, func(t *gtest.T) {
+		conn, err := gtcp.NewConn(addr)
+		t.AssertNil(err)
+		t.AssertNE(conn, nil)
+		recv, err := conn.SendRecvWithTimeout(sendData, -1, time.Second, gtcp.Retry{Count: 1})
+		t.AssertNil(err)
+		t.Assert(recv, sendData)
+	})
+}
+
+func TestConn_RecvWithTimeout(t *testing.T) {
+	addr := getFreePortAddr()
+
+	startTCPServer(addr)
+
+	gtest.C(t, func(t *gtest.T) {
+		conn, err := gtcp.NewConn(addr)
+		t.AssertNil(err)
+		t.AssertNE(conn, nil)
+		conn.Send(sendData)
+		recv, err := conn.RecvWithTimeout(-1, time.Second, gtcp.Retry{Count: 1})
+		t.AssertNil(err)
+		t.Assert(recv, sendData)
+	})
+}
+
+func TestConn_RecvLine(t *testing.T) {
+	addr := getFreePortAddr()
+
+	startTCPServer(addr)
+
+	gtest.C(t, func(t *gtest.T) {
+		conn, err := gtcp.NewConn(addr)
+		t.AssertNil(err)
+		t.AssertNE(conn, nil)
+		data := []byte("hello\n")
+		conn.Send(data)
+		recv, err := conn.RecvLine(gtcp.Retry{Count: 1})
+		t.AssertNil(err)
+		splitData := gstr.Split(string(data), "\n")
+		t.Assert(recv, splitData[0])
+	})
+}
+
+func TestConn_RecvTill(t *testing.T) {
+	addr := getFreePortAddr()
+
+	startTCPServer(addr)
+
+	gtest.C(t, func(t *gtest.T) {
+		conn, err := gtcp.NewConn(addr)
+		t.AssertNil(err)
+		t.AssertNE(conn, nil)
+		conn.Send(sendData)
+		recv, err := conn.RecvTill([]byte("hello"), gtcp.Retry{Count: 1})
+		t.AssertNil(err)
+		t.Assert(recv, sendData)
+	})
+}
+
+func TestConn_SetDeadline(t *testing.T) {
+	addr := getFreePortAddr()
+
+	startTCPServer(addr)
+
+	gtest.C(t, func(t *gtest.T) {
+		conn, err := gtcp.NewConn(addr)
+		t.AssertNil(err)
+		t.AssertNE(conn, nil)
+		conn.SetDeadline(time.Time{})
+		err = conn.Send(sendData, gtcp.Retry{Count: 1})
+		t.AssertNil(err)
+		recv, err := conn.Recv(-1)
+		t.AssertNil(err)
+		t.Assert(recv, sendData)
+	})
+}
+
+func TestConn_SetReceiveBufferWait(t *testing.T) {
+	addr := getFreePortAddr()
+
+	startTCPServer(addr)
+
+	gtest.C(t, func(t *gtest.T) {
+		conn, err := gtcp.NewConn(addr)
+		t.AssertNil(err)
+		t.AssertNE(conn, nil)
+		conn.SetReceiveBufferWait(time.Millisecond * 100)
+		err = conn.Send(sendData, gtcp.Retry{Count: 1})
+		t.AssertNil(err)
+		recv, err := conn.Recv(-1)
+		t.AssertNil(err)
+		t.Assert(recv, sendData)
+	})
+}
+
+func TestNewNetConnKeyCrt(t *testing.T) {
+	addr := getFreePortAddr()
+
+	startTCPKeyCrtServer(addr)
+
+	gtest.C(t, func(t *gtest.T) {
+		conn, err := gtcp.NewNetConnKeyCrt(addr, "crtFile", keyFile, time.Second)
+		t.AssertNil(conn)
+		t.AssertNE(err, nil)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		conn, err := gtcp.NewNetConnKeyCrt(addr, crtFile, keyFile, time.Second)
+		t.AssertNil(conn)
+		t.AssertNE(err, nil)
+	})
+}
+
+func TestSend(t *testing.T) {
+	addr := getFreePortAddr()
+
+	startTCPServer(addr)
+
+	gtest.C(t, func(t *gtest.T) {
+		err := gtcp.Send(invalidAddr, sendData, gtcp.Retry{Count: 1})
+		t.AssertNE(err, nil)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		err := gtcp.Send(addr, sendData, gtcp.Retry{Count: 1})
+		t.AssertNil(err)
+	})
+}
+
+func TestSendRecv(t *testing.T) {
+	addr := getFreePortAddr()
+
+	startTCPServer(addr)
+
+	gtest.C(t, func(t *gtest.T) {
+		recv, err := gtcp.SendRecv(invalidAddr, sendData, -1)
+		t.AssertNE(err, nil)
+		t.Assert(recv, nil)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		recv, err := gtcp.SendRecv(addr, sendData, -1)
+		t.AssertNil(err)
+		t.Assert(recv, sendData)
+	})
+}
+
+func TestSendWithTimeout(t *testing.T) {
+	addr := getFreePortAddr()
+
+	startTCPServer(addr)
+
+	time.Sleep(simpleTimeout)
+
+	gtest.C(t, func(t *gtest.T) {
+		err := gtcp.SendWithTimeout(invalidAddr, sendData, time.Millisecond*500)
+		t.AssertNE(err, nil)
+		err = gtcp.SendWithTimeout(addr, sendData, time.Millisecond*500)
+		t.AssertNil(err)
+	})
+}
+
+func TestSendRecvWithTimeout(t *testing.T) {
+	addr := getFreePortAddr()
+
+	startTCPServer(addr)
+
+	time.Sleep(simpleTimeout)
+
+	gtest.C(t, func(t *gtest.T) {
+		recv, err := gtcp.SendRecvWithTimeout(invalidAddr, sendData, -1, time.Millisecond*500)
+		t.AssertNil(recv)
+		t.AssertNE(err, nil)
+		recv, err = gtcp.SendRecvWithTimeout(addr, sendData, -1, time.Millisecond*500)
+		t.AssertNil(err)
+		t.Assert(recv, sendData)
+	})
+}
+
+func TestSendPkg(t *testing.T) {
+	addr := getFreePortAddr()
+
+	startTCPPkgServer(addr)
+
+	time.Sleep(simpleTimeout)
+
+	gtest.C(t, func(t *gtest.T) {
+		err := gtcp.SendPkg(addr, sendData)
+		t.AssertNil(err)
+		err = gtcp.SendPkg(invalidAddr, sendData)
+		t.AssertNE(err, nil)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		err := gtcp.SendPkg(addr, sendData, gtcp.PkgOption{Retry: gtcp.Retry{Count: 3}})
+		t.AssertNil(err)
+		err = gtcp.SendPkg(addr, sendData)
+		t.AssertNil(err)
+	})
+}
+
+func TestSendRecvPkg(t *testing.T) {
+	addr := getFreePortAddr()
+
+	startTCPPkgServer(addr)
+
+	time.Sleep(simpleTimeout)
+
+	gtest.C(t, func(t *gtest.T) {
+		err := gtcp.SendPkg(addr, sendData)
+		t.AssertNil(err)
+		_, err = gtcp.SendRecvPkg(invalidAddr, sendData)
+		t.AssertNE(err, nil)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		err := gtcp.SendPkg(addr, sendData)
+		t.AssertNil(err)
+		recv, err := gtcp.SendRecvPkg(addr, sendData)
+		t.AssertNil(err)
+		t.Assert(recv, sendData)
+	})
+}
+
+func TestSendPkgWithTimeout(t *testing.T) {
+	addr := getFreePortAddr()
+
+	startTCPPkgServer(addr)
+
+	time.Sleep(simpleTimeout)
+
+	gtest.C(t, func(t *gtest.T) {
+		err := gtcp.SendPkg(addr, sendData)
+		t.AssertNil(err)
+		err = gtcp.SendPkgWithTimeout(invalidAddr, sendData, time.Second)
+		t.AssertNE(err, nil)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		err := gtcp.SendPkg(addr, sendData)
+		t.AssertNil(err)
+		err = gtcp.SendPkgWithTimeout(addr, sendData, time.Second)
+		t.AssertNil(err)
+	})
+}
+
+func TestSendRecvPkgWithTimeout(t *testing.T) {
+	addr := getFreePortAddr()
+
+	startTCPPkgServer(addr)
+
+	time.Sleep(simpleTimeout)
+
+	gtest.C(t, func(t *gtest.T) {
+		err := gtcp.SendPkg(addr, sendData)
+		t.AssertNil(err)
+		_, err = gtcp.SendRecvPkgWithTimeout(invalidAddr, sendData, time.Second)
+		t.AssertNE(err, nil)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		err := gtcp.SendPkg(addr, sendData)
+		t.AssertNil(err)
+		recv, err := gtcp.SendRecvPkgWithTimeout(addr, sendData, time.Second)
+		t.AssertNil(err)
+		t.Assert(recv, sendData)
+	})
+}
+
+func TestNewServer(t *testing.T) {
+	addr := getFreePortAddr()
+
+	gtest.C(t, func(t *gtest.T) {
+		s := gtcp.NewServer(addr, func(conn *gtcp.Conn) {
+			defer conn.Close()
+			for {
+				data, err := conn.Recv(-1)
+				if err != nil {
+					break
+				}
+				conn.Send(data)
+			}
+		}, "NewServer")
+		defer s.Close()
+		go s.Run()
+
+		time.Sleep(simpleTimeout)
+
+		recv, err := gtcp.SendRecv(addr, sendData, -1)
+		t.AssertNil(err)
+		t.Assert(recv, sendData)
+	})
+}
+
+func TestGetServer(t *testing.T) {
+	addr := getFreePortAddr()
+
+	gtest.C(t, func(t *gtest.T) {
+		s := gtcp.GetServer("GetServer")
+		defer s.Close()
+		go s.Run()
+
+		t.Assert(s.GetAddress(), "")
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		gtcp.NewServer(addr, func(conn *gtcp.Conn) {
+			defer conn.Close()
+			for {
+				data, err := conn.Recv(-1)
+				if err != nil {
+					break
+				}
+				conn.Send(data)
+			}
+		}, "NewServer")
+
+		s := gtcp.GetServer("NewServer")
+		defer s.Close()
+		go s.Run()
+
+		time.Sleep(simpleTimeout)
+
+		recv, err := gtcp.SendRecv(addr, sendData, -1)
+		t.AssertNil(err)
+		t.Assert(recv, sendData)
+	})
+}
+
+func TestServer_SetAddress(t *testing.T) {
+	addr := getFreePortAddr()
+
+	gtest.C(t, func(t *gtest.T) {
+		s := gtcp.NewServer("", func(conn *gtcp.Conn) {
+			defer conn.Close()
+			for {
+				data, err := conn.Recv(-1)
+				if err != nil {
+					break
+				}
+				conn.Send(data)
+			}
+		})
+		defer s.Close()
+		t.Assert(s.GetAddress(), "")
+		s.SetAddress(addr)
+		go s.Run()
+
+		time.Sleep(simpleTimeout)
+
+		recv, err := gtcp.SendRecv(addr, sendData, -1)
+		t.AssertNil(err)
+		t.Assert(recv, sendData)
+	})
+}
+
+func TestServer_SetHandler(t *testing.T) {
+	addr := getFreePortAddr()
+
+	gtest.C(t, func(t *gtest.T) {
+		s := gtcp.NewServer(addr, nil)
+		defer s.Close()
+		s.SetHandler(func(conn *gtcp.Conn) {
+			defer conn.Close()
+			for {
+				data, err := conn.Recv(-1)
+				if err != nil {
+					break
+				}
+				conn.Send(data)
+			}
+		})
+		go s.Run()
+
+		time.Sleep(simpleTimeout)
+
+		recv, err := gtcp.SendRecv(addr, sendData, -1)
+		t.AssertNil(err)
+		t.Assert(recv, sendData)
+	})
+}
+
+func TestServer_Run(t *testing.T) {
+	addr := getFreePortAddr()
+
+	gtest.C(t, func(t *gtest.T) {
+		s := gtcp.NewServer(addr, func(conn *gtcp.Conn) {
+			defer conn.Close()
+			for {
+				data, err := conn.Recv(-1)
+				if err != nil {
+					break
+				}
+				conn.Send(data)
+			}
+		})
+		defer s.Close()
+		go s.Run()
+
+		time.Sleep(simpleTimeout)
+
+		recv, err := gtcp.SendRecv(addr, sendData, -1)
+		t.AssertNil(err)
+		t.Assert(recv, sendData)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		s := gtcp.NewServer(addr, nil)
+		defer s.Close()
+		go func() {
+			err := s.Run()
+			t.AssertNE(err, nil)
+		}()
+	})
+}
diff --git a/net/gtcp/testdata/crtFile b/net/gtcp/testdata/crtFile
new file mode 100644
index 000000000..e69de29bb
diff --git a/net/gtcp/testdata/keyFile b/net/gtcp/testdata/keyFile
new file mode 100644
index 000000000..e69de29bb
diff --git a/net/gtcp/testdata/server.crt b/net/gtcp/testdata/server.crt
new file mode 100644
index 000000000..1132a2e55
--- /dev/null
+++ b/net/gtcp/testdata/server.crt
@@ -0,0 +1,20 @@
+-----BEGIN CERTIFICATE-----
+MIIDVzCCAj+gAwIBAgIJAPRQQvW4UaTJMA0GCSqGSIb3DQEBCwUAMEIxCzAJBgNV
+BAYTAlhYMRUwEwYDVQQHDAxEZWZhdWx0IENpdHkxHDAaBgNVBAoME0RlZmF1bHQg
+Q29tcGFueSBMdGQwHhcNMTcxMTA2MDMwNjUzWhcNMjcxMTA0MDMwNjUzWjBCMQsw
+CQYDVQQGEwJYWDEVMBMGA1UEBwwMRGVmYXVsdCBDaXR5MRwwGgYDVQQKDBNEZWZh
+dWx0IENvbXBhbnkgTHRkMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA
+rvm9LVnIIPlimBCiNzhLmKqe8soWN7ZND+cN8myD8mcGVZblp01JZbR4n1btEekU
+rl3oNr/6aXhLml4ijre150Z73q31XMarlgBtbkbs4Lu22rlLZg/u2hzs9f1aF1VT
+qXzru+2ifcYR15Ptoyr8t12dYSQ9YXP7LwzghE9oWw52w0LxlNL0cNq2muSMTelQ
+xBU3OuAOdy7dPhiHvkpCCZ5SmwZuK8IpSX0/pJUgDkmd3zfKaaOE4JdLKJ5lWsGF
+RgM8leygKfvW4hwguEh7S1UG9CT/6jqPpyiPii3Qc4dxrogmiTPlFpYWY8bFNa9s
+iuwr8KFPPZIIwxZgDLAvywIDAQABo1AwTjAdBgNVHQ4EFgQUMsBb4Dhl4OZl+xw8
+Pl2wkRhUVi0wHwYDVR0jBBgwFoAUMsBb4Dhl4OZl+xw8Pl2wkRhUVi0wDAYDVR0T
+BAUwAwEB/zANBgkqhkiG9w0BAQsFAAOCAQEAQEaUz59HZHbPt4Etv4zASn3mFJeR
+QZHmUnKhVjB163xvHoN46GJmc4VnWahOd1a7i7b+qK6AnFzKI5zmZ4z5ZrjwqZiG
+epvAQ4FVbZy1nzMjBXQIyAkiDgbdjASvOUoE4OlKA3jLH7H204K3jhpaFTKVQNeY
+BGEALlKdveQUjlp5YTk38NrrZg0yzGDBUQ6X6PCYB+kdEOOpyx6061jxgIVKuBaY
+37I88vGcC9C3PVhYvDcilMkEcUPnp7DRMiZpXU7DraCWlWbr/b+47NkTPBWiNiLC
+nlfGdCGuL0ylZ16nEpkvZVUWiAijh3sUYbz1dbBACw+8dTG/+vlKUuz/hA==
+-----END CERTIFICATE-----
\ No newline at end of file
diff --git a/net/gtcp/testdata/server.key b/net/gtcp/testdata/server.key
new file mode 100644
index 000000000..d4d7923c3
--- /dev/null
+++ b/net/gtcp/testdata/server.key
@@ -0,0 +1,27 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEowIBAAKCAQEArvm9LVnIIPlimBCiNzhLmKqe8soWN7ZND+cN8myD8mcGVZbl
+p01JZbR4n1btEekUrl3oNr/6aXhLml4ijre150Z73q31XMarlgBtbkbs4Lu22rlL
+Zg/u2hzs9f1aF1VTqXzru+2ifcYR15Ptoyr8t12dYSQ9YXP7LwzghE9oWw52w0Lx
+lNL0cNq2muSMTelQxBU3OuAOdy7dPhiHvkpCCZ5SmwZuK8IpSX0/pJUgDkmd3zfK
+aaOE4JdLKJ5lWsGFRgM8leygKfvW4hwguEh7S1UG9CT/6jqPpyiPii3Qc4dxrogm
+iTPlFpYWY8bFNa9siuwr8KFPPZIIwxZgDLAvywIDAQABAoIBAQCRYfXaWY/cPfm6
+qY9u3DqLpbCdwGWHctRC01MWSy2y2gE8Wj2ErcW/WJ0kn4Ao8oX5fxMzcn2o5ofC
+wlZqSKA+gqTnV5jXtkbZQo+qIgotjCqZP34zVie6WHBWz2PsoTv7Rk1D/2WUpV8r
+xMCdY1lJLeJW1Vqev1REOqnNpYDqrhBsCCNn0vvCOS+/UbTbJ2d4sw3BuqGfd2Uk
+eIXSlwkODKf2Tk3b4tktC7I0XZfBeO1DEpBJAYP+zPTt/we/Kne6FI/squdephJL
+JMj30bSZ0jpgP/K6otEiE3pfdzijTFPjw8ayU1yuZZMSRLJtFKbSfSNGUfXVHwZP
+6ygv91DJAoGBAOIawxKzSVJxz6yvaxh2Zxnib33TmpyWcDVKje/bk88hxEXm7C3Q
+OPMGbfy37mc6jDoH2erv2GFDFRCezHKS+OEN5heZnL3m/c6E0A4K/V9VUDSnABLi
+jmDRw45mDZq9edGxkvydHYMdJhH+hbbWrxr8LQtsBLuaDzLEkHa8cscdAoGBAMYc
+Wd4x3fBCA2/Xd98+ZTpYhtbYDvIYl2gfVLSiLuvf3ZgnWozibCOJg5DVh/0vCS+G
+ct4Ga3e17qRXZOXuSoZdBIh7nV2mQ0+zc+4ZE7UE0cAU4KYkGBabt1J4HdIxCOUB
+60smideKfFKurh5OCxSP76tIwOhcSXpduhmb/VYHAoGAfe7V89Zz4j2No+rYRXm9
+FwetfXGcTdbkjGoIAC5WdymhfiWOKj4tWf6cyANR/6D2dWPmFhqcdB++3dD0omQF
+xqPNIhvm10aO2rXSg9/PG4gS8iCJw/r3vilXODrTHPqnnQnAin6f72UOzTrsEtgk
+E22dUR1KzYqTKH2e0ONJMmkCgYBlcFzftd7zR4nk+YoKiDNi9bNNTOISOl9EVE6W
+Ezk9U6puXzAxVTqT07THM17nV+83I3urjdP3PvPLuGgUh7gnJnfMvqbsLdbnd3aT
+4slBdg9EcCw7Rd4DrYXnt1Nlre/k+t+U4k3QTLutxn2nTMTFqZHJvX3xPFfvTRCe
+Tk4gfwKBgDDo8/NvOZQJi+A5qJFooWkm5mFjsq2RTuOE5dZlgfNp3FzbJ1wcC0X5
+ifOWAMGIyw0m68Q07fL2rsfvfB69iB6oRv6WCuUXH2f5THgUeVxxYHHUfGJQQkcu
+XJXnZDH/OB1Pg674BzC6dGsHDM19kgWmr0aVQK4jueqxsm5pchEr
+-----END RSA PRIVATE KEY-----
\ No newline at end of file