zmostp/tests/test2/send_test.go

package test2

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

type TestCase struct {
	Channel uint32
	Payload []byte
}

var ENC *zmostp_go.Transmitter
var INCH chan *zmostp_go.Message

func TestMain(m *testing.M) {
	addr, err := net.ResolveTCPAddr("tcp", "localhost:19810")
	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))
	}
	ENC = zmostp_go.NewTransmitter(&zmostp_go.TransmitterConfig{
		Writer:               conn,
		HumanFriendlySending: false,
		EnableCRC:            true,
	})
	INCH = ENC.GetMessageInChannel()
	wg := sync.WaitGroup{}
	wg.Add(1)
	ctx, cncl := context.WithCancel(context.Background())
	go func() {
		err := ENC.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 FuzzSendWithHumanFriendlySwitching(f *testing.F) {
	f.Log(" ==== fuzz looping test ====")
	testcases := []TestCase{
		{0, []byte("hello")},
		{114514, []byte("hello, gensoukyo")},
		{0xAA550101, []byte{0xAA, 0xA5, 0x5A, 0x01, 0x55, 0x00}},
	}
	for _, tci := range testcases {
		f.Add(tci.Channel, tci.Payload, true)
		f.Add(tci.Channel, tci.Payload, false)
	}
	f.Fuzz(func(t *testing.T, ch uint32, payload []byte, hf bool) {
		ENC.SetHumanFriendOutputOption(hf)
		INCH <- &zmostp_go.Message{
			Channel: ch,
			Payload: payload,
		}
	})
}