func regexMatchGen(regex *syntax.Regexp) gopter.Gen { switch regex.Op { case syntax.OpLiteral: return Const(string(regex.Rune)) case syntax.OpCharClass: gens := make([]gopter.Gen, 0, len(regex.Rune)/2) for i := 0; i+1 < len(regex.Rune); i += 2 { gens = append(gens, RuneRange(regex.Rune[i], regex.Rune[i+1]).Map(func(v interface{}) interface{} { return string(v.(rune)) })) } return OneGenOf(gens...) case syntax.OpAnyChar: return Rune().Map(func(v interface{}) interface{} { return string(v.(rune)) }) case syntax.OpAnyCharNotNL: return RuneNoControl().Map(func(v interface{}) interface{} { return string(v.(rune)) }) case syntax.OpCapture: return regexMatchGen(regex.Sub[0]) case syntax.OpStar: elementGen := regexMatchGen(regex.Sub[0]) return SliceOf(elementGen).Map(func(v interface{}) interface{} { return strings.Join(v.([]string), "") }) case syntax.OpPlus: elementGen := regexMatchGen(regex.Sub[0]) return gopter.CombineGens(elementGen, SliceOf(elementGen)).Map(func(v interface{}) interface{} { vs := v.([]interface{}) return vs[0].(string) + strings.Join(vs[1].([]string), "") }) case syntax.OpQuest: elementGen := regexMatchGen(regex.Sub[0]) return OneGenOf(Const(""), elementGen) case syntax.OpConcat: gens := make([]gopter.Gen, len(regex.Sub)) for i, sub := range regex.Sub { gens[i] = regexMatchGen(sub) } return gopter.CombineGens(gens...).Map(func(v interface{}) interface{} { result := "" for _, str := range v.([]interface{}) { result += str.(string) } return result }) case syntax.OpAlternate: gens := make([]gopter.Gen, len(regex.Sub)) for i, sub := range regex.Sub { gens[i] = regexMatchGen(sub) } return OneGenOf(gens...) } return Const("") }
// Complex64 generate arbitrary complex64 numbers func Complex64() gopter.Gen { return gopter.CombineGens( Float32(), Float32(), ).Map(func(v interface{}) interface{} { values := v.([]interface{}) return complex(values[0].(float32), values[1].(float32)) }).WithShrinker(Complex64Shrinker) }
// Complex128Box generate complex128 numbers within a rectangle/box in the complex plane func Complex128Box(min, max complex128) gopter.Gen { return gopter.CombineGens( Float64Range(real(min), real(max)), Float64Range(imag(min), imag(max)), ).Map(func(v interface{}) interface{} { values := v.([]interface{}) return complex(values[0].(float64), values[1].(float64)) }).SuchThat(func(v interface{}) bool { c := v.(complex128) return real(c) >= real(min) && real(c) <= real(max) && imag(c) >= imag(min) && imag(c) <= imag(max) }).WithShrinker(Complex128Shrinker) }
// Float32 generates arbitrary float32 numbers that do not contain NaN or Inf func Float32() gopter.Gen { return gopter.CombineGens( Int32Range(0, 1), Int32Range(0, 0xfe), Int32Range(0, 0x7fffff), ).Map(func(v interface{}) interface{} { values := v.([]interface{}) sign := uint32(values[0].(int32)) exponent := uint32(values[1].(int32)) mantissa := uint32(values[2].(int32)) return math.Float32frombits((sign << 31) | (exponent << 23) | mantissa) }).WithShrinker(Float32Shrinker) }
// Identifier generates an arbitrary identifier string // Identitiers are supporsed to start with a lowercase letter and contain only // letters and digits func Identifier() gopter.Gen { return gopter.CombineGens( AlphaLowerChar(), SliceOf(AlphaNumChar()), ).Map(func(v interface{}) interface{} { values := v.([]interface{}) first := values[0].(rune) tail := values[1].([]rune) result := make([]rune, 0, len(tail)+1) return string(append(append(result, first), tail...)) }).SuchThat(func(v interface{}) bool { str := v.(string) if len(str) < 1 || !unicode.IsLower(([]rune(str))[0]) { return false } for _, ch := range str { if !unicode.IsLetter(ch) && !unicode.IsDigit(ch) { return false } } return true }).WithShrinker(StringShrinker) }