gitee.com/KyleChenSource/lib-robot@v1.0.2/robottest/common/brutetest/brutetest.go

package brutetest

/*
	暴力测试
	// 如果相互嵌套，只能单层嵌套

	配置 [
		// 根据循序进行测试
		{
		'msgname': // 协议名
		'msgid': // 协议id, 可以为0, 则不进行测试
		'notest': // 不进行测试标记
		'caseid': // = 0, 没有要求。非0则会相同id，根据flowid排序
		'flowid': // 顺序
		'data': { //发送的协议
			%B_I8 min:max:...valid value%  16,32,64
			%B_U8 min:max:...valid value%  16,32,64
			%B_F32 min:max:...valid value% 64
			%B_BL%
			%B_STR min:max:...valid value%
			%B_BS minLen:maxLen:...valid% base64
			%B_MSG msgName%
			%B_ARR minLen:maxLen type params%
			%B_MAP minLen:maxLen key_type params value_type params%
		}
	]
*/

import (
	"bytes"
	"encoding/base64"
	"encoding/json"
	"fmt"
	"io/ioutil"
	"math"
	"math/rand"
	"os"
	"regexp"
	"sort"
	"strconv"
	"strings"

	"gitee.com/KyleChenSource/lib-robot/robottest/log"
	"github.com/valyala/fastjson"
)

const (
	testcnt_warn        = 5000
	generator_cnt_max   = 300000 // 限制一个消息的实际测试次数, 如果超过该次数，会启动Step = [Count / generator_cnt_max + 1, +2]
	caseCnfPattern      = ": *\"%B_(I8|I16|I32|I64|U8|U16|U32|U64|F32|F64|BL|STR|BS|MSG|ARR|MAP)([=_\\-\\.0-9:a-zA-Z ]*)%\""
	caseCnfSplitPattern = " *: *"
	caseCnfArrayPattern = " *([0-9]*) *: *([0-9]*) *B_(I8|I16|I32|I64|U8|U16|U32|U64|F32|F64|BL|STR|BS|MSG|ARR) *(.*)"
	caseCnfMapPattern   = " *([0-9]*) *: *([0-9]*) *B_(I8|I16|I32|I64|U8|U16|U32|U64|F32|F64|BL|STR|BS)(.*) *B_(I8|I16|I32|I64|U8|U16|U32|U64|F32|F64|BL|STR|BS|MSG|ARR|MAP)(.*)"
	randCntInt          = 3
	randCntString       = 3
	randCntBytes        = 4
	randCntArrayLenMin  = 0
	randCntArrayLenMax  = 10
	randCntArray        = 3
	randCntMapLenMin    = 0
	randCntMapLenMax    = 10
	randCntMap          = 3
)

var a float32
var (
	BrutetestMsgMap      = make(map[string]*BruteMsgCnf)
	BrutetestCaselistMap = make(map[int][]*BruteMsgCnf)
)

type BruteCaseType int

const (
	BruteCaseType_Int8 BruteCaseType = iota
	BruteCaseType_Int16
	BruteCaseType_Int32
	BruteCaseType_Int64
	BruteCaseType_Uint8
	BruteCaseType_Uint16
	BruteCaseType_Uint32
	BruteCaseType_Uint64
	BruteCaseType_Float32
	BruteCaseType_Float64
	BruteCaseType_BOOL
	BruteCaseType_STR
	BruteCaseType_BS
	BruteCaseType_MSG
	BruteCaseType_ARR
	BruteCaseType_MAP
	BruteCaseType_Cnt
)

var (
	prePath             = "./brutetest"
	caseCnfRe           = regexp.MustCompile(caseCnfPattern)
	caseCnfInt8SpliteRe = regexp.MustCompile(caseCnfSplitPattern)
	caseCnfArrayRe      = regexp.MustCompile(caseCnfArrayPattern)
	caseCnfMapRe        = regexp.MustCompile(caseCnfMapPattern)
)

func SpaceCnt(data string) int {
	cnt := 0
	for ; cnt < len(data); cnt++ {
		if data[cnt] != ' ' {
			break
		}
	}
	return cnt
}

func Int64(data string) (out int64, parseLen int, err error) {
	data = strings.Trim(data, " ")
	parseLen = len(data)
	if parseLen == 0 {
		return
	}

	out, err = strconv.ParseInt(data, 10, 64)
	if err != nil {
		return
	}

	return
}

func Uint64(data string) (out uint64, parseLen int, err error) {
	data = strings.Trim(data, " ")
	parseLen = len(data)
	if parseLen == 0 {
		return
	}

	out, err = strconv.ParseUint(data, 10, 64)
	if err != nil {
		return
	}

	return
}

func Float64(data string) (out float64, parseLen int, err error) {
	data = strings.Trim(data, " ")
	parseLen = len(data)
	if parseLen == 0 {
		return
	}

	out, err = strconv.ParseFloat(data, 64)
	if err != nil {
		return
	}

	return
}

func String(data string) (out string, parseLen int, err error) {
	out = strings.Trim(data, " \n\r")
	parseLen = len(out)
	return
}

type BruteCase interface {
	// ok : 是否循环结束
	// v : 如果Ok，就是可以放入json的文本
	Next() (ok bool, v string)
	// 必定返回成功, 跳过step个的下一个例子
	Step(step uint64) string
	// 获取随机值总数
	Count() uint64
}

type BruteCaseCnf interface {
	Type() BruteCaseType
	Case() BruteCase
	RandCnt() int
}

type BruteCaseCnfInt struct {
	BType BruteCaseType
	Min   int64
	Max   int64
	Datas []string
}

func (this *BruteCaseCnfInt) Type() BruteCaseType {
	return this.BType
}

func (this *BruteCaseCnfInt) RandCnt() int {
	if this.Max == this.Min {
		return 0
	}
	return randCntInt
}

func (this *BruteCaseCnfInt) Case() BruteCase {
	return &BruteCaseInt{
		cnf: this,
		cnt: uint64(len(this.Datas) + this.RandCnt()),
	}
}

type BruteCaseInt struct {
	cnf   *BruteCaseCnfInt
	cnt   uint64
	index uint64
}

func (this *BruteCaseInt) Next() (ok bool, v string) {
	ok = false
	if this.index >= this.cnt {
		this.index = 0
		return
	}

	if this.index < uint64(len(this.cnf.Datas)) {
		ok = true
		v = this.cnf.Datas[this.index]
		this.index++
		return
	}

	this.index++
	r := rand.Int63n(this.cnf.Max/2 - this.cnf.Min/2)
	return true, fmt.Sprintf("%d", this.cnf.Min+r+r)
}

func (this *BruteCaseInt) Step(step uint64) (v string) {
	this.index = (this.index + step) % this.cnt

	if this.index < uint64(len(this.cnf.Datas)) {
		v = this.cnf.Datas[this.index]
		this.index++
		return
	}

	this.index++
	r := rand.Int63n(this.cnf.Max/2 - this.cnf.Min/2)
	return fmt.Sprintf("%d", this.cnf.Min+r+r)
}

func (this *BruteCaseInt) Count() uint64 {
	return this.cnt
}

func ParseParamInt(data string, t BruteCaseType) (cnf BruteCaseCnf, err error) {
	var min int64
	var max int64
	switch t {
	case BruteCaseType_Int8:
		min = math.MinInt8
		max = math.MaxInt8
	case BruteCaseType_Int16:
		min = math.MinInt16
		max = math.MaxInt16
	case BruteCaseType_Int32:
		min = math.MinInt32
		max = math.MaxInt32
	case BruteCaseType_Int64:
		min = math.MinInt64
		max = math.MaxInt64
	default:
		err = fmt.Errorf("type:%d not Int", t)
		return
	}

	s := caseCnfInt8SpliteRe.Split(data, -1)
	slen := len(s)
	if slen == 0 {
		// 默认的Int8
		datas := make([]string, 2, 2)
		datas[0] = fmt.Sprintf("%d", min)
		datas[1] = fmt.Sprintf("%d", max)
		cnf = &BruteCaseCnfInt{
			BType: t,
			Min:   min,
			Max:   max,
			Datas: datas,
		}
		return
	}

	p, l, e := Int64(s[0])
	if e != nil {
		err = e
		return
	}

	if l != 0 && p > min {
		min = p
	}

	if slen <= 1 {
		datas := make([]string, 2, 2)
		datas[0] = fmt.Sprintf("%d", min)
		datas[1] = fmt.Sprintf("%d", max)
		cnf = &BruteCaseCnfInt{
			BType: t,
			Min:   min,
			Max:   max,
			Datas: datas,
		}
		return
	}

	p, l, e = Int64(s[1])
	if e != nil {
		err = e
		return
	}

	if l != 0 && p < max {
		max = p
	}

	if slen <= 2 {
		datas := make([]string, 2, 2)
		datas[0] = fmt.Sprintf("%d", min)
		datas[1] = fmt.Sprintf("%d", max)
		cnf = &BruteCaseCnfInt{
			BType: t,
			Min:   min,
			Max:   max,
			Datas: datas,
		}
		return
	}

	ps := make([]string, 2, slen)
	for i := 2; i < slen; i++ {
		p, l, e = Int64(s[i])
		if e != nil {
			err = e
			return
		}

		if l == 0 {
			continue
		}

		ps = append(ps, fmt.Sprintf("%d", p))
	}

	ps[0] = fmt.Sprintf("%d", min)
	ps[1] = fmt.Sprintf("%d", max)
	cnf = &BruteCaseCnfInt{
		BType: t,
		Min:   min,
		Max:   max,
		Datas: ps,
	}
	return
}

type BruteCaseCnfUint struct {
	BType BruteCaseType
	Min   uint64
	Max   uint64
	Datas []string
}

func (this *BruteCaseCnfUint) Type() BruteCaseType {
	return this.BType
}

func (this *BruteCaseCnfUint) RandCnt() int {
	if this.Max == this.Min {
		return 0
	}

	return randCntInt
}

func (this *BruteCaseCnfUint) Case() BruteCase {
	return &BruteCaseUint{
		cnf: this,
		cnt: uint64(len(this.Datas) + this.RandCnt()),
	}
}

type BruteCaseUint struct {
	cnf   *BruteCaseCnfUint
	cnt   uint64
	index uint64
}

func (this *BruteCaseUint) Next() (ok bool, v string) {
	ok = false
	if this.index >= this.cnt {
		this.index = 0
		return
	}

	if this.index < uint64(len(this.cnf.Datas)) {
		ok = true
		v = this.cnf.Datas[this.index]
		this.index++
		return
	}

	this.index++
	r := rand.Int63n(int64((this.cnf.Max - this.cnf.Min) / 2))
	return true, fmt.Sprintf("%d", this.cnf.Min+uint64(r)*2)
}

func (this *BruteCaseUint) Step(step uint64) (v string) {
	this.index = (this.index + step) % this.cnt

	if this.index < uint64(len(this.cnf.Datas)) {
		v = this.cnf.Datas[this.index]
		this.index++
		return
	}

	this.index++
	r := rand.Int63n(int64((this.cnf.Max - this.cnf.Min) / 2))
	return fmt.Sprintf("%d", this.cnf.Min+uint64(r)*2)
}

func (this *BruteCaseUint) Count() uint64 {
	return this.cnt
}

func ParseParamUint(data string, t BruteCaseType) (cnf BruteCaseCnf, err error) {
	min := uint64(0)
	var max uint64
	switch t {
	case BruteCaseType_Uint8:
		max = math.MaxUint8
	case BruteCaseType_Uint16:
		max = math.MaxUint16
	case BruteCaseType_Uint32:
		max = math.MaxUint32
	case BruteCaseType_Uint64:
		max = math.MaxUint64
	default:
		err = fmt.Errorf("type:%d not UInt", t)
		return
	}

	s := caseCnfInt8SpliteRe.Split(data, -1)
	slen := len(s)
	if slen == 0 {
		// 默认的Int8
		datas := make([]string, 2, 2)
		datas[0] = fmt.Sprintf("%d", min)
		datas[1] = fmt.Sprintf("%d", max)
		cnf = &BruteCaseCnfUint{
			BType: t,
			Min:   min,
			Max:   max,
			Datas: datas,
		}
		return
	}

	p, l, e := Uint64(s[0])
	if e != nil {
		err = e
		return
	}

	if l != 0 && p > min {
		min = p
	}

	if slen <= 1 {
		datas := make([]string, 2, 2)
		datas[0] = fmt.Sprintf("%d", min)
		datas[1] = fmt.Sprintf("%d", max)
		cnf = &BruteCaseCnfUint{
			BType: t,
			Min:   min,
			Max:   max,
			Datas: datas,
		}
		return
	}

	p, l, e = Uint64(s[1])
	if e != nil {
		err = e
		return
	}

	if l != 0 && p < max {
		max = p
	}

	if slen <= 2 {
		datas := make([]string, 2, 2)
		datas[0] = fmt.Sprintf("%d", min)
		datas[1] = fmt.Sprintf("%d", max)
		cnf = &BruteCaseCnfUint{
			BType: t,
			Min:   min,
			Max:   max,
			Datas: datas,
		}
		return
	}

	ps := make([]string, 2, slen)
	for i := 2; i < slen; i++ {
		p, l, e = Uint64(s[i])
		if e != nil {
			err = e
			return
		}

		if l == 0 {
			continue
		}

		ps = append(ps, fmt.Sprintf("%d", p))
	}

	ps[0] = fmt.Sprintf("%d", min)
	ps[1] = fmt.Sprintf("%d", max)
	cnf = &BruteCaseCnfUint{
		BType: t,
		Min:   min,
		Max:   max,
		Datas: ps,
	}
	return
}

type BruteCaseCnfFloat struct {
	BType BruteCaseType
	Min   float64
	Max   float64
	Datas []string
}

func (this *BruteCaseCnfFloat) Type() BruteCaseType {
	return this.BType
}

func (this *BruteCaseCnfFloat) RandCnt() int {
	if this.Min == this.Max {
		return 0
	}

	return randCntInt
}

func (this *BruteCaseCnfFloat) Case() BruteCase {
	return &BruteCaseFloat{
		cnf: this,
		cnt: uint64(len(this.Datas) + this.RandCnt()),
	}
}

type BruteCaseFloat struct {
	cnf   *BruteCaseCnfFloat
	cnt   uint64
	index uint64
}

func (this *BruteCaseFloat) Next() (ok bool, v string) {
	ok = false
	if this.index >= this.cnt {
		this.index = 0
		return
	}

	if this.index < uint64(len(this.cnf.Datas)) {
		ok = true
		v = this.cnf.Datas[this.index]
		this.index++
		return
	}

	this.index++
	return true, fmt.Sprintf("%.5f", rand.Float64()*(this.cnf.Max-this.cnf.Min)+this.cnf.Min)
}

func (this *BruteCaseFloat) Step(step uint64) (v string) {
	this.index = (this.index + step) % this.cnt

	if this.index < uint64(len(this.cnf.Datas)) {
		v = this.cnf.Datas[this.index]
		this.index++
		return
	}

	this.index++
	return fmt.Sprintf("%.5f", rand.Float64()*(this.cnf.Max-this.cnf.Min)+this.cnf.Min)
}

func (this *BruteCaseFloat) Count() uint64 {
	return this.cnt
}

func ParseParamFloat(data string, t BruteCaseType) (cnf BruteCaseCnf, err error) {
	var min float64
	var max float64
	switch t {
	case BruteCaseType_Float32:
		min = -math.MaxFloat32
		max = math.MaxFloat32
	case BruteCaseType_Float64:
		min = -math.MaxFloat64
		max = math.MaxFloat64
	default:
		err = fmt.Errorf("type:%d not Float", t)
		return
	}

	s := caseCnfInt8SpliteRe.Split(data, -1)
	slen := len(s)
	if slen == 0 {
		// 默认的Int8
		datas := make([]string, 2, 2)
		datas[0] = fmt.Sprintf("%.5f", min)
		datas[1] = fmt.Sprintf("%.5f", max)
		cnf = &BruteCaseCnfFloat{
			BType: t,
			Min:   min,
			Max:   max,
			Datas: datas,
		}
		return
	}

	p, l, e := Float64(s[0])
	if e != nil {
		err = e
		return
	}

	if l != 0 && p > min {
		min = p
	}

	if slen <= 1 {
		datas := make([]string, 2, 2)
		datas[0] = fmt.Sprintf("%.5f", min)
		datas[1] = fmt.Sprintf("%.5f", max)
		cnf = &BruteCaseCnfFloat{
			BType: t,
			Min:   min,
			Max:   max,
			Datas: datas,
		}
		return
	}

	p, l, e = Float64(s[1])
	if e != nil {
		err = e
		return
	}

	if l != 0 && p < max {
		max = p
	}

	if slen <= 2 {
		datas := make([]string, 2, 2)
		datas[0] = fmt.Sprintf("%.5f", min)
		datas[1] = fmt.Sprintf("%.5f", max)
		cnf = &BruteCaseCnfFloat{
			BType: t,
			Min:   min,
			Max:   max,
			Datas: datas,
		}
		return
	}

	ps := make([]string, 2, slen)
	for i := 2; i < slen; i++ {
		p, l, e = Float64(s[i])
		if e != nil {
			err = e
			return
		}

		if l == 0 {
			continue
		}

		ps = append(ps, fmt.Sprintf("%.5f", p))
	}

	ps[0] = fmt.Sprintf("%.5f", min)
	ps[1] = fmt.Sprintf("%.5f", max)
	cnf = &BruteCaseCnfFloat{
		BType: t,
		Min:   min,
		Max:   max,
		Datas: ps,
	}
	return
}

type BruteCaseCnfBool struct {
}

func (this *BruteCaseCnfBool) Type() BruteCaseType {
	return BruteCaseType_BOOL
}

func (this *BruteCaseCnfBool) RandCnt() int {
	return 0
}

func (this *BruteCaseCnfBool) Case() BruteCase {
	return &BruteCaseBool{}
}

var (
	bruteCaseBool = []string{"true", "false"}
)

type BruteCaseBool struct {
	index uint64
}

func (this *BruteCaseBool) Next() (ok bool, v string) {
	ok = false
	if this.index >= 2 {
		this.index = 0
		return
	}

	ok = true
	v = bruteCaseBool[this.index]
	this.index++
	return
}

func (this *BruteCaseBool) Step(step uint64) (v string) {
	this.index = (this.index + step) % 2
	v = bruteCaseBool[this.index]
	this.index++
	return
}

func (this *BruteCaseBool) Count() uint64 {
	return 2
}

type BruteCaseCnfString struct {
	Min   int
	Max   int
	Datas []string
}

func (this *BruteCaseCnfString) Type() BruteCaseType {
	return BruteCaseType_STR
}

func (this *BruteCaseCnfString) RandCnt() int {
	return randCntString
}

func (this *BruteCaseCnfString) Case() BruteCase {
	return &BruteCaseString{
		cnf: this,
		cnt: uint64(len(this.Datas) + this.RandCnt()),
	}
}

type BruteCaseString struct {
	cnf   *BruteCaseCnfString
	cnt   uint64
	index uint64
}

const stringList = " .ABCDEFGHIJKLMNOPQRSTUVWXWZabcdefghijklmnoqprstuvwxyz0123456789"

func (this *BruteCaseString) Next() (ok bool, v string) {
	ok = false
	if this.index >= this.cnt {
		this.index = 0
		return
	}

	if this.index < uint64(len(this.cnf.Datas)) {
		ok = true
		v = this.cnf.Datas[this.index]
		this.index++
		return
	}

	this.index++
	slen := rand.Int31n(int32(this.cnf.Max-this.cnf.Min)) + int32(this.cnf.Min+2)
	b := make([]byte, slen)
	b[0] = '"'
	for i := 1; i < int(slen-1); i++ {
		b[i] = stringList[rand.Int31n(int32(len(stringList)))]
	}
	b[slen-1] = '"'
	return true, string(b)
}

func (this *BruteCaseString) Step(step uint64) (v string) {
	this.index = (this.index + step) % this.cnt

	if this.index < uint64(len(this.cnf.Datas)) {
		v = this.cnf.Datas[this.index]
		this.index++
		return
	}

	this.index++
	slen := rand.Int31n(int32(this.cnf.Max-this.cnf.Min)) + int32(this.cnf.Min+2)
	b := make([]byte, slen)
	b[0] = '"'
	for i := 1; i < int(slen-1); i++ {
		b[i] = stringList[rand.Int31n(int32(len(stringList)))]
	}
	b[slen-1] = '"'
	return string(b)
}

func (this *BruteCaseString) Count() uint64 {
	return this.cnt
}

func ParseParamString(data string) (cnf BruteCaseCnf, err error) {
	minLen := 0
	maxLen := 10

	s := caseCnfInt8SpliteRe.Split(data, -1)
	slen := len(s)
	if slen == 0 {
		cnf = &BruteCaseCnfString{
			Min: minLen,
			Max: maxLen,
		}
		return
	}

	p, l, e := Int64(s[0])
	if e != nil {
		err = e
		return
	}

	if l != 0 && int(p) > minLen {
		minLen = int(p)
	}

	if slen <= 1 {
		cnf = &BruteCaseCnfString{
			Min: minLen,
			Max: maxLen,
		}
		return
	}

	p, l, e = Int64(s[1])
	if e != nil {
		err = e
		return
	}

	if l != 0 && int(p) < maxLen {
		maxLen = int(p)
	}

	if slen <= 2 {
		cnf = &BruteCaseCnfString{
			Min: minLen,
			Max: maxLen,
		}
		return
	}

	ps := make([]string, 0, slen-2)
	for i := 2; i < slen; i++ {
		var tempS string
		tempS, l, e = String(s[i])
		if e != nil {
			err = e
			return
		}

		if l == 0 {
			continue
		}

		ps = append(ps, fmt.Sprintf("\"%s\"", tempS))
	}

	cnf = &BruteCaseCnfString{
		Min:   minLen,
		Max:   maxLen,
		Datas: ps,
	}
	return
}

type BruteCaseCnfByteString struct {
	Min   int
	Max   int
	Datas []string
}

func (this *BruteCaseCnfByteString) Type() BruteCaseType {
	return BruteCaseType_BS
}

func (this *BruteCaseCnfByteString) RandCnt() int {
	return randCntBytes
}

func (this *BruteCaseCnfByteString) Case() BruteCase {
	return &BruteCaseByteString{
		cnf: this,
		cnt: uint64(len(this.Datas) + this.RandCnt()),
	}
}

type BruteCaseByteString struct {
	cnf   *BruteCaseCnfByteString
	cnt   uint64
	index uint64
}

func (this *BruteCaseByteString) Next() (ok bool, v string) {
	ok = false
	if this.index >= this.cnt {
		this.index = 0
		return
	}

	if this.index < uint64(len(this.cnf.Datas)) {
		ok = true
		v = this.cnf.Datas[this.index]
		this.index++
		return
	}

	this.index++
	slen := rand.Int31n(int32(this.cnf.Max - this.cnf.Min))
	b := make([]byte, slen)
	for i := 0; i < int(slen); i++ {
		b[i] = byte(rand.Intn(255) - 128)
	}
	return true, fmt.Sprintf("\"%s\"", base64.StdEncoding.EncodeToString(b))
}

func (this *BruteCaseByteString) Step(step uint64) (v string) {
	this.index = (this.index + step) % this.cnt
	if this.index < uint64(len(this.cnf.Datas)) {
		v = this.cnf.Datas[this.index]
		this.index++
		return
	}

	this.index++
	slen := rand.Int31n(int32(this.cnf.Max - this.cnf.Min))
	b := make([]byte, slen)
	for i := 0; i < int(slen); i++ {
		b[i] = byte(rand.Intn(255) - 128)
	}
	return fmt.Sprintf("\"%s\"", base64.StdEncoding.EncodeToString(b))
}

func (this *BruteCaseByteString) Count() uint64 {
	return this.cnt
}

func ParseParamByteString(data string) (cnf BruteCaseCnf, err error) {
	minLen := 0
	maxLen := 10

	s := caseCnfInt8SpliteRe.Split(data, -1)
	slen := len(s)
	if slen == 0 {
		cnf = &BruteCaseCnfByteString{
			Min: minLen,
			Max: maxLen,
		}
		return
	}

	p, l, e := Int64(s[0])
	if e != nil {
		err = e
		return
	}

	if l != 0 && int(p) > minLen {
		minLen = int(p)
	}

	if slen <= 1 {
		cnf = &BruteCaseCnfByteString{
			Min: minLen,
			Max: maxLen,
		}
		return
	}

	p, l, e = Int64(s[1])
	if e != nil {
		err = e
		return
	}

	if l != 0 && int(p) < maxLen {
		maxLen = int(p)
	}

	if slen <= 2 {
		cnf = &BruteCaseCnfByteString{
			Min: minLen,
			Max: maxLen,
		}
		return
	}

	ps := make([]string, 0, slen-2)
	for i := 2; i < slen; i++ {
		var tempS string
		tempS, l, err = String(s[i])
		if err != nil {
			return
		}

		if l == 0 {
			continue
		}

		if _, err = base64.StdEncoding.DecodeString(tempS); err != nil {
			return
		}

		ps = append(ps, fmt.Sprintf("\"%s\"", tempS))
	}

	cnf = &BruteCaseCnfByteString{
		Min:   minLen,
		Max:   maxLen,
		Datas: ps,
	}
	return
}

type BruteCaseCnfMsg struct {
	msgName string
}

func (this *BruteCaseCnfMsg) Type() BruteCaseType {
	return BruteCaseType_MSG
}

func (this *BruteCaseCnfMsg) RandCnt() int {
	return 0
}

func (this *BruteCaseCnfMsg) Case() BruteCase {
	mc, ok := BrutetestMsgMap[this.msgName]
	if !ok {
		return nil
	}

	m := mc.Generator(0, 0)
	if m == nil {
		return nil
	}

	return &BruteCaseMsg{
		msg: m,
	}
}

type BruteCaseMsg struct {
	msg *BruteMsgGenerator
}

func (this *BruteCaseMsg) Next() (ok bool, v string) {
	return this.msg.Next()
}

func (this *BruteCaseMsg) Step(step uint64) (v string) {
	return this.msg._step(step)
}

func (this *BruteCaseMsg) Count() uint64 {
	return this.msg.Count()
}

func ParseParamMsg(data string) (cnf BruteCaseCnf, err error) {

	p, l, e := String(data)
	if e != nil {
		err = e
		return
	}

	if l == 0 {
		err = fmt.Errorf("msgname null")
		return
	}

	cnf = &BruteCaseCnfMsg{
		msgName: p,
	}
	return
}

type BruteCaseCnfArray struct {
	Min int
	Max int
	Cnf BruteCaseCnf
}

func (this *BruteCaseCnfArray) Type() BruteCaseType {
	return BruteCaseType_ARR
}

func (this *BruteCaseCnfArray) RandCnt() int {
	return randCntArray
}

func (this *BruteCaseCnfArray) Case() BruteCase {
	return &BruteCaseArray{
		cnf:       this,
		bruteCase: this.Cnf.Case(),
	}
}

type BruteCaseArray struct {
	cnf       *BruteCaseCnfArray
	index     uint64
	bruteCase BruteCase
}

func (this *BruteCaseArray) one() string {
	ok, s := this.bruteCase.Next()
	if !ok {
		_, s = this.bruteCase.Next()
	}

	return s
}

func (this *BruteCaseArray) Next() (ok bool, v string) {
	if this.index >= this.Count() {
		this.index = 0
		return false, ""
	}

	var outBuilder strings.Builder
	outBuilder.WriteString("[")
	cnt := rand.Int31n(int32(this.cnf.Max-this.cnf.Min)) + int32(this.cnf.Min)
	if cnt > 0 {
		outBuilder.WriteString(this.one())
	}
	for i := 1; i < int(cnt); i++ {
		outBuilder.WriteString(",")
		outBuilder.WriteString(this.one())
	}
	outBuilder.WriteString("]")
	this.index++
	return true, outBuilder.String()
}

func (this *BruteCaseArray) Step(step uint64) (v string) {
	var outBuilder strings.Builder
	outBuilder.WriteString("[")
	cnt := rand.Int31n(int32(this.cnf.Max-this.cnf.Min)) + int32(this.cnf.Min)
	if cnt > 0 {
		outBuilder.WriteString(this.one())
	}
	for i := 1; i < int(cnt); i++ {
		outBuilder.WriteString(",")
		outBuilder.WriteString(this.one())
	}
	outBuilder.WriteString("]")
	return outBuilder.String()
}

func (this *BruteCaseArray) Count() uint64 {
	return uint64(this.cnf.RandCnt())
}

func ParseParamArray(data string) (cnf BruteCaseCnf, err error) {
	matches := caseCnfArrayRe.FindStringSubmatch(data)
	if len(matches) != 5 {
		err = fmt.Errorf("caseCnfArrayRe match len:%d not 5", len(matches))
		return
	}

	cnf, err = ParseCnf(matches[3], matches[4])
	if err != nil {
		return
	}

	min := int64(randCntArrayLenMin)
	max := int64(randCntArrayLenMax)
	i, l, e := Int64(matches[1])
	if e != nil {
		err = e
		return
	}

	if l > 0 {
		min = i
	}

	i, l, e = Int64(matches[2])
	if e != nil {
		err = e
		return
	}

	if l > 0 {
		max = i
	}

	cnf = &BruteCaseCnfArray{
		Min: int(min),
		Max: int(max),
		Cnf: cnf,
	}
	return
}

type BruteCaseCnfMap struct {
	Min   int
	Max   int
	Key   BruteCaseCnf
	Value BruteCaseCnf
}

func (this *BruteCaseCnfMap) Type() BruteCaseType {
	return BruteCaseType_MAP
}

func (this *BruteCaseCnfMap) RandCnt() int {
	return randCntMap
}

func (this *BruteCaseCnfMap) Case() BruteCase {
	return &BruteCaseMap{
		cnf:   this,
		key:   this.Key.Case(),
		value: this.Value.Case(),
	}
}

type BruteCaseMap struct {
	cnf   *BruteCaseCnfMap
	cnt   uint64
	index uint64
	key   BruteCase
	value BruteCase
}

func (this *BruteCaseMap) one(keys map[string]bool) string {
	var outBuilder strings.Builder

	ok := false
	s := ""
	for !ok {
		ok, s = this.key.Next()
		if ok {
			_, ok = keys[s]
			ok = !ok
		}
	}
	keys[s] = true

	if s[0] == '"' {
		outBuilder.WriteString(s)
		outBuilder.WriteString(":")
	} else {
		outBuilder.WriteString("\"")
		outBuilder.WriteString(s)
		outBuilder.WriteString("\":")
	}

	ok, s = this.value.Next()
	if !ok {
		_, s = this.value.Next()
	}
	outBuilder.WriteString(s)

	return outBuilder.String()
}

func (this *BruteCaseMap) Next() (ok bool, v string) {
	if this.index >= this.Count() {
		this.index = 0
		return false, ""
	}

	var outBuilder strings.Builder
	outBuilder.WriteString("{")
	cnt := rand.Int31n(int32(this.cnf.Max-this.cnf.Min)) + int32(this.cnf.Min)
	keys := make(map[string]bool, cnt)
	for i := 0; i < int(cnt); i++ {
		if i > 0 {
			outBuilder.WriteString(",")
		}
		outBuilder.WriteString(this.one(keys))
	}
	outBuilder.WriteString("}")
	this.index++
	return true, outBuilder.String()
}

func (this *BruteCaseMap) Step(step uint64) (v string) {
	var outBuilder strings.Builder
	outBuilder.WriteString("{")
	cnt := rand.Int31n(int32(this.cnf.Max-this.cnf.Min)) + int32(this.cnf.Min)
	keys := make(map[string]bool, cnt)

	for i := 0; i < int(cnt); i++ {
		if i > 0 {
			outBuilder.WriteString(",")
		}
		outBuilder.WriteString(this.one(keys))
	}
	outBuilder.WriteString("}")
	return outBuilder.String()
}

func (this *BruteCaseMap) Count() uint64 {
	return this.key.Count()
}

func ParseParamMap(data string) (cnf BruteCaseCnf, err error) {
	matches := caseCnfMapRe.FindStringSubmatch(data)
	if len(matches) != 7 {
		err = fmt.Errorf("caseCnfMapRe match len:%d not 5", len(matches))
		return
	}

	key, err := ParseCnf(matches[3], matches[4])
	if err != nil {
		return
	}

	value, err := ParseCnf(matches[5], matches[6])
	if err != nil {
		return
	}

	min := int64(randCntMapLenMin)
	max := int64(randCntMapLenMax)
	i, l, e := Int64(matches[1])
	if e != nil {
		err = e
		return
	}

	if l > 0 {
		min = i
	}

	i, l, e = Int64(matches[2])
	if e != nil {
		err = e
		return
	}

	if l > 0 {
		max = i
	}

	cnf = &BruteCaseCnfMap{
		Min:   int(min),
		Max:   int(max),
		Key:   key,
		Value: value,
	}
	return
}

type BruteMsgCnf struct {
	Test bool
	Pre  string

	MsgName   string
	MsgId     int
	ResponeId int
	Timeout   int64

	Data string
	Ctxs []string
	Cnfs []BruteCaseCnf
}

func (this *BruteMsgCnf) Generator(skip uint64, cnt uint64) *BruteMsgGenerator {
	cnfCnt := len(this.Cnfs)
	cases := make([]BruteCase, cnfCnt)
	caseCnts := make([]uint64, cnfCnt)
	testCnt := uint64(1)
	for i := cnfCnt - 1; i >= 0; i-- {
		c := this.Cnfs[i]

		cases[i] = c.Case()
		if cases[i] == nil {
			return nil
		}

		testCnt = testCnt * cases[i].Count()
		if i > 0 {
			caseCnts[i-1] = testCnt
		}
	}

	var caseNows []string
	if cnfCnt > 0 {
		caseNows = make([]string, cnfCnt)
		caseCnts[cnfCnt-1] = 1
	}

	step := uint64(1)
	if testCnt > generator_cnt_max {
		step = testCnt / generator_cnt_max
	}

	gen := BruteMsgGenerator{
		iteratoring: false,
		cnf:         this,
		cases:       cases,
		casesNows:   caseNows,

		caseCnts: caseCnts,
		cnt:      testCnt,
		skip:     skip,
		limit:    cnt,

		step: step,
	}

	return &gen
}

// 设置offset、Count，实现一个generator拆分不同task并发测试
// 使用Step来进行实际测试数量调整。因为一个robot 10ms一次测试，限制一个测试单元的测试次数在30万次以内。如果超过了，就会使用Step进行随机跳跃
type BruteMsgGenerator struct {
	iteratoring bool // 是否遍历过程中
	cnf         *BruteMsgCnf
	cases       []BruteCase
	casesNows   []string
	format      string

	cnt      uint64   // 用例总次数
	caseCnts []uint64 // 每个用例的次数
	skip     uint64   // 跳过的用例数

	index uint64 // 当前返回次数
	limit uint64 // 限制的用例数

	step uint64 // 获取用例的步长
}

func (this *BruteMsgGenerator) reset() {
	this.iteratoring = false
}

func (this *BruteMsgGenerator) _next() (bool, string) {
	index := 0
	if !this.iteratoring {
		this.iteratoring = true
		// 还未初始化
		caseLen := len(this.cases)
		if caseLen == 0 {
			// 没有随机
			return true, this.cnf.Ctxs[0]
		}

		var formatBuild strings.Builder
		formatBuild.WriteString(this.cnf.Ctxs[index])

		for ; index < caseLen-1; index++ {
			_, this.casesNows[index] = this.cases[index].Next()
			formatBuild.WriteString(this.casesNows[index])
			formatBuild.WriteString(this.cnf.Ctxs[index+1])
		}

		formatBuild.WriteString("%s")
		formatBuild.WriteString(this.cnf.Ctxs[index+1])

		this.format = formatBuild.String()
	}

	if len(this.cases) == 0 {
		// 无随机
		return false, ""
	}
	index = len(this.cases) - 1
	ok, cs := this.cases[index].Next()
	if !ok {
		// 需要进行format重新生成
		index--

		for ; index >= 0; index-- {
			ok, cs = this.cases[index].Next()
			if ok {
				break
			}
		}

		if !ok {
			// 遍历结束
			return false, ""
		}

		this.casesNows[index] = cs

		var formatBuild strings.Builder
		for i := 0; i <= index; i++ {
			formatBuild.WriteString(this.cnf.Ctxs[i])
			formatBuild.WriteString(this.casesNows[i])
		}

		for index++; index < len(this.cases)-1; index++ {
			formatBuild.WriteString(this.cnf.Ctxs[index])
			_, this.casesNows[index] = this.cases[index].Next()
			formatBuild.WriteString(this.casesNows[index])
		}

		formatBuild.WriteString(this.cnf.Ctxs[index])
		formatBuild.WriteString("%s")
		formatBuild.WriteString(this.cnf.Ctxs[index+1])

		this.format = formatBuild.String()

		ok, cs = this.cases[index].Next()
	}

	return true, fmt.Sprintf(this.format, cs)
}

func (this *BruteMsgGenerator) _step(step uint64) string {
	var b strings.Builder
	if !this.iteratoring {
		step = this.skip
		for i := 0; i < len(this.cases); i++ {
			b.WriteString(this.cnf.Ctxs[i])
			cStep := (step / this.caseCnts[i]) % this.cases[i].Count()
			if cStep > 0 {
				this.casesNows[i] = this.cases[i].Step(cStep)
			} else {
				this.casesNows[i] = this.cases[i].Step(1)
			}
			b.WriteString(this.casesNows[i])
		}
		this.iteratoring = true
	} else {
		for i := 0; i < len(this.cases); i++ {
			b.WriteString(this.cnf.Ctxs[i])
			cStep := (step / this.caseCnts[i]) % this.cases[i].Count()
			if cStep > 0 {
				this.casesNows[i] = this.cases[i].Step(cStep)
			}
			b.WriteString(this.casesNows[i])
		}
	}
	b.WriteString(this.cnf.Ctxs[len(this.cases)])

	return b.String()
}

func (this *BruteMsgGenerator) Next() (bool, string) {
	if this.limit > 0 && this.index > this.limit {
		this.reset()
		return false, ""
	}

	if this.step == 1 {
		ok, s := this._next()
		if !ok {
			this.reset()
		} else {
			this.index++
		}
		return ok, s
	}

	this.index++
	return true, this._step(this.step)
}

func (this *BruteMsgGenerator) RealCount() uint64 {
	return this.cnt
}

func (this *BruteMsgGenerator) Count() uint64 {
	return this.cnt / this.step
}

func (this *BruteMsgGenerator) Step() uint64 {
	return this.step
}

func (this *BruteMsgGenerator) BruteCnf() *BruteMsgCnf {
	return this.cnf
}

func ParseCnf(t string, param string) (cnf BruteCaseCnf, err error) {
	switch t {
	case "I8":
		cnf, err = ParseParamInt(param, BruteCaseType_Int8)
		if err != nil {
			return
		}
	case "I16":
		cnf, err = ParseParamInt(param, BruteCaseType_Int16)
		if err != nil {
			return
		}
	case "I32":
		cnf, err = ParseParamInt(param, BruteCaseType_Int32)
		if err != nil {
			return
		}
	case "I64":
		cnf, err = ParseParamInt(param, BruteCaseType_Int64)
		if err != nil {
			return
		}
	case "U8":
		cnf, err = ParseParamUint(param, BruteCaseType_Uint8)
		if err != nil {
			return
		}
	case "U16":
		cnf, err = ParseParamUint(param, BruteCaseType_Uint16)
		if err != nil {
			return
		}
	case "U32":
		cnf, err = ParseParamUint(param, BruteCaseType_Uint32)
		if err != nil {
			return
		}
	case "U64":
		cnf, err = ParseParamUint(param, BruteCaseType_Uint64)
		if err != nil {
			return
		}
	case "F32":
		cnf, err = ParseParamFloat(param, BruteCaseType_Float32)
		if err != nil {
			return
		}
	case "F64":
		cnf, err = ParseParamFloat(param, BruteCaseType_Float64)
		if err != nil {
			return
		}
	case "BL":
		cnf = &BruteCaseCnfBool{}
	case "STR":
		cnf, err = ParseParamString(param)
		if err != nil {
			return
		}
	case "BS":
		cnf, err = ParseParamByteString(param)
		if err != nil {
			return
		}
	case "MSG":
		cnf, err = ParseParamMsg(param)
		if err != nil {
			return
		}
	case "ARR":
		cnf, err = ParseParamArray(param)
		if err != nil {
			return
		}
	case "MAP":
		cnf, err = ParseParamMap(param)
		if err != nil {
			return
		}
	default:
		err = fmt.Errorf("type:%s err %s", t, param)
	}

	return
}

func Json2Brute(data string) (ctxs []string, cnfs []BruteCaseCnf, err error) {
	// 查找随机，记录
	ctxs = make([]string, 0, 10)
	cnfs = make([]BruteCaseCnf, 0, 9)

	lastIndex := 0
	caseIndexes := caseCnfRe.FindAllStringSubmatchIndex(data, -1)
	for _, v := range caseIndexes {
		var c BruteCaseCnf
		c, err = ParseCnf(data[v[2]:v[3]], data[v[4]:v[5]])
		ctxs = append(ctxs, data[lastIndex:v[0]+1])
		lastIndex = v[1]
		cnfs = append(cnfs, c)
	}

	if lastIndex < len(data) {
		ctxs = append(ctxs, data[lastIndex:])
	}

	return
}

func BruteTestFileExsit(file string) bool {
	f, err := os.Stat(fmt.Sprintf("%s/%s", prePath, file))
	if err != nil {
		log.LogError("os.State %s/%s err:%s", prePath, file, err.Error())
		return false
	}

	return f != nil
}
func BruteTestCreate(file string) (err error) {
	// 进行配置加载
	readFile, err := ioutil.ReadFile(fmt.Sprintf("%s/%s", prePath, file))
	if err != nil {
		log.LogError("File open:%s/%s err:%s", prePath, file, err.Error())
		return
	}

	v, err := fastjson.ParseBytes(readFile)
	if err != nil {
		log.LogError("File:%s fastjson Parse err:%s", file, err.Error())
		return
	}

	a, err := v.Array()
	if err != nil {
		log.LogError("File:%s Object Get err:%s", file, err.Error())
		return
	}

	caseId := 1
	for i := 0; i < len(a); i++ {
		c := BruteMsgCnf{}
		m := a[i]

		c.Test = !m.GetBool("notest")
		c.Pre = string(m.GetStringBytes("premsg"))

		c.MsgName = string(m.GetStringBytes("msgname"))
		c.MsgId = m.GetInt("msgid")
		c.ResponeId = m.GetInt("responseid")
		c.Timeout = m.GetInt64("timeout")

		c.Data = m.GetObject("data").String()

		// 进行data文本解析
		c.Ctxs, c.Cnfs, err = Json2Brute(c.Data)
		if err != nil {
			log.LogError("msg:%s Json2Brute err:%s", c.MsgName, err.Error())
			return
		}

		if !c.Test {
			BrutetestMsgMap[c.MsgName] = &c
		} else {
			BrutetestMsgMap[c.MsgName] = &c
			msgSlice := make([]*BruteMsgCnf, 0, 1)
			msgSlice = append(msgSlice, &c)
			BrutetestCaselistMap[caseId] = msgSlice
			caseId++
		}
	}

	for _, mslice := range BrutetestCaselistMap {
		for pre := mslice[0].Pre; len(pre) > 0; {
			m, ok := BrutetestMsgMap[pre]
			if !ok {
				err = fmt.Errorf("msg:%s pre:%s nil", mslice[len(mslice)-1].MsgName, pre)
				return
			}

			mslice = append(mslice, m)
			pre = m.Pre
		}
	}

	return
}

func BruteTestSave(file string) {
	brutes := make([]*BruteMsgCnf, 0, len(BrutetestMsgMap))
	for _, b := range BrutetestMsgMap {
		brutes = append(brutes, b)
	}

	sort.Slice(brutes, func(i, j int) bool {
		if brutes[i].MsgId > 0 && brutes[j].MsgId > 0 {
			return brutes[i].MsgId < brutes[j].MsgId
		}

		if brutes[i].MsgId > 0 {
			return true
		}

		if brutes[j].MsgId > 0 {
			return false
		}

		return brutes[i].MsgName < brutes[j].MsgName
	})

	writeFile, err := os.OpenFile(fmt.Sprintf("%s/%s", prePath, file), os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0666)
	if err != nil {
		log.LogError("No File:%s/%s", prePath, file)
		return
	}

	if len(brutes) == 0 {
		log.LogInfo("brute msg 0")
		return
	}

	log.LogInfo("%s/%s brutes cnt:%d", prePath, file, len(brutes))
	writeFile.WriteString("[")

	for i := 0; i < len(brutes); i++ {
		b := brutes[i]

		if b.Test {
			tCnt := b.Generator(0, 0).Count()
			if tCnt > testcnt_warn {
				log.LogError("%s Test Count:%d try mannual config", b.MsgName, tCnt)
			}
		}

		if i == 0 {
			writeFile.WriteString("\n\t{\n")
		} else {
			writeFile.WriteString(",\n\t{\n")
		}

		writeFile.WriteString(fmt.Sprintf("\t\t\"msgname\":\"%s\",\n", b.MsgName))
		if !b.Test {
			writeFile.WriteString("\t\t\"notest\":true,\n")
		} else {
			writeFile.WriteString(fmt.Sprintf("\t\t\"msgid\":%d,\n", b.MsgId))
			writeFile.WriteString(fmt.Sprintf("\t\t\"responseid\":%d,\n", b.ResponeId))
			if b.Timeout != 0 {
				writeFile.WriteString(fmt.Sprintf("\t\t\"timeout\":%d,\n", b.Timeout))
			}
		}

		if len(b.Pre) > 0 {
			writeFile.WriteString(fmt.Sprintf("\t\t\"premsg\":\"%s\",\n", b.Pre))
		}

		var buf bytes.Buffer
		err := json.Indent(&buf, []byte(b.Data), "", "\t\t\t")
		if err != nil {
			log.LogError("%d Indent err:%s", b.Data, err.Error())
		}
		if buf.Len() > 2 {
			buf.Truncate(buf.Len() - 1)
			buf.WriteString("\t\t}")
		}
		writeFile.WriteString(fmt.Sprintf("\t\t\"data\":%s", buf.String()))

		writeFile.WriteString("\n\t}")
	}
	writeFile.WriteString("\n]")

	writeFile.Sync()
	writeFile.Close()
}