golib/v2/gnet/net_test.go

package gnet

import (
	"errors"
	"fmt"
	"log"
	"net"
	"os"
	"testing"
	"time"
)

func serverTCP(address string) {
	ln, err := net.Listen("tcp", address)
	if err != nil {
		panic(err)
	}
	ln = NewListener(ln, &Config{
		ReadTimout:  5 * time.Second,
		WriteTimout: 2 * time.Second,
	})
	for {
		conn, err := ln.Accept()
		if err != nil {
			_ = ln.Close()
			fmt.Println("serverTCP: accept close:", err)
			return
		}
		go func(conn net.Conn) {
			for {
				b := make([]byte, MaxBuffSize)
				n, err := conn.Read(b)
				if err != nil {
					_ = conn.Close()
					fmt.Println("conn.Read:", os.IsTimeout(err), err)
					return
				}
				fmt.Println("conn.Read:", Bytes(b[:n]).HexTo())
			}
		}(conn)
	}
}

func serverTCPModBus(address string) {
	ln, err := net.Listen("tcp", address)
	if err != nil {
		panic(err)
	}
	ln = NewListener(ln, &Config{
		ReadTimout:  5 * time.Second,
		WriteTimout: 2 * time.Second,
	})
	for {
		conn, err := ln.Accept()
		if err != nil {
			_ = ln.Close()
			fmt.Println("serverTCP: accept close:", err)
			return
		}
		go func(conn net.Conn) {
			for {
				b := make([]byte, MaxBuffSize)
				n, err := conn.Read(b)
				if err != nil {
					_ = conn.Close()
					fmt.Println("conn.Read:", err)
					return
				}
				fmt.Println("conn.Read:", Bytes(b[:n]).HexTo())
				p := []byte("hello,world")
				if _, err = conn.Write(p); err != nil {
					_ = conn.Close()
					fmt.Println("conn.Write:", err)
				} else {
					fmt.Println("conn.Write:", string(p))
				}
			}
		}(conn)
	}
}

func TestTcpClient_SetAutoReconnect(t *testing.T) {
	address := "127.0.0.1:9876"
	go serverTCP(address)

	client, err := DialTCPAlive("tcp", address, nil)
	if err != nil {
		t.Error("Dial:", err)
		return
	}

	var count int
	for {
		_, err = client.Write([]byte(time.Now().String()))
		if err != nil {
			fmt.Println("client.Write:", errors.Is(err, net.ErrClosed), err)
		} else {
			count++
			if count >= 5 && count < 10 {
				time.Sleep(5 * time.Second)
			}
			if count == 10 {
				_ = client.Close()
				fmt.Println("client.Close")
			}
			if count >= 10 {
				count = 0
			}
		}
		time.Sleep(1 * time.Second)
	}
}

func TestTcpClient_SetAutoReconnectModbus(t *testing.T) {
	address := "127.0.0.1:9876"
	go serverTCPModBus(address)

	client, err := DialTCPAlive("tcp", address, nil)
	if err != nil {
		t.Error("Dial:", err)
		return
	}

	var count int
	for {
		_, err = client.Write([]byte(time.Now().String()))
		if err == nil {

			b := make([]byte, MaxBuffSize)
			n, err := client.Read(b)
			if err == nil {
				fmt.Println("client.Read:", b[:n])
				count++
				if count >= 5 && count < 10 {
					time.Sleep(5 * time.Second)
				}
				if count == 10 {
					_ = client.Close()
					fmt.Println("client.Close")
				}
				if count >= 10 {
					count = 0
				}
			} else {
				fmt.Println("client.Read:", err)
			}

		} else {
			fmt.Println("client.Write:", err)
			break
		}

		time.Sleep(1 * time.Second)
	}
}

func TestDialTCP(t *testing.T) {
	address := "127.0.0.1:9876"
	go serverTCP(address)

	client, err := DialTCP("tcp", address)
	if err != nil {
		t.Error("Dial:", err)
		return
	}

	var count int
	for {
		_, err = client.Write([]byte(time.Now().String()))
		if err != nil {
			t.Error("client.Write:", err)
			return
		}
		count++
		if count >= 5 {
			time.Sleep(6 * time.Second)
			count = 0
		} else {
			time.Sleep(1 * time.Second)
		}
	}
}

func TestDialModBus(t *testing.T) {
	address := "127.0.0.1:9876"
	go serverTCPModBus(address)

	client, err := DialTCP("tcp", address)
	if err != nil {
		t.Error("DialModBus:", err)
		return
	}

	var count int
	for {
		_, err = client.Write([]byte(time.Now().String()))
		if err != nil {
			t.Error("client.Write:", err)
			return
		}

		b := make([]byte, MaxBuffSize)
		i, err := client.Read(b)
		if err != nil {
			t.Error("client.Read:", err)
			return
		}

		fmt.Println("client.Read:", b[:i])

		count++
		if count >= 5 {
			time.Sleep(6 * time.Second)
			count = 0
		} else {
			time.Sleep(1 * time.Second)
		}
	}
}

func TestListenTCP(t *testing.T) {
	ln, err := ListenTCP("tcp", "0.0.0.0:8899")
	if err != nil {
		t.Error(err)
		return
	}
	defer func() {
		_ = ln.Close()
	}()
	for {
		conn, err := ln.Accept()
		if err != nil {
			t.Error(err)
			return
		}
		go func(conn net.Conn) {
			defer func() {
				_ = conn.Close()
			}()
			for {
				b := make([]byte, 512)
				n, err := conn.Read(b)
				if err != nil {
					log.Println(err)
					return
				}
				log.Println("Hex:", Bytes(b[:n]).HexTo())
				log.Println(string(b[:n]))
			}
		}(conn)
	}
}