zmostp/tests/test3/re_enc_svr_client_test.go

package test3

import (
	"bytes"
	"context"
	"flag"
	"fmt"
	zmostp_go "git.swzry.com/zry/zmostp/zmostp-go"
	"math/rand"
	"net"
	"os"
	"sync"
	"testing"
)

type TestCase struct {
	Channel uint32
	Payload []byte
}

var flagHelp bool
var flagServer string
var flagBatchTestCount int
var flagMaxRandomDataLength int

var ENC *zmostp_go.Transmitter
var DEC *zmostp_go.Receiver
var INCH chan *zmostp_go.Message
var OUTCH chan *zmostp_go.Message
var LH *LogHandler

func TestMain(m *testing.M) {
	fmt.Println("start.")
	flag.BoolVar(&flagHelp, "h", false, "print help")
	flag.StringVar(&flagServer, "s", "localhost:19810", "server address")
	flag.IntVar(&flagBatchTestCount, "b", 100, "batch test count")
	flag.IntVar(&flagMaxRandomDataLength, "l", 64, "max random data length")
	flag.Parse()
	if flagHelp {
		flag.PrintDefaults()
		return
	}
	addr, err := net.ResolveTCPAddr("tcp", flagServer)
	if err != nil {
		panic(fmt.Errorf("failed resolving tcp address: %v", err))
	}
	conn, err := net.DialTCP("tcp", nil, addr)
	if err != nil {
		panic(fmt.Errorf("failed dialing tcp: %v", err))
	}
	LH = &LogHandler{}
	ENC = zmostp_go.NewTransmitter(&zmostp_go.TransmitterConfig{
		Writer:               conn,
		HumanFriendlySending: false,
		EnableCRC:            true,
	})
	DEC = zmostp_go.NewReceiver(&zmostp_go.ReceiverConfig{
		ByteReader:       zmostp_go.NewSimpleByteReader(conn),
		EnableCRC:        true,
		DecodeFailureLog: LH,
	})
	INCH = ENC.GetMessageInChannel()
	OUTCH = DEC.GetMessageOutChannel()
	wg := sync.WaitGroup{}
	wg.Add(2)
	ctx, cncl := context.WithCancel(context.Background())
	go func() {
		err := ENC.Run(ctx)
		if err != nil {
			panic(err)
		}
		wg.Done()
	}()
	go func() {
		err := DEC.Run(ctx)
		if err != nil {
			panic(err)
		}
		wg.Done()
	}()
	fmt.Println("==== Init Ok ====")
	exitCode := m.Run()
	fmt.Println("==== Test End ====")
	cncl()
	_ = conn.Close()
	fmt.Println("==== Waiting for exit ====")
	wg.Wait()
	os.Exit(exitCode)
}

func TestFixedTestCase(t *testing.T) {
	testcases := []TestCase{
		{0, []byte("hello")},
		{114514, []byte("hello, gensoukyo")},
		{0xAA550101, []byte{0xAA, 0xA5, 0x5A, 0x01, 0x55, 0x00}},
	}
	for _, v := range testcases {
		testOneData(t, v.Channel, v.Payload, false)
		testOneData(t, v.Channel, v.Payload, true)
	}
}

func testOneData(t *testing.T, ch uint32, payload []byte, hf bool) {
	ENC.SetHumanFriendOutputOption(hf)
	INCH <- &zmostp_go.Message{
		Channel: ch,
		Payload: payload,
	}
	t.Logf("wait on ch %d", ch)
	rep := <-OUTCH
	if rep.Channel != ch {
		t.Fatalf("channel mismatch: got %d, want %d", rep.Channel, ch)
	}
	if !bytes.Equal(rep.Payload, payload) {
		t.Fatalf("payload mismatch: got %s, want %s", rep.Payload, payload)
	}
	t.Logf("test on ch %d ok", ch)
}

func pickRandom() *TestCase {
	ch := rand.Uint32()
	payloadLen := rand.Intn(flagMaxRandomDataLength)
	payload := make([]byte, payloadLen)
	rand.Read(payload)
	return &TestCase{
		Channel: ch,
		Payload: payload,
	}
}

func TestRandomTestCase(t *testing.T) {
	for i := 0; i < flagBatchTestCount; i++ {
		tc := pickRandom()
		testOneData(t, tc.Channel, tc.Payload, false)
		testOneData(t, tc.Channel, tc.Payload, true)
	}
}