github.com/gogf/gf@v1.16.9/net/gudp/gudp_unit_basic_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 gudp_test
     8  
     9  import (
    10  	"fmt"
    11  	"github.com/gogf/gf/net/gudp"
    12  	"github.com/gogf/gf/os/glog"
    13  	"github.com/gogf/gf/test/gtest"
    14  	"github.com/gogf/gf/util/gconv"
    15  	"testing"
    16  	"time"
    17  )
    18  
    19  func Test_Basic(t *testing.T) {
    20  	p, _ := ports.PopRand()
    21  	s := gudp.NewServer(fmt.Sprintf("127.0.0.1:%d", p), func(conn *gudp.Conn) {
    22  		defer conn.Close()
    23  		for {
    24  			data, err := conn.Recv(-1)
    25  			if len(data) > 0 {
    26  				if err := conn.Send(append([]byte("> "), data...)); err != nil {
    27  					glog.Error(err)
    28  				}
    29  			}
    30  			if err != nil {
    31  				break
    32  			}
    33  		}
    34  	})
    35  	go s.Run()
    36  	defer s.Close()
    37  	time.Sleep(100 * time.Millisecond)
    38  	// gudp.Conn.Send
    39  	gtest.C(t, func(t *gtest.T) {
    40  		for i := 0; i < 100; i++ {
    41  			conn, err := gudp.NewConn(fmt.Sprintf("127.0.0.1:%d", p))
    42  			t.Assert(err, nil)
    43  			t.Assert(conn.Send([]byte(gconv.String(i))), nil)
    44  			conn.Close()
    45  		}
    46  	})
    47  	// gudp.Conn.SendRecv
    48  	gtest.C(t, func(t *gtest.T) {
    49  		for i := 0; i < 100; i++ {
    50  			conn, err := gudp.NewConn(fmt.Sprintf("127.0.0.1:%d", p))
    51  			t.Assert(err, nil)
    52  			result, err := conn.SendRecv([]byte(gconv.String(i)), -1)
    53  			t.Assert(err, nil)
    54  			t.Assert(string(result), fmt.Sprintf(`> %d`, i))
    55  			conn.Close()
    56  		}
    57  	})
    58  	// gudp.Send
    59  	gtest.C(t, func(t *gtest.T) {
    60  		for i := 0; i < 100; i++ {
    61  			err := gudp.Send(fmt.Sprintf("127.0.0.1:%d", p), []byte(gconv.String(i)))
    62  			t.Assert(err, nil)
    63  		}
    64  	})
    65  	// gudp.SendRecv
    66  	gtest.C(t, func(t *gtest.T) {
    67  		for i := 0; i < 100; i++ {
    68  			result, err := gudp.SendRecv(fmt.Sprintf("127.0.0.1:%d", p), []byte(gconv.String(i)), -1)
    69  			t.Assert(err, nil)
    70  			t.Assert(string(result), fmt.Sprintf(`> %d`, i))
    71  		}
    72  	})
    73  }
    74  
    75  // If the read buffer size is less than the sent package size,
    76  // the rest data would be dropped.
    77  func Test_Buffer(t *testing.T) {
    78  	p, _ := ports.PopRand()
    79  	s := gudp.NewServer(fmt.Sprintf("127.0.0.1:%d", p), func(conn *gudp.Conn) {
    80  		defer conn.Close()
    81  		for {
    82  			data, err := conn.Recv(1)
    83  			if len(data) > 0 {
    84  				if err := conn.Send(data); err != nil {
    85  					glog.Error(err)
    86  				}
    87  			}
    88  			if err != nil {
    89  				break
    90  			}
    91  		}
    92  	})
    93  	go s.Run()
    94  	defer s.Close()
    95  	time.Sleep(100 * time.Millisecond)
    96  	gtest.C(t, func(t *gtest.T) {
    97  		result, err := gudp.SendRecv(fmt.Sprintf("127.0.0.1:%d", p), []byte("123"), -1)
    98  		t.Assert(err, nil)
    99  		t.Assert(string(result), "1")
   100  	})
   101  	gtest.C(t, func(t *gtest.T) {
   102  		result, err := gudp.SendRecv(fmt.Sprintf("127.0.0.1:%d", p), []byte("456"), -1)
   103  		t.Assert(err, nil)
   104  		t.Assert(string(result), "4")
   105  	})
   106  }