github.com/gogf/gf@v1.16.9/net/gtcp/gtcp_unit_pkg_test.go (about)

     1  // Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
     2  //
     3  // This Source Code Form is subject to the terms of the MIT License.
     4  // If a copy of the MIT was not distributed with this file,
     5  // You can obtain one at https://github.com/gogf/gf.
     6  
     7  package gtcp_test
     8  
     9  import (
    10  	"fmt"
    11  	"github.com/gogf/gf/net/gtcp"
    12  	"github.com/gogf/gf/test/gtest"
    13  	"github.com/gogf/gf/util/gconv"
    14  	"testing"
    15  	"time"
    16  )
    17  
    18  func Test_Package_Basic(t *testing.T) {
    19  	p, _ := ports.PopRand()
    20  	s := gtcp.NewServer(fmt.Sprintf(`:%d`, p), func(conn *gtcp.Conn) {
    21  		defer conn.Close()
    22  		for {
    23  			data, err := conn.RecvPkg()
    24  			if err != nil {
    25  				break
    26  			}
    27  			conn.SendPkg(data)
    28  		}
    29  	})
    30  	go s.Run()
    31  	defer s.Close()
    32  	time.Sleep(100 * time.Millisecond)
    33  	// SendPkg
    34  	gtest.C(t, func(t *gtest.T) {
    35  		conn, err := gtcp.NewConn(fmt.Sprintf("127.0.0.1:%d", p))
    36  		t.Assert(err, nil)
    37  		defer conn.Close()
    38  		for i := 0; i < 100; i++ {
    39  			err := conn.SendPkg([]byte(gconv.String(i)))
    40  			t.Assert(err, nil)
    41  		}
    42  		for i := 0; i < 100; i++ {
    43  			err := conn.SendPkgWithTimeout([]byte(gconv.String(i)), time.Second)
    44  			t.Assert(err, nil)
    45  		}
    46  	})
    47  	// SendPkg with big data - failure.
    48  	gtest.C(t, func(t *gtest.T) {
    49  		conn, err := gtcp.NewConn(fmt.Sprintf("127.0.0.1:%d", p))
    50  		t.Assert(err, nil)
    51  		defer conn.Close()
    52  		data := make([]byte, 65536)
    53  		err = conn.SendPkg(data)
    54  		t.AssertNE(err, nil)
    55  	})
    56  	// SendRecvPkg
    57  	gtest.C(t, func(t *gtest.T) {
    58  		conn, err := gtcp.NewConn(fmt.Sprintf("127.0.0.1:%d", p))
    59  		t.Assert(err, nil)
    60  		defer conn.Close()
    61  		for i := 100; i < 200; i++ {
    62  			data := []byte(gconv.String(i))
    63  			result, err := conn.SendRecvPkg(data)
    64  			t.Assert(err, nil)
    65  			t.Assert(result, data)
    66  		}
    67  		for i := 100; i < 200; i++ {
    68  			data := []byte(gconv.String(i))
    69  			result, err := conn.SendRecvPkgWithTimeout(data, time.Second)
    70  			t.Assert(err, nil)
    71  			t.Assert(result, data)
    72  		}
    73  	})
    74  	// SendRecvPkg with big data - failure.
    75  	gtest.C(t, func(t *gtest.T) {
    76  		conn, err := gtcp.NewConn(fmt.Sprintf("127.0.0.1:%d", p))
    77  		t.Assert(err, nil)
    78  		defer conn.Close()
    79  		data := make([]byte, 65536)
    80  		result, err := conn.SendRecvPkg(data)
    81  		t.AssertNE(err, nil)
    82  		t.Assert(result, nil)
    83  	})
    84  	// SendRecvPkg with big data - success.
    85  	gtest.C(t, func(t *gtest.T) {
    86  		conn, err := gtcp.NewConn(fmt.Sprintf("127.0.0.1:%d", p))
    87  		t.Assert(err, nil)
    88  		defer conn.Close()
    89  		data := make([]byte, 65500)
    90  		data[100] = byte(65)
    91  		data[65400] = byte(85)
    92  		result, err := conn.SendRecvPkg(data)
    93  		t.Assert(err, nil)
    94  		t.Assert(result, data)
    95  	})
    96  }
    97  
    98  func Test_Package_Timeout(t *testing.T) {
    99  	p, _ := ports.PopRand()
   100  	s := gtcp.NewServer(fmt.Sprintf(`:%d`, p), func(conn *gtcp.Conn) {
   101  		defer conn.Close()
   102  		for {
   103  			data, err := conn.RecvPkg()
   104  			if err != nil {
   105  				break
   106  			}
   107  			time.Sleep(time.Second)
   108  			gtest.Assert(conn.SendPkg(data), nil)
   109  		}
   110  	})
   111  	go s.Run()
   112  	defer s.Close()
   113  	time.Sleep(100 * time.Millisecond)
   114  	gtest.C(t, func(t *gtest.T) {
   115  		conn, err := gtcp.NewConn(fmt.Sprintf("127.0.0.1:%d", p))
   116  		t.Assert(err, nil)
   117  		defer conn.Close()
   118  		data := []byte("10000")
   119  		result, err := conn.SendRecvPkgWithTimeout(data, time.Millisecond*500)
   120  		t.AssertNE(err, nil)
   121  		t.Assert(result, nil)
   122  	})
   123  	gtest.C(t, func(t *gtest.T) {
   124  		conn, err := gtcp.NewConn(fmt.Sprintf("127.0.0.1:%d", p))
   125  		t.Assert(err, nil)
   126  		defer conn.Close()
   127  		data := []byte("10000")
   128  		result, err := conn.SendRecvPkgWithTimeout(data, time.Second*2)
   129  		t.Assert(err, nil)
   130  		t.Assert(result, data)
   131  	})
   132  }
   133  
   134  func Test_Package_Option(t *testing.T) {
   135  	p, _ := ports.PopRand()
   136  	s := gtcp.NewServer(fmt.Sprintf(`:%d`, p), func(conn *gtcp.Conn) {
   137  		defer conn.Close()
   138  		option := gtcp.PkgOption{HeaderSize: 1}
   139  		for {
   140  			data, err := conn.RecvPkg(option)
   141  			if err != nil {
   142  				break
   143  			}
   144  			gtest.Assert(conn.SendPkg(data, option), nil)
   145  		}
   146  	})
   147  	go s.Run()
   148  	defer s.Close()
   149  	time.Sleep(100 * time.Millisecond)
   150  	// SendRecvPkg with big data - failure.
   151  	gtest.C(t, func(t *gtest.T) {
   152  		conn, err := gtcp.NewConn(fmt.Sprintf("127.0.0.1:%d", p))
   153  		t.Assert(err, nil)
   154  		defer conn.Close()
   155  		data := make([]byte, 0xFF+1)
   156  		result, err := conn.SendRecvPkg(data, gtcp.PkgOption{HeaderSize: 1})
   157  		t.AssertNE(err, nil)
   158  		t.Assert(result, nil)
   159  	})
   160  	// SendRecvPkg with big data - success.
   161  	gtest.C(t, func(t *gtest.T) {
   162  		conn, err := gtcp.NewConn(fmt.Sprintf("127.0.0.1:%d", p))
   163  		t.Assert(err, nil)
   164  		defer conn.Close()
   165  		data := make([]byte, 0xFF)
   166  		data[100] = byte(65)
   167  		data[200] = byte(85)
   168  		result, err := conn.SendRecvPkg(data, gtcp.PkgOption{HeaderSize: 1})
   169  		t.Assert(err, nil)
   170  		t.Assert(result, data)
   171  	})
   172  }