id
int32 0
167k
| repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
listlengths 21
1.41k
| docstring
stringlengths 6
2.61k
| docstring_tokens
listlengths 3
215
| sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
9,300 |
leanovate/gopter
|
gen_parameters.go
|
NextInt64
|
func (p *GenParameters) NextInt64() int64 {
v := p.Rng.Int63()
if p.NextBool() {
return -v
}
return v
}
|
go
|
func (p *GenParameters) NextInt64() int64 {
v := p.Rng.Int63()
if p.NextBool() {
return -v
}
return v
}
|
[
"func",
"(",
"p",
"*",
"GenParameters",
")",
"NextInt64",
"(",
")",
"int64",
"{",
"v",
":=",
"p",
".",
"Rng",
".",
"Int63",
"(",
")",
"\n",
"if",
"p",
".",
"NextBool",
"(",
")",
"{",
"return",
"-",
"v",
"\n",
"}",
"\n",
"return",
"v",
"\n",
"}"
] |
// NextInt64 create a random int64 using the underlying Rng.
|
[
"NextInt64",
"create",
"a",
"random",
"int64",
"using",
"the",
"underlying",
"Rng",
"."
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen_parameters.go#L30-L36
|
9,301 |
leanovate/gopter
|
gen_parameters.go
|
NextUint64
|
func (p *GenParameters) NextUint64() uint64 {
first := uint64(p.Rng.Int63())
second := uint64(p.Rng.Int63())
return (first << 1) ^ second
}
|
go
|
func (p *GenParameters) NextUint64() uint64 {
first := uint64(p.Rng.Int63())
second := uint64(p.Rng.Int63())
return (first << 1) ^ second
}
|
[
"func",
"(",
"p",
"*",
"GenParameters",
")",
"NextUint64",
"(",
")",
"uint64",
"{",
"first",
":=",
"uint64",
"(",
"p",
".",
"Rng",
".",
"Int63",
"(",
")",
")",
"\n",
"second",
":=",
"uint64",
"(",
"p",
".",
"Rng",
".",
"Int63",
"(",
")",
")",
"\n\n",
"return",
"(",
"first",
"<<",
"1",
")",
"^",
"second",
"\n",
"}"
] |
// NextUint64 create a random uint64 using the underlying Rng.
|
[
"NextUint64",
"create",
"a",
"random",
"uint64",
"using",
"the",
"underlying",
"Rng",
"."
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen_parameters.go#L39-L44
|
9,302 |
leanovate/gopter
|
gen_parameters.go
|
DefaultGenParameters
|
func DefaultGenParameters() *GenParameters {
seed := time.Now().UnixNano()
return &GenParameters{
MinSize: 0,
MaxSize: 100,
MaxShrinkCount: 1000,
Rng: rand.New(NewLockedSource(seed)),
}
}
|
go
|
func DefaultGenParameters() *GenParameters {
seed := time.Now().UnixNano()
return &GenParameters{
MinSize: 0,
MaxSize: 100,
MaxShrinkCount: 1000,
Rng: rand.New(NewLockedSource(seed)),
}
}
|
[
"func",
"DefaultGenParameters",
"(",
")",
"*",
"GenParameters",
"{",
"seed",
":=",
"time",
".",
"Now",
"(",
")",
".",
"UnixNano",
"(",
")",
"\n\n",
"return",
"&",
"GenParameters",
"{",
"MinSize",
":",
"0",
",",
"MaxSize",
":",
"100",
",",
"MaxShrinkCount",
":",
"1000",
",",
"Rng",
":",
"rand",
".",
"New",
"(",
"NewLockedSource",
"(",
"seed",
")",
")",
",",
"}",
"\n",
"}"
] |
// DefaultGenParameters creates default GenParameters.
|
[
"DefaultGenParameters",
"creates",
"default",
"GenParameters",
"."
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen_parameters.go#L59-L68
|
9,303 |
leanovate/gopter
|
gen/floats.go
|
Float64Range
|
func Float64Range(min, max float64) gopter.Gen {
d := max - min
if d < 0 || d > math.MaxFloat64 {
return Fail(reflect.TypeOf(float64(0)))
}
return func(genParams *gopter.GenParameters) *gopter.GenResult {
genResult := gopter.NewGenResult(min+genParams.Rng.Float64()*d, Float64Shrinker)
genResult.Sieve = func(v interface{}) bool {
return v.(float64) >= min && v.(float64) <= max
}
return genResult
}
}
|
go
|
func Float64Range(min, max float64) gopter.Gen {
d := max - min
if d < 0 || d > math.MaxFloat64 {
return Fail(reflect.TypeOf(float64(0)))
}
return func(genParams *gopter.GenParameters) *gopter.GenResult {
genResult := gopter.NewGenResult(min+genParams.Rng.Float64()*d, Float64Shrinker)
genResult.Sieve = func(v interface{}) bool {
return v.(float64) >= min && v.(float64) <= max
}
return genResult
}
}
|
[
"func",
"Float64Range",
"(",
"min",
",",
"max",
"float64",
")",
"gopter",
".",
"Gen",
"{",
"d",
":=",
"max",
"-",
"min",
"\n",
"if",
"d",
"<",
"0",
"||",
"d",
">",
"math",
".",
"MaxFloat64",
"{",
"return",
"Fail",
"(",
"reflect",
".",
"TypeOf",
"(",
"float64",
"(",
"0",
")",
")",
")",
"\n",
"}",
"\n\n",
"return",
"func",
"(",
"genParams",
"*",
"gopter",
".",
"GenParameters",
")",
"*",
"gopter",
".",
"GenResult",
"{",
"genResult",
":=",
"gopter",
".",
"NewGenResult",
"(",
"min",
"+",
"genParams",
".",
"Rng",
".",
"Float64",
"(",
")",
"*",
"d",
",",
"Float64Shrinker",
")",
"\n",
"genResult",
".",
"Sieve",
"=",
"func",
"(",
"v",
"interface",
"{",
"}",
")",
"bool",
"{",
"return",
"v",
".",
"(",
"float64",
")",
">=",
"min",
"&&",
"v",
".",
"(",
"float64",
")",
"<=",
"max",
"\n",
"}",
"\n",
"return",
"genResult",
"\n",
"}",
"\n",
"}"
] |
// Float64Range generates float64 numbers within a given range
|
[
"Float64Range",
"generates",
"float64",
"numbers",
"within",
"a",
"given",
"range"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen/floats.go#L11-L24
|
9,304 |
leanovate/gopter
|
gen/floats.go
|
Float64
|
func Float64() gopter.Gen {
return gopter.CombineGens(
Int64Range(0, 1),
Int64Range(0, 0x7fe),
Int64Range(0, 0xfffffffffffff),
).Map(func(values []interface{}) float64 {
sign := uint64(values[0].(int64))
exponent := uint64(values[1].(int64))
mantissa := uint64(values[2].(int64))
return math.Float64frombits((sign << 63) | (exponent << 52) | mantissa)
}).WithShrinker(Float64Shrinker)
}
|
go
|
func Float64() gopter.Gen {
return gopter.CombineGens(
Int64Range(0, 1),
Int64Range(0, 0x7fe),
Int64Range(0, 0xfffffffffffff),
).Map(func(values []interface{}) float64 {
sign := uint64(values[0].(int64))
exponent := uint64(values[1].(int64))
mantissa := uint64(values[2].(int64))
return math.Float64frombits((sign << 63) | (exponent << 52) | mantissa)
}).WithShrinker(Float64Shrinker)
}
|
[
"func",
"Float64",
"(",
")",
"gopter",
".",
"Gen",
"{",
"return",
"gopter",
".",
"CombineGens",
"(",
"Int64Range",
"(",
"0",
",",
"1",
")",
",",
"Int64Range",
"(",
"0",
",",
"0x7fe",
")",
",",
"Int64Range",
"(",
"0",
",",
"0xfffffffffffff",
")",
",",
")",
".",
"Map",
"(",
"func",
"(",
"values",
"[",
"]",
"interface",
"{",
"}",
")",
"float64",
"{",
"sign",
":=",
"uint64",
"(",
"values",
"[",
"0",
"]",
".",
"(",
"int64",
")",
")",
"\n",
"exponent",
":=",
"uint64",
"(",
"values",
"[",
"1",
"]",
".",
"(",
"int64",
")",
")",
"\n",
"mantissa",
":=",
"uint64",
"(",
"values",
"[",
"2",
"]",
".",
"(",
"int64",
")",
")",
"\n\n",
"return",
"math",
".",
"Float64frombits",
"(",
"(",
"sign",
"<<",
"63",
")",
"|",
"(",
"exponent",
"<<",
"52",
")",
"|",
"mantissa",
")",
"\n",
"}",
")",
".",
"WithShrinker",
"(",
"Float64Shrinker",
")",
"\n",
"}"
] |
// Float64 generates arbitrary float64 numbers that do not contain NaN or Inf
|
[
"Float64",
"generates",
"arbitrary",
"float64",
"numbers",
"that",
"do",
"not",
"contain",
"NaN",
"or",
"Inf"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen/floats.go#L27-L39
|
9,305 |
leanovate/gopter
|
gen/floats.go
|
Float32Range
|
func Float32Range(min, max float32) gopter.Gen {
d := max - min
if d < 0 || d > math.MaxFloat32 {
return Fail(reflect.TypeOf(float32(0)))
}
return func(genParams *gopter.GenParameters) *gopter.GenResult {
genResult := gopter.NewGenResult(min+genParams.Rng.Float32()*d, Float32Shrinker)
genResult.Sieve = func(v interface{}) bool {
return v.(float32) >= min && v.(float32) <= max
}
return genResult
}
}
|
go
|
func Float32Range(min, max float32) gopter.Gen {
d := max - min
if d < 0 || d > math.MaxFloat32 {
return Fail(reflect.TypeOf(float32(0)))
}
return func(genParams *gopter.GenParameters) *gopter.GenResult {
genResult := gopter.NewGenResult(min+genParams.Rng.Float32()*d, Float32Shrinker)
genResult.Sieve = func(v interface{}) bool {
return v.(float32) >= min && v.(float32) <= max
}
return genResult
}
}
|
[
"func",
"Float32Range",
"(",
"min",
",",
"max",
"float32",
")",
"gopter",
".",
"Gen",
"{",
"d",
":=",
"max",
"-",
"min",
"\n",
"if",
"d",
"<",
"0",
"||",
"d",
">",
"math",
".",
"MaxFloat32",
"{",
"return",
"Fail",
"(",
"reflect",
".",
"TypeOf",
"(",
"float32",
"(",
"0",
")",
")",
")",
"\n",
"}",
"\n",
"return",
"func",
"(",
"genParams",
"*",
"gopter",
".",
"GenParameters",
")",
"*",
"gopter",
".",
"GenResult",
"{",
"genResult",
":=",
"gopter",
".",
"NewGenResult",
"(",
"min",
"+",
"genParams",
".",
"Rng",
".",
"Float32",
"(",
")",
"*",
"d",
",",
"Float32Shrinker",
")",
"\n",
"genResult",
".",
"Sieve",
"=",
"func",
"(",
"v",
"interface",
"{",
"}",
")",
"bool",
"{",
"return",
"v",
".",
"(",
"float32",
")",
">=",
"min",
"&&",
"v",
".",
"(",
"float32",
")",
"<=",
"max",
"\n",
"}",
"\n",
"return",
"genResult",
"\n",
"}",
"\n",
"}"
] |
// Float32Range generates float32 numbers within a given range
|
[
"Float32Range",
"generates",
"float32",
"numbers",
"within",
"a",
"given",
"range"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen/floats.go#L42-L54
|
9,306 |
leanovate/gopter
|
gen/floats.go
|
Float32
|
func Float32() gopter.Gen {
return gopter.CombineGens(
Int32Range(0, 1),
Int32Range(0, 0xfe),
Int32Range(0, 0x7fffff),
).Map(func(values []interface{}) float32 {
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)
}
|
go
|
func Float32() gopter.Gen {
return gopter.CombineGens(
Int32Range(0, 1),
Int32Range(0, 0xfe),
Int32Range(0, 0x7fffff),
).Map(func(values []interface{}) float32 {
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)
}
|
[
"func",
"Float32",
"(",
")",
"gopter",
".",
"Gen",
"{",
"return",
"gopter",
".",
"CombineGens",
"(",
"Int32Range",
"(",
"0",
",",
"1",
")",
",",
"Int32Range",
"(",
"0",
",",
"0xfe",
")",
",",
"Int32Range",
"(",
"0",
",",
"0x7fffff",
")",
",",
")",
".",
"Map",
"(",
"func",
"(",
"values",
"[",
"]",
"interface",
"{",
"}",
")",
"float32",
"{",
"sign",
":=",
"uint32",
"(",
"values",
"[",
"0",
"]",
".",
"(",
"int32",
")",
")",
"\n",
"exponent",
":=",
"uint32",
"(",
"values",
"[",
"1",
"]",
".",
"(",
"int32",
")",
")",
"\n",
"mantissa",
":=",
"uint32",
"(",
"values",
"[",
"2",
"]",
".",
"(",
"int32",
")",
")",
"\n\n",
"return",
"math",
".",
"Float32frombits",
"(",
"(",
"sign",
"<<",
"31",
")",
"|",
"(",
"exponent",
"<<",
"23",
")",
"|",
"mantissa",
")",
"\n",
"}",
")",
".",
"WithShrinker",
"(",
"Float32Shrinker",
")",
"\n",
"}"
] |
// Float32 generates arbitrary float32 numbers that do not contain NaN or Inf
|
[
"Float32",
"generates",
"arbitrary",
"float32",
"numbers",
"that",
"do",
"not",
"contain",
"NaN",
"or",
"Inf"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen/floats.go#L57-L69
|
9,307 |
leanovate/gopter
|
gen/string_shrink.go
|
StringShrinker
|
func StringShrinker(v interface{}) gopter.Shrink {
return runeSliceShrinker([]rune(v.(string))).Map(runesToString)
}
|
go
|
func StringShrinker(v interface{}) gopter.Shrink {
return runeSliceShrinker([]rune(v.(string))).Map(runesToString)
}
|
[
"func",
"StringShrinker",
"(",
"v",
"interface",
"{",
"}",
")",
"gopter",
".",
"Shrink",
"{",
"return",
"runeSliceShrinker",
"(",
"[",
"]",
"rune",
"(",
"v",
".",
"(",
"string",
")",
")",
")",
".",
"Map",
"(",
"runesToString",
")",
"\n",
"}"
] |
// StringShrinker is a shrinker for strings.
// It is very similar to a sliace shrinker just that the elements themselves will not be shrinkeed.
|
[
"StringShrinker",
"is",
"a",
"shrinker",
"for",
"strings",
".",
"It",
"is",
"very",
"similar",
"to",
"a",
"sliace",
"shrinker",
"just",
"that",
"the",
"elements",
"themselves",
"will",
"not",
"be",
"shrinkeed",
"."
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen/string_shrink.go#L9-L11
|
9,308 |
leanovate/gopter
|
properties.go
|
NewProperties
|
func NewProperties(parameters *TestParameters) *Properties {
if parameters == nil {
parameters = DefaultTestParameters()
}
return &Properties{
parameters: parameters,
props: make(map[string]Prop, 0),
propNames: make([]string, 0),
}
}
|
go
|
func NewProperties(parameters *TestParameters) *Properties {
if parameters == nil {
parameters = DefaultTestParameters()
}
return &Properties{
parameters: parameters,
props: make(map[string]Prop, 0),
propNames: make([]string, 0),
}
}
|
[
"func",
"NewProperties",
"(",
"parameters",
"*",
"TestParameters",
")",
"*",
"Properties",
"{",
"if",
"parameters",
"==",
"nil",
"{",
"parameters",
"=",
"DefaultTestParameters",
"(",
")",
"\n",
"}",
"\n",
"return",
"&",
"Properties",
"{",
"parameters",
":",
"parameters",
",",
"props",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"Prop",
",",
"0",
")",
",",
"propNames",
":",
"make",
"(",
"[",
"]",
"string",
",",
"0",
")",
",",
"}",
"\n",
"}"
] |
// NewProperties create new Properties with given test parameters.
// If parameters is nil default test parameters will be used
|
[
"NewProperties",
"create",
"new",
"Properties",
"with",
"given",
"test",
"parameters",
".",
"If",
"parameters",
"is",
"nil",
"default",
"test",
"parameters",
"will",
"be",
"used"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/properties.go#L14-L23
|
9,309 |
leanovate/gopter
|
properties.go
|
Run
|
func (p *Properties) Run(reporter Reporter) bool {
success := true
for _, propName := range p.propNames {
prop := p.props[propName]
result := prop.Check(p.parameters)
reporter.ReportTestResult(propName, result)
if !result.Passed() {
success = false
}
}
return success
}
|
go
|
func (p *Properties) Run(reporter Reporter) bool {
success := true
for _, propName := range p.propNames {
prop := p.props[propName]
result := prop.Check(p.parameters)
reporter.ReportTestResult(propName, result)
if !result.Passed() {
success = false
}
}
return success
}
|
[
"func",
"(",
"p",
"*",
"Properties",
")",
"Run",
"(",
"reporter",
"Reporter",
")",
"bool",
"{",
"success",
":=",
"true",
"\n",
"for",
"_",
",",
"propName",
":=",
"range",
"p",
".",
"propNames",
"{",
"prop",
":=",
"p",
".",
"props",
"[",
"propName",
"]",
"\n\n",
"result",
":=",
"prop",
".",
"Check",
"(",
"p",
".",
"parameters",
")",
"\n\n",
"reporter",
".",
"ReportTestResult",
"(",
"propName",
",",
"result",
")",
"\n",
"if",
"!",
"result",
".",
"Passed",
"(",
")",
"{",
"success",
"=",
"false",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"success",
"\n",
"}"
] |
// Run checks all definied propertiesand reports the result
|
[
"Run",
"checks",
"all",
"definied",
"propertiesand",
"reports",
"the",
"result"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/properties.go#L32-L45
|
9,310 |
leanovate/gopter
|
gen.go
|
WithLabel
|
func (g Gen) WithLabel(label string) Gen {
return func(genParams *GenParameters) *GenResult {
result := g(genParams)
result.Labels = append(result.Labels, label)
return result
}
}
|
go
|
func (g Gen) WithLabel(label string) Gen {
return func(genParams *GenParameters) *GenResult {
result := g(genParams)
result.Labels = append(result.Labels, label)
return result
}
}
|
[
"func",
"(",
"g",
"Gen",
")",
"WithLabel",
"(",
"label",
"string",
")",
"Gen",
"{",
"return",
"func",
"(",
"genParams",
"*",
"GenParameters",
")",
"*",
"GenResult",
"{",
"result",
":=",
"g",
"(",
"genParams",
")",
"\n",
"result",
".",
"Labels",
"=",
"append",
"(",
"result",
".",
"Labels",
",",
"label",
")",
"\n",
"return",
"result",
"\n",
"}",
"\n",
"}"
] |
// WithLabel adds a label to a generated value.
// Labels are usually used for reporting for the arguments of a property check.
|
[
"WithLabel",
"adds",
"a",
"label",
"to",
"a",
"generated",
"value",
".",
"Labels",
"are",
"usually",
"used",
"for",
"reporting",
"for",
"the",
"arguments",
"of",
"a",
"property",
"check",
"."
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen.go#L33-L39
|
9,311 |
leanovate/gopter
|
gen.go
|
WithShrinker
|
func (g Gen) WithShrinker(shrinker Shrinker) Gen {
return func(genParams *GenParameters) *GenResult {
result := g(genParams)
if shrinker == nil {
result.Shrinker = NoShrinker
} else {
result.Shrinker = shrinker
}
return result
}
}
|
go
|
func (g Gen) WithShrinker(shrinker Shrinker) Gen {
return func(genParams *GenParameters) *GenResult {
result := g(genParams)
if shrinker == nil {
result.Shrinker = NoShrinker
} else {
result.Shrinker = shrinker
}
return result
}
}
|
[
"func",
"(",
"g",
"Gen",
")",
"WithShrinker",
"(",
"shrinker",
"Shrinker",
")",
"Gen",
"{",
"return",
"func",
"(",
"genParams",
"*",
"GenParameters",
")",
"*",
"GenResult",
"{",
"result",
":=",
"g",
"(",
"genParams",
")",
"\n",
"if",
"shrinker",
"==",
"nil",
"{",
"result",
".",
"Shrinker",
"=",
"NoShrinker",
"\n",
"}",
"else",
"{",
"result",
".",
"Shrinker",
"=",
"shrinker",
"\n",
"}",
"\n",
"return",
"result",
"\n",
"}",
"\n",
"}"
] |
// WithShrinker creates a derived generator with a specific shrinker
|
[
"WithShrinker",
"creates",
"a",
"derived",
"generator",
"with",
"a",
"specific",
"shrinker"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen.go#L90-L100
|
9,312 |
leanovate/gopter
|
gen.go
|
FlatMap
|
func (g Gen) FlatMap(f func(interface{}) Gen, resultType reflect.Type) Gen {
return func(genParams *GenParameters) *GenResult {
result := g(genParams)
value, ok := result.Retrieve()
if ok {
return f(value)(genParams)
}
return &GenResult{
Shrinker: NoShrinker,
Result: nil,
Labels: result.Labels,
ResultType: resultType,
}
}
}
|
go
|
func (g Gen) FlatMap(f func(interface{}) Gen, resultType reflect.Type) Gen {
return func(genParams *GenParameters) *GenResult {
result := g(genParams)
value, ok := result.Retrieve()
if ok {
return f(value)(genParams)
}
return &GenResult{
Shrinker: NoShrinker,
Result: nil,
Labels: result.Labels,
ResultType: resultType,
}
}
}
|
[
"func",
"(",
"g",
"Gen",
")",
"FlatMap",
"(",
"f",
"func",
"(",
"interface",
"{",
"}",
")",
"Gen",
",",
"resultType",
"reflect",
".",
"Type",
")",
"Gen",
"{",
"return",
"func",
"(",
"genParams",
"*",
"GenParameters",
")",
"*",
"GenResult",
"{",
"result",
":=",
"g",
"(",
"genParams",
")",
"\n",
"value",
",",
"ok",
":=",
"result",
".",
"Retrieve",
"(",
")",
"\n",
"if",
"ok",
"{",
"return",
"f",
"(",
"value",
")",
"(",
"genParams",
")",
"\n",
"}",
"\n",
"return",
"&",
"GenResult",
"{",
"Shrinker",
":",
"NoShrinker",
",",
"Result",
":",
"nil",
",",
"Labels",
":",
"result",
".",
"Labels",
",",
"ResultType",
":",
"resultType",
",",
"}",
"\n",
"}",
"\n",
"}"
] |
// FlatMap creates a derived generator by passing a generated value to a function which itself
// creates a generator.
|
[
"FlatMap",
"creates",
"a",
"derived",
"generator",
"by",
"passing",
"a",
"generated",
"value",
"to",
"a",
"function",
"which",
"itself",
"creates",
"a",
"generator",
"."
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen.go#L187-L201
|
9,313 |
leanovate/gopter
|
gen/slice_of.go
|
SliceOfN
|
func SliceOfN(desiredlen int, elementGen gopter.Gen, typeOverrides ...reflect.Type) gopter.Gen {
var typeOverride reflect.Type
if len(typeOverrides) > 1 {
panic("too many type overrides specified, at most 1 may be provided.")
} else if len(typeOverrides) == 1 {
typeOverride = typeOverrides[0]
}
return func(genParams *gopter.GenParameters) *gopter.GenResult {
result, elementSieve, elementShrinker := genSlice(elementGen, genParams, desiredlen, typeOverride)
genResult := gopter.NewGenResult(result.Interface(), SliceShrinkerOne(elementShrinker))
if elementSieve != nil {
genResult.Sieve = func(v interface{}) bool {
rv := reflect.ValueOf(v)
return rv.Len() == desiredlen && forAllSieve(elementSieve)(v)
}
} else {
genResult.Sieve = func(v interface{}) bool {
return reflect.ValueOf(v).Len() == desiredlen
}
}
return genResult
}
}
|
go
|
func SliceOfN(desiredlen int, elementGen gopter.Gen, typeOverrides ...reflect.Type) gopter.Gen {
var typeOverride reflect.Type
if len(typeOverrides) > 1 {
panic("too many type overrides specified, at most 1 may be provided.")
} else if len(typeOverrides) == 1 {
typeOverride = typeOverrides[0]
}
return func(genParams *gopter.GenParameters) *gopter.GenResult {
result, elementSieve, elementShrinker := genSlice(elementGen, genParams, desiredlen, typeOverride)
genResult := gopter.NewGenResult(result.Interface(), SliceShrinkerOne(elementShrinker))
if elementSieve != nil {
genResult.Sieve = func(v interface{}) bool {
rv := reflect.ValueOf(v)
return rv.Len() == desiredlen && forAllSieve(elementSieve)(v)
}
} else {
genResult.Sieve = func(v interface{}) bool {
return reflect.ValueOf(v).Len() == desiredlen
}
}
return genResult
}
}
|
[
"func",
"SliceOfN",
"(",
"desiredlen",
"int",
",",
"elementGen",
"gopter",
".",
"Gen",
",",
"typeOverrides",
"...",
"reflect",
".",
"Type",
")",
"gopter",
".",
"Gen",
"{",
"var",
"typeOverride",
"reflect",
".",
"Type",
"\n",
"if",
"len",
"(",
"typeOverrides",
")",
">",
"1",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"else",
"if",
"len",
"(",
"typeOverrides",
")",
"==",
"1",
"{",
"typeOverride",
"=",
"typeOverrides",
"[",
"0",
"]",
"\n",
"}",
"\n",
"return",
"func",
"(",
"genParams",
"*",
"gopter",
".",
"GenParameters",
")",
"*",
"gopter",
".",
"GenResult",
"{",
"result",
",",
"elementSieve",
",",
"elementShrinker",
":=",
"genSlice",
"(",
"elementGen",
",",
"genParams",
",",
"desiredlen",
",",
"typeOverride",
")",
"\n\n",
"genResult",
":=",
"gopter",
".",
"NewGenResult",
"(",
"result",
".",
"Interface",
"(",
")",
",",
"SliceShrinkerOne",
"(",
"elementShrinker",
")",
")",
"\n",
"if",
"elementSieve",
"!=",
"nil",
"{",
"genResult",
".",
"Sieve",
"=",
"func",
"(",
"v",
"interface",
"{",
"}",
")",
"bool",
"{",
"rv",
":=",
"reflect",
".",
"ValueOf",
"(",
"v",
")",
"\n",
"return",
"rv",
".",
"Len",
"(",
")",
"==",
"desiredlen",
"&&",
"forAllSieve",
"(",
"elementSieve",
")",
"(",
"v",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"genResult",
".",
"Sieve",
"=",
"func",
"(",
"v",
"interface",
"{",
"}",
")",
"bool",
"{",
"return",
"reflect",
".",
"ValueOf",
"(",
"v",
")",
".",
"Len",
"(",
")",
"==",
"desiredlen",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"genResult",
"\n",
"}",
"\n",
"}"
] |
// SliceOfN generates a slice of generated elements with definied length
|
[
"SliceOfN",
"generates",
"a",
"slice",
"of",
"generated",
"elements",
"with",
"definied",
"length"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen/slice_of.go#L43-L66
|
9,314 |
leanovate/gopter
|
gen/struct.go
|
Struct
|
func Struct(rt reflect.Type, gens map[string]gopter.Gen) gopter.Gen {
if rt.Kind() == reflect.Ptr {
rt = rt.Elem()
}
if rt.Kind() != reflect.Struct {
return Fail(rt)
}
fieldGens := []gopter.Gen{}
fieldTypes := []reflect.Type{}
for i := 0; i < rt.NumField(); i++ {
fieldName := rt.Field(i).Name
gen := gens[fieldName]
if gen != nil {
fieldGens = append(fieldGens, gen)
fieldTypes = append(fieldTypes, rt.Field(i).Type)
}
}
buildStructType := reflect.FuncOf(fieldTypes, []reflect.Type{rt}, false)
unbuildStructType := reflect.FuncOf([]reflect.Type{rt}, fieldTypes, false)
buildStructFunc := reflect.MakeFunc(buildStructType, func(args []reflect.Value) []reflect.Value {
result := reflect.New(rt)
for i := 0; i < rt.NumField(); i++ {
if _, ok := gens[rt.Field(i).Name]; !ok {
continue
}
result.Elem().Field(i).Set(args[0])
args = args[1:]
}
return []reflect.Value{result.Elem()}
})
unbuildStructFunc := reflect.MakeFunc(unbuildStructType, func(args []reflect.Value) []reflect.Value {
s := args[0]
results := []reflect.Value{}
for i := 0; i < s.NumField(); i++ {
if _, ok := gens[rt.Field(i).Name]; !ok {
continue
}
results = append(results, s.Field(i))
}
return results
})
return gopter.DeriveGen(
buildStructFunc.Interface(),
unbuildStructFunc.Interface(),
fieldGens...,
)
}
|
go
|
func Struct(rt reflect.Type, gens map[string]gopter.Gen) gopter.Gen {
if rt.Kind() == reflect.Ptr {
rt = rt.Elem()
}
if rt.Kind() != reflect.Struct {
return Fail(rt)
}
fieldGens := []gopter.Gen{}
fieldTypes := []reflect.Type{}
for i := 0; i < rt.NumField(); i++ {
fieldName := rt.Field(i).Name
gen := gens[fieldName]
if gen != nil {
fieldGens = append(fieldGens, gen)
fieldTypes = append(fieldTypes, rt.Field(i).Type)
}
}
buildStructType := reflect.FuncOf(fieldTypes, []reflect.Type{rt}, false)
unbuildStructType := reflect.FuncOf([]reflect.Type{rt}, fieldTypes, false)
buildStructFunc := reflect.MakeFunc(buildStructType, func(args []reflect.Value) []reflect.Value {
result := reflect.New(rt)
for i := 0; i < rt.NumField(); i++ {
if _, ok := gens[rt.Field(i).Name]; !ok {
continue
}
result.Elem().Field(i).Set(args[0])
args = args[1:]
}
return []reflect.Value{result.Elem()}
})
unbuildStructFunc := reflect.MakeFunc(unbuildStructType, func(args []reflect.Value) []reflect.Value {
s := args[0]
results := []reflect.Value{}
for i := 0; i < s.NumField(); i++ {
if _, ok := gens[rt.Field(i).Name]; !ok {
continue
}
results = append(results, s.Field(i))
}
return results
})
return gopter.DeriveGen(
buildStructFunc.Interface(),
unbuildStructFunc.Interface(),
fieldGens...,
)
}
|
[
"func",
"Struct",
"(",
"rt",
"reflect",
".",
"Type",
",",
"gens",
"map",
"[",
"string",
"]",
"gopter",
".",
"Gen",
")",
"gopter",
".",
"Gen",
"{",
"if",
"rt",
".",
"Kind",
"(",
")",
"==",
"reflect",
".",
"Ptr",
"{",
"rt",
"=",
"rt",
".",
"Elem",
"(",
")",
"\n",
"}",
"\n",
"if",
"rt",
".",
"Kind",
"(",
")",
"!=",
"reflect",
".",
"Struct",
"{",
"return",
"Fail",
"(",
"rt",
")",
"\n",
"}",
"\n",
"fieldGens",
":=",
"[",
"]",
"gopter",
".",
"Gen",
"{",
"}",
"\n",
"fieldTypes",
":=",
"[",
"]",
"reflect",
".",
"Type",
"{",
"}",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"rt",
".",
"NumField",
"(",
")",
";",
"i",
"++",
"{",
"fieldName",
":=",
"rt",
".",
"Field",
"(",
"i",
")",
".",
"Name",
"\n",
"gen",
":=",
"gens",
"[",
"fieldName",
"]",
"\n",
"if",
"gen",
"!=",
"nil",
"{",
"fieldGens",
"=",
"append",
"(",
"fieldGens",
",",
"gen",
")",
"\n",
"fieldTypes",
"=",
"append",
"(",
"fieldTypes",
",",
"rt",
".",
"Field",
"(",
"i",
")",
".",
"Type",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"buildStructType",
":=",
"reflect",
".",
"FuncOf",
"(",
"fieldTypes",
",",
"[",
"]",
"reflect",
".",
"Type",
"{",
"rt",
"}",
",",
"false",
")",
"\n",
"unbuildStructType",
":=",
"reflect",
".",
"FuncOf",
"(",
"[",
"]",
"reflect",
".",
"Type",
"{",
"rt",
"}",
",",
"fieldTypes",
",",
"false",
")",
"\n\n",
"buildStructFunc",
":=",
"reflect",
".",
"MakeFunc",
"(",
"buildStructType",
",",
"func",
"(",
"args",
"[",
"]",
"reflect",
".",
"Value",
")",
"[",
"]",
"reflect",
".",
"Value",
"{",
"result",
":=",
"reflect",
".",
"New",
"(",
"rt",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"rt",
".",
"NumField",
"(",
")",
";",
"i",
"++",
"{",
"if",
"_",
",",
"ok",
":=",
"gens",
"[",
"rt",
".",
"Field",
"(",
"i",
")",
".",
"Name",
"]",
";",
"!",
"ok",
"{",
"continue",
"\n",
"}",
"\n",
"result",
".",
"Elem",
"(",
")",
".",
"Field",
"(",
"i",
")",
".",
"Set",
"(",
"args",
"[",
"0",
"]",
")",
"\n",
"args",
"=",
"args",
"[",
"1",
":",
"]",
"\n",
"}",
"\n",
"return",
"[",
"]",
"reflect",
".",
"Value",
"{",
"result",
".",
"Elem",
"(",
")",
"}",
"\n",
"}",
")",
"\n",
"unbuildStructFunc",
":=",
"reflect",
".",
"MakeFunc",
"(",
"unbuildStructType",
",",
"func",
"(",
"args",
"[",
"]",
"reflect",
".",
"Value",
")",
"[",
"]",
"reflect",
".",
"Value",
"{",
"s",
":=",
"args",
"[",
"0",
"]",
"\n",
"results",
":=",
"[",
"]",
"reflect",
".",
"Value",
"{",
"}",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"s",
".",
"NumField",
"(",
")",
";",
"i",
"++",
"{",
"if",
"_",
",",
"ok",
":=",
"gens",
"[",
"rt",
".",
"Field",
"(",
"i",
")",
".",
"Name",
"]",
";",
"!",
"ok",
"{",
"continue",
"\n",
"}",
"\n",
"results",
"=",
"append",
"(",
"results",
",",
"s",
".",
"Field",
"(",
"i",
")",
")",
"\n",
"}",
"\n",
"return",
"results",
"\n",
"}",
")",
"\n\n",
"return",
"gopter",
".",
"DeriveGen",
"(",
"buildStructFunc",
".",
"Interface",
"(",
")",
",",
"unbuildStructFunc",
".",
"Interface",
"(",
")",
",",
"fieldGens",
"...",
",",
")",
"\n",
"}"
] |
// Struct generates a given struct type.
// rt has to be the reflect type of the struct, gens contains a map of field generators.
// Note that the result types of the generators in gen have to match the type of the correspoinding
// field in the struct. Also note that only public fields of a struct can be generated
|
[
"Struct",
"generates",
"a",
"given",
"struct",
"type",
".",
"rt",
"has",
"to",
"be",
"the",
"reflect",
"type",
"of",
"the",
"struct",
"gens",
"contains",
"a",
"map",
"of",
"field",
"generators",
".",
"Note",
"that",
"the",
"result",
"types",
"of",
"the",
"generators",
"in",
"gen",
"have",
"to",
"match",
"the",
"type",
"of",
"the",
"correspoinding",
"field",
"in",
"the",
"struct",
".",
"Also",
"note",
"that",
"only",
"public",
"fields",
"of",
"a",
"struct",
"can",
"be",
"generated"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen/struct.go#L13-L62
|
9,315 |
leanovate/gopter
|
gen/struct.go
|
StructPtr
|
func StructPtr(rt reflect.Type, gens map[string]gopter.Gen) gopter.Gen {
if rt.Kind() == reflect.Ptr {
rt = rt.Elem()
}
buildPtrType := reflect.FuncOf([]reflect.Type{rt}, []reflect.Type{reflect.PtrTo(rt)}, false)
unbuildPtrType := reflect.FuncOf([]reflect.Type{reflect.PtrTo(rt)}, []reflect.Type{rt}, false)
buildPtrFunc := reflect.MakeFunc(buildPtrType, func(args []reflect.Value) []reflect.Value {
sp := reflect.New(rt)
sp.Elem().Set(args[0])
return []reflect.Value{sp}
})
unbuildPtrFunc := reflect.MakeFunc(unbuildPtrType, func(args []reflect.Value) []reflect.Value {
return []reflect.Value{args[0].Elem()}
})
return gopter.DeriveGen(
buildPtrFunc.Interface(),
unbuildPtrFunc.Interface(),
Struct(rt, gens),
)
}
|
go
|
func StructPtr(rt reflect.Type, gens map[string]gopter.Gen) gopter.Gen {
if rt.Kind() == reflect.Ptr {
rt = rt.Elem()
}
buildPtrType := reflect.FuncOf([]reflect.Type{rt}, []reflect.Type{reflect.PtrTo(rt)}, false)
unbuildPtrType := reflect.FuncOf([]reflect.Type{reflect.PtrTo(rt)}, []reflect.Type{rt}, false)
buildPtrFunc := reflect.MakeFunc(buildPtrType, func(args []reflect.Value) []reflect.Value {
sp := reflect.New(rt)
sp.Elem().Set(args[0])
return []reflect.Value{sp}
})
unbuildPtrFunc := reflect.MakeFunc(unbuildPtrType, func(args []reflect.Value) []reflect.Value {
return []reflect.Value{args[0].Elem()}
})
return gopter.DeriveGen(
buildPtrFunc.Interface(),
unbuildPtrFunc.Interface(),
Struct(rt, gens),
)
}
|
[
"func",
"StructPtr",
"(",
"rt",
"reflect",
".",
"Type",
",",
"gens",
"map",
"[",
"string",
"]",
"gopter",
".",
"Gen",
")",
"gopter",
".",
"Gen",
"{",
"if",
"rt",
".",
"Kind",
"(",
")",
"==",
"reflect",
".",
"Ptr",
"{",
"rt",
"=",
"rt",
".",
"Elem",
"(",
")",
"\n",
"}",
"\n\n",
"buildPtrType",
":=",
"reflect",
".",
"FuncOf",
"(",
"[",
"]",
"reflect",
".",
"Type",
"{",
"rt",
"}",
",",
"[",
"]",
"reflect",
".",
"Type",
"{",
"reflect",
".",
"PtrTo",
"(",
"rt",
")",
"}",
",",
"false",
")",
"\n",
"unbuildPtrType",
":=",
"reflect",
".",
"FuncOf",
"(",
"[",
"]",
"reflect",
".",
"Type",
"{",
"reflect",
".",
"PtrTo",
"(",
"rt",
")",
"}",
",",
"[",
"]",
"reflect",
".",
"Type",
"{",
"rt",
"}",
",",
"false",
")",
"\n\n",
"buildPtrFunc",
":=",
"reflect",
".",
"MakeFunc",
"(",
"buildPtrType",
",",
"func",
"(",
"args",
"[",
"]",
"reflect",
".",
"Value",
")",
"[",
"]",
"reflect",
".",
"Value",
"{",
"sp",
":=",
"reflect",
".",
"New",
"(",
"rt",
")",
"\n",
"sp",
".",
"Elem",
"(",
")",
".",
"Set",
"(",
"args",
"[",
"0",
"]",
")",
"\n",
"return",
"[",
"]",
"reflect",
".",
"Value",
"{",
"sp",
"}",
"\n",
"}",
")",
"\n",
"unbuildPtrFunc",
":=",
"reflect",
".",
"MakeFunc",
"(",
"unbuildPtrType",
",",
"func",
"(",
"args",
"[",
"]",
"reflect",
".",
"Value",
")",
"[",
"]",
"reflect",
".",
"Value",
"{",
"return",
"[",
"]",
"reflect",
".",
"Value",
"{",
"args",
"[",
"0",
"]",
".",
"Elem",
"(",
")",
"}",
"\n",
"}",
")",
"\n\n",
"return",
"gopter",
".",
"DeriveGen",
"(",
"buildPtrFunc",
".",
"Interface",
"(",
")",
",",
"unbuildPtrFunc",
".",
"Interface",
"(",
")",
",",
"Struct",
"(",
"rt",
",",
"gens",
")",
",",
")",
"\n",
"}"
] |
// StructPtr generates pointers to a given struct type.
// Note that StructPtr does not generate nil, if you want to include nil in your
// testing you should combine gen.PtrOf with gen.Struct.
// rt has to be the reflect type of the struct, gens contains a map of field generators.
// Note that the result types of the generators in gen have to match the type of the correspoinding
// field in the struct. Also note that only public fields of a struct can be generated
|
[
"StructPtr",
"generates",
"pointers",
"to",
"a",
"given",
"struct",
"type",
".",
"Note",
"that",
"StructPtr",
"does",
"not",
"generate",
"nil",
"if",
"you",
"want",
"to",
"include",
"nil",
"in",
"your",
"testing",
"you",
"should",
"combine",
"gen",
".",
"PtrOf",
"with",
"gen",
".",
"Struct",
".",
"rt",
"has",
"to",
"be",
"the",
"reflect",
"type",
"of",
"the",
"struct",
"gens",
"contains",
"a",
"map",
"of",
"field",
"generators",
".",
"Note",
"that",
"the",
"result",
"types",
"of",
"the",
"generators",
"in",
"gen",
"have",
"to",
"match",
"the",
"type",
"of",
"the",
"correspoinding",
"field",
"in",
"the",
"struct",
".",
"Also",
"note",
"that",
"only",
"public",
"fields",
"of",
"a",
"struct",
"can",
"be",
"generated"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen/struct.go#L70-L92
|
9,316 |
leanovate/gopter
|
gen/map_shrink.go
|
MapShrinker
|
func MapShrinker(keyShrinker, elementShrinker gopter.Shrinker) gopter.Shrinker {
return func(v interface{}) gopter.Shrink {
rv := reflect.ValueOf(v)
if rv.Kind() != reflect.Map {
panic(fmt.Sprintf("%#v is not a Map", v))
}
keys := rv.MapKeys()
mapShrink := &mapShrink{
original: rv,
originalKeys: keys,
offset: 0,
length: rv.Len(),
chunkLength: rv.Len() >> 1,
}
shrinks := make([]gopter.Shrink, 0, rv.Len()+1)
shrinks = append(shrinks, mapShrink.Next)
for _, key := range keys {
mapShrinkOne := &mapShrinkOne{
original: rv,
key: key,
keyShrink: keyShrinker(key.Interface()),
lastKey: key.Interface(),
elementShrink: elementShrinker(rv.MapIndex(key).Interface()),
lastElement: rv.MapIndex(key).Interface(),
}
shrinks = append(shrinks, mapShrinkOne.Next)
}
return gopter.ConcatShrinks(shrinks...)
}
}
|
go
|
func MapShrinker(keyShrinker, elementShrinker gopter.Shrinker) gopter.Shrinker {
return func(v interface{}) gopter.Shrink {
rv := reflect.ValueOf(v)
if rv.Kind() != reflect.Map {
panic(fmt.Sprintf("%#v is not a Map", v))
}
keys := rv.MapKeys()
mapShrink := &mapShrink{
original: rv,
originalKeys: keys,
offset: 0,
length: rv.Len(),
chunkLength: rv.Len() >> 1,
}
shrinks := make([]gopter.Shrink, 0, rv.Len()+1)
shrinks = append(shrinks, mapShrink.Next)
for _, key := range keys {
mapShrinkOne := &mapShrinkOne{
original: rv,
key: key,
keyShrink: keyShrinker(key.Interface()),
lastKey: key.Interface(),
elementShrink: elementShrinker(rv.MapIndex(key).Interface()),
lastElement: rv.MapIndex(key).Interface(),
}
shrinks = append(shrinks, mapShrinkOne.Next)
}
return gopter.ConcatShrinks(shrinks...)
}
}
|
[
"func",
"MapShrinker",
"(",
"keyShrinker",
",",
"elementShrinker",
"gopter",
".",
"Shrinker",
")",
"gopter",
".",
"Shrinker",
"{",
"return",
"func",
"(",
"v",
"interface",
"{",
"}",
")",
"gopter",
".",
"Shrink",
"{",
"rv",
":=",
"reflect",
".",
"ValueOf",
"(",
"v",
")",
"\n",
"if",
"rv",
".",
"Kind",
"(",
")",
"!=",
"reflect",
".",
"Map",
"{",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"v",
")",
")",
"\n",
"}",
"\n",
"keys",
":=",
"rv",
".",
"MapKeys",
"(",
")",
"\n",
"mapShrink",
":=",
"&",
"mapShrink",
"{",
"original",
":",
"rv",
",",
"originalKeys",
":",
"keys",
",",
"offset",
":",
"0",
",",
"length",
":",
"rv",
".",
"Len",
"(",
")",
",",
"chunkLength",
":",
"rv",
".",
"Len",
"(",
")",
">>",
"1",
",",
"}",
"\n\n",
"shrinks",
":=",
"make",
"(",
"[",
"]",
"gopter",
".",
"Shrink",
",",
"0",
",",
"rv",
".",
"Len",
"(",
")",
"+",
"1",
")",
"\n",
"shrinks",
"=",
"append",
"(",
"shrinks",
",",
"mapShrink",
".",
"Next",
")",
"\n",
"for",
"_",
",",
"key",
":=",
"range",
"keys",
"{",
"mapShrinkOne",
":=",
"&",
"mapShrinkOne",
"{",
"original",
":",
"rv",
",",
"key",
":",
"key",
",",
"keyShrink",
":",
"keyShrinker",
"(",
"key",
".",
"Interface",
"(",
")",
")",
",",
"lastKey",
":",
"key",
".",
"Interface",
"(",
")",
",",
"elementShrink",
":",
"elementShrinker",
"(",
"rv",
".",
"MapIndex",
"(",
"key",
")",
".",
"Interface",
"(",
")",
")",
",",
"lastElement",
":",
"rv",
".",
"MapIndex",
"(",
"key",
")",
".",
"Interface",
"(",
")",
",",
"}",
"\n",
"shrinks",
"=",
"append",
"(",
"shrinks",
",",
"mapShrinkOne",
".",
"Next",
")",
"\n",
"}",
"\n",
"return",
"gopter",
".",
"ConcatShrinks",
"(",
"shrinks",
"...",
")",
"\n",
"}",
"\n",
"}"
] |
// MapShrinker creates a map shrinker from shrinker for the key values.
// The length of the map will be shrunk as well
|
[
"MapShrinker",
"creates",
"a",
"map",
"shrinker",
"from",
"shrinker",
"for",
"the",
"key",
"values",
".",
"The",
"length",
"of",
"the",
"map",
"will",
"be",
"shrunk",
"as",
"well"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen/map_shrink.go#L119-L149
|
9,317 |
leanovate/gopter
|
gen/regex.go
|
RegexMatch
|
func RegexMatch(regexStr string) gopter.Gen {
regexSyntax, err1 := syntax.Parse(regexStr, syntax.Perl)
regex, err2 := regexp.Compile(regexStr)
if err1 != nil || err2 != nil {
return Fail(reflect.TypeOf(""))
}
return regexMatchGen(regexSyntax.Simplify()).SuchThat(func(v string) bool {
return regex.MatchString(v)
}).WithShrinker(StringShrinker)
}
|
go
|
func RegexMatch(regexStr string) gopter.Gen {
regexSyntax, err1 := syntax.Parse(regexStr, syntax.Perl)
regex, err2 := regexp.Compile(regexStr)
if err1 != nil || err2 != nil {
return Fail(reflect.TypeOf(""))
}
return regexMatchGen(regexSyntax.Simplify()).SuchThat(func(v string) bool {
return regex.MatchString(v)
}).WithShrinker(StringShrinker)
}
|
[
"func",
"RegexMatch",
"(",
"regexStr",
"string",
")",
"gopter",
".",
"Gen",
"{",
"regexSyntax",
",",
"err1",
":=",
"syntax",
".",
"Parse",
"(",
"regexStr",
",",
"syntax",
".",
"Perl",
")",
"\n",
"regex",
",",
"err2",
":=",
"regexp",
".",
"Compile",
"(",
"regexStr",
")",
"\n",
"if",
"err1",
"!=",
"nil",
"||",
"err2",
"!=",
"nil",
"{",
"return",
"Fail",
"(",
"reflect",
".",
"TypeOf",
"(",
"\"",
"\"",
")",
")",
"\n",
"}",
"\n",
"return",
"regexMatchGen",
"(",
"regexSyntax",
".",
"Simplify",
"(",
")",
")",
".",
"SuchThat",
"(",
"func",
"(",
"v",
"string",
")",
"bool",
"{",
"return",
"regex",
".",
"MatchString",
"(",
"v",
")",
"\n",
"}",
")",
".",
"WithShrinker",
"(",
"StringShrinker",
")",
"\n",
"}"
] |
// RegexMatch generates matches for a given regular expression
// regexStr is supposed to conform to the perl regular expression syntax
|
[
"RegexMatch",
"generates",
"matches",
"for",
"a",
"given",
"regular",
"expression",
"regexStr",
"is",
"supposed",
"to",
"conform",
"to",
"the",
"perl",
"regular",
"expression",
"syntax"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen/regex.go#L14-L23
|
9,318 |
leanovate/gopter
|
gen/ptr_shrink.go
|
PtrShrinker
|
func PtrShrinker(elementShrinker gopter.Shrinker) gopter.Shrinker {
return func(v interface{}) gopter.Shrink {
if v == nil {
return gopter.NoShrink
}
elem := reflect.ValueOf(v).Elem()
if !elem.IsValid() || !elem.CanInterface() {
return gopter.NoShrink
}
rt := reflect.TypeOf(v)
elementShink := elementShrinker(reflect.ValueOf(v).Elem().Interface())
nilShrink := &nilShrink{}
return gopter.ConcatShrinks(
nilShrink.Next,
elementShink.Map(func(elem interface{}) interface{} {
slice := reflect.MakeSlice(reflect.SliceOf(rt.Elem()), 0, 1)
slice = reflect.Append(slice, reflect.ValueOf(elem))
return slice.Index(0).Addr().Interface()
}),
)
}
}
|
go
|
func PtrShrinker(elementShrinker gopter.Shrinker) gopter.Shrinker {
return func(v interface{}) gopter.Shrink {
if v == nil {
return gopter.NoShrink
}
elem := reflect.ValueOf(v).Elem()
if !elem.IsValid() || !elem.CanInterface() {
return gopter.NoShrink
}
rt := reflect.TypeOf(v)
elementShink := elementShrinker(reflect.ValueOf(v).Elem().Interface())
nilShrink := &nilShrink{}
return gopter.ConcatShrinks(
nilShrink.Next,
elementShink.Map(func(elem interface{}) interface{} {
slice := reflect.MakeSlice(reflect.SliceOf(rt.Elem()), 0, 1)
slice = reflect.Append(slice, reflect.ValueOf(elem))
return slice.Index(0).Addr().Interface()
}),
)
}
}
|
[
"func",
"PtrShrinker",
"(",
"elementShrinker",
"gopter",
".",
"Shrinker",
")",
"gopter",
".",
"Shrinker",
"{",
"return",
"func",
"(",
"v",
"interface",
"{",
"}",
")",
"gopter",
".",
"Shrink",
"{",
"if",
"v",
"==",
"nil",
"{",
"return",
"gopter",
".",
"NoShrink",
"\n",
"}",
"\n",
"elem",
":=",
"reflect",
".",
"ValueOf",
"(",
"v",
")",
".",
"Elem",
"(",
")",
"\n",
"if",
"!",
"elem",
".",
"IsValid",
"(",
")",
"||",
"!",
"elem",
".",
"CanInterface",
"(",
")",
"{",
"return",
"gopter",
".",
"NoShrink",
"\n",
"}",
"\n",
"rt",
":=",
"reflect",
".",
"TypeOf",
"(",
"v",
")",
"\n",
"elementShink",
":=",
"elementShrinker",
"(",
"reflect",
".",
"ValueOf",
"(",
"v",
")",
".",
"Elem",
"(",
")",
".",
"Interface",
"(",
")",
")",
"\n\n",
"nilShrink",
":=",
"&",
"nilShrink",
"{",
"}",
"\n",
"return",
"gopter",
".",
"ConcatShrinks",
"(",
"nilShrink",
".",
"Next",
",",
"elementShink",
".",
"Map",
"(",
"func",
"(",
"elem",
"interface",
"{",
"}",
")",
"interface",
"{",
"}",
"{",
"slice",
":=",
"reflect",
".",
"MakeSlice",
"(",
"reflect",
".",
"SliceOf",
"(",
"rt",
".",
"Elem",
"(",
")",
")",
",",
"0",
",",
"1",
")",
"\n",
"slice",
"=",
"reflect",
".",
"Append",
"(",
"slice",
",",
"reflect",
".",
"ValueOf",
"(",
"elem",
")",
")",
"\n\n",
"return",
"slice",
".",
"Index",
"(",
"0",
")",
".",
"Addr",
"(",
")",
".",
"Interface",
"(",
")",
"\n",
"}",
")",
",",
")",
"\n",
"}",
"\n",
"}"
] |
// PtrShrinker convert a value shrinker to a pointer to value shrinker
|
[
"PtrShrinker",
"convert",
"a",
"value",
"shrinker",
"to",
"a",
"pointer",
"to",
"value",
"shrinker"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen/ptr_shrink.go#L22-L45
|
9,319 |
leanovate/gopter
|
prop_result.go
|
NewPropResult
|
func NewPropResult(success bool, label string) *PropResult {
if success {
return &PropResult{
Status: PropTrue,
Labels: []string{label},
Args: make([]*PropArg, 0),
}
}
return &PropResult{
Status: PropFalse,
Labels: []string{label},
Args: make([]*PropArg, 0),
}
}
|
go
|
func NewPropResult(success bool, label string) *PropResult {
if success {
return &PropResult{
Status: PropTrue,
Labels: []string{label},
Args: make([]*PropArg, 0),
}
}
return &PropResult{
Status: PropFalse,
Labels: []string{label},
Args: make([]*PropArg, 0),
}
}
|
[
"func",
"NewPropResult",
"(",
"success",
"bool",
",",
"label",
"string",
")",
"*",
"PropResult",
"{",
"if",
"success",
"{",
"return",
"&",
"PropResult",
"{",
"Status",
":",
"PropTrue",
",",
"Labels",
":",
"[",
"]",
"string",
"{",
"label",
"}",
",",
"Args",
":",
"make",
"(",
"[",
"]",
"*",
"PropArg",
",",
"0",
")",
",",
"}",
"\n",
"}",
"\n",
"return",
"&",
"PropResult",
"{",
"Status",
":",
"PropFalse",
",",
"Labels",
":",
"[",
"]",
"string",
"{",
"label",
"}",
",",
"Args",
":",
"make",
"(",
"[",
"]",
"*",
"PropArg",
",",
"0",
")",
",",
"}",
"\n",
"}"
] |
// NewPropResult create a PropResult with label
|
[
"NewPropResult",
"create",
"a",
"PropResult",
"with",
"label"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/prop_result.go#L44-L57
|
9,320 |
leanovate/gopter
|
prop_result.go
|
Success
|
func (r *PropResult) Success() bool {
return r.Status == PropTrue || r.Status == PropProof
}
|
go
|
func (r *PropResult) Success() bool {
return r.Status == PropTrue || r.Status == PropProof
}
|
[
"func",
"(",
"r",
"*",
"PropResult",
")",
"Success",
"(",
")",
"bool",
"{",
"return",
"r",
".",
"Status",
"==",
"PropTrue",
"||",
"r",
".",
"Status",
"==",
"PropProof",
"\n",
"}"
] |
// Success checks if the result was successful
|
[
"Success",
"checks",
"if",
"the",
"result",
"was",
"successful"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/prop_result.go#L60-L62
|
9,321 |
leanovate/gopter
|
prop_result.go
|
WithArgs
|
func (r *PropResult) WithArgs(args []*PropArg) *PropResult {
r.Args = args
return r
}
|
go
|
func (r *PropResult) WithArgs(args []*PropArg) *PropResult {
r.Args = args
return r
}
|
[
"func",
"(",
"r",
"*",
"PropResult",
")",
"WithArgs",
"(",
"args",
"[",
"]",
"*",
"PropArg",
")",
"*",
"PropResult",
"{",
"r",
".",
"Args",
"=",
"args",
"\n",
"return",
"r",
"\n",
"}"
] |
// WithArgs sets argument descriptors to the PropResult for reporting
|
[
"WithArgs",
"sets",
"argument",
"descriptors",
"to",
"the",
"PropResult",
"for",
"reporting"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/prop_result.go#L65-L68
|
9,322 |
leanovate/gopter
|
prop_result.go
|
AddArgs
|
func (r *PropResult) AddArgs(args ...*PropArg) *PropResult {
r.Args = append(r.Args, args...)
return r
}
|
go
|
func (r *PropResult) AddArgs(args ...*PropArg) *PropResult {
r.Args = append(r.Args, args...)
return r
}
|
[
"func",
"(",
"r",
"*",
"PropResult",
")",
"AddArgs",
"(",
"args",
"...",
"*",
"PropArg",
")",
"*",
"PropResult",
"{",
"r",
".",
"Args",
"=",
"append",
"(",
"r",
".",
"Args",
",",
"args",
"...",
")",
"\n",
"return",
"r",
"\n",
"}"
] |
// AddArgs add argument descriptors to the PropResult for reporting
|
[
"AddArgs",
"add",
"argument",
"descriptors",
"to",
"the",
"PropResult",
"for",
"reporting"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/prop_result.go#L71-L74
|
9,323 |
leanovate/gopter
|
prop_result.go
|
And
|
func (r *PropResult) And(other *PropResult) *PropResult {
switch {
case r.Status == PropError:
return r
case other.Status == PropError:
return other
case r.Status == PropFalse:
return r
case other.Status == PropFalse:
return other
case r.Status == PropUndecided:
return r
case other.Status == PropUndecided:
return other
case r.Status == PropProof:
return r.mergeWith(other, other.Status)
case other.Status == PropProof:
return r.mergeWith(other, r.Status)
case r.Status == PropTrue && other.Status == PropTrue:
return r.mergeWith(other, PropTrue)
default:
return r
}
}
|
go
|
func (r *PropResult) And(other *PropResult) *PropResult {
switch {
case r.Status == PropError:
return r
case other.Status == PropError:
return other
case r.Status == PropFalse:
return r
case other.Status == PropFalse:
return other
case r.Status == PropUndecided:
return r
case other.Status == PropUndecided:
return other
case r.Status == PropProof:
return r.mergeWith(other, other.Status)
case other.Status == PropProof:
return r.mergeWith(other, r.Status)
case r.Status == PropTrue && other.Status == PropTrue:
return r.mergeWith(other, PropTrue)
default:
return r
}
}
|
[
"func",
"(",
"r",
"*",
"PropResult",
")",
"And",
"(",
"other",
"*",
"PropResult",
")",
"*",
"PropResult",
"{",
"switch",
"{",
"case",
"r",
".",
"Status",
"==",
"PropError",
":",
"return",
"r",
"\n",
"case",
"other",
".",
"Status",
"==",
"PropError",
":",
"return",
"other",
"\n",
"case",
"r",
".",
"Status",
"==",
"PropFalse",
":",
"return",
"r",
"\n",
"case",
"other",
".",
"Status",
"==",
"PropFalse",
":",
"return",
"other",
"\n",
"case",
"r",
".",
"Status",
"==",
"PropUndecided",
":",
"return",
"r",
"\n",
"case",
"other",
".",
"Status",
"==",
"PropUndecided",
":",
"return",
"other",
"\n",
"case",
"r",
".",
"Status",
"==",
"PropProof",
":",
"return",
"r",
".",
"mergeWith",
"(",
"other",
",",
"other",
".",
"Status",
")",
"\n",
"case",
"other",
".",
"Status",
"==",
"PropProof",
":",
"return",
"r",
".",
"mergeWith",
"(",
"other",
",",
"r",
".",
"Status",
")",
"\n",
"case",
"r",
".",
"Status",
"==",
"PropTrue",
"&&",
"other",
".",
"Status",
"==",
"PropTrue",
":",
"return",
"r",
".",
"mergeWith",
"(",
"other",
",",
"PropTrue",
")",
"\n",
"default",
":",
"return",
"r",
"\n",
"}",
"\n",
"}"
] |
// And combines two PropResult by an and operation.
// The resulting PropResult will be only true if both PropResults are true.
|
[
"And",
"combines",
"two",
"PropResult",
"by",
"an",
"and",
"operation",
".",
"The",
"resulting",
"PropResult",
"will",
"be",
"only",
"true",
"if",
"both",
"PropResults",
"are",
"true",
"."
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/prop_result.go#L78-L101
|
9,324 |
leanovate/gopter
|
locked_source.go
|
NewLockedSource
|
func NewLockedSource(seed int64) *lockedSource {
return &lockedSource{
src: rand.NewSource(seed).(rand.Source64),
}
}
|
go
|
func NewLockedSource(seed int64) *lockedSource {
return &lockedSource{
src: rand.NewSource(seed).(rand.Source64),
}
}
|
[
"func",
"NewLockedSource",
"(",
"seed",
"int64",
")",
"*",
"lockedSource",
"{",
"return",
"&",
"lockedSource",
"{",
"src",
":",
"rand",
".",
"NewSource",
"(",
"seed",
")",
".",
"(",
"rand",
".",
"Source64",
")",
",",
"}",
"\n",
"}"
] |
// NewLockedSource takes a seed and returns a new
// lockedSource for use with rand.New
|
[
"NewLockedSource",
"takes",
"a",
"seed",
"and",
"returns",
"a",
"new",
"lockedSource",
"for",
"use",
"with",
"rand",
".",
"New"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/locked_source.go#L20-L24
|
9,325 |
leanovate/gopter
|
locked_source.go
|
seedPos
|
func (r *lockedSource) seedPos(seed int64, readPos *int8) {
r.lk.Lock()
r.src.Seed(seed)
*readPos = 0
r.lk.Unlock()
}
|
go
|
func (r *lockedSource) seedPos(seed int64, readPos *int8) {
r.lk.Lock()
r.src.Seed(seed)
*readPos = 0
r.lk.Unlock()
}
|
[
"func",
"(",
"r",
"*",
"lockedSource",
")",
"seedPos",
"(",
"seed",
"int64",
",",
"readPos",
"*",
"int8",
")",
"{",
"r",
".",
"lk",
".",
"Lock",
"(",
")",
"\n",
"r",
".",
"src",
".",
"Seed",
"(",
"seed",
")",
"\n",
"*",
"readPos",
"=",
"0",
"\n",
"r",
".",
"lk",
".",
"Unlock",
"(",
")",
"\n",
"}"
] |
// seedPos implements Seed for a lockedSource without a race condition.
|
[
"seedPos",
"implements",
"Seed",
"for",
"a",
"lockedSource",
"without",
"a",
"race",
"condition",
"."
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/locked_source.go#L47-L52
|
9,326 |
leanovate/gopter
|
locked_source.go
|
read
|
func (r *lockedSource) read(p []byte, readVal *int64, readPos *int8) (n int, err error) {
r.lk.Lock()
n, err = read(p, r.src.Int63, readVal, readPos)
r.lk.Unlock()
return
}
|
go
|
func (r *lockedSource) read(p []byte, readVal *int64, readPos *int8) (n int, err error) {
r.lk.Lock()
n, err = read(p, r.src.Int63, readVal, readPos)
r.lk.Unlock()
return
}
|
[
"func",
"(",
"r",
"*",
"lockedSource",
")",
"read",
"(",
"p",
"[",
"]",
"byte",
",",
"readVal",
"*",
"int64",
",",
"readPos",
"*",
"int8",
")",
"(",
"n",
"int",
",",
"err",
"error",
")",
"{",
"r",
".",
"lk",
".",
"Lock",
"(",
")",
"\n",
"n",
",",
"err",
"=",
"read",
"(",
"p",
",",
"r",
".",
"src",
".",
"Int63",
",",
"readVal",
",",
"readPos",
")",
"\n",
"r",
".",
"lk",
".",
"Unlock",
"(",
")",
"\n",
"return",
"\n",
"}"
] |
// read implements Read for a lockedSource without a race condition.
|
[
"read",
"implements",
"Read",
"for",
"a",
"lockedSource",
"without",
"a",
"race",
"condition",
"."
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/locked_source.go#L55-L60
|
9,327 |
leanovate/gopter
|
prop_arg.go
|
NewPropArg
|
func NewPropArg(genResult *GenResult, shrinks int, value, origValue interface{}) *PropArg {
return &PropArg{
Label: strings.Join(genResult.Labels, ", "),
Arg: value,
OrigArg: origValue,
Shrinks: shrinks,
}
}
|
go
|
func NewPropArg(genResult *GenResult, shrinks int, value, origValue interface{}) *PropArg {
return &PropArg{
Label: strings.Join(genResult.Labels, ", "),
Arg: value,
OrigArg: origValue,
Shrinks: shrinks,
}
}
|
[
"func",
"NewPropArg",
"(",
"genResult",
"*",
"GenResult",
",",
"shrinks",
"int",
",",
"value",
",",
"origValue",
"interface",
"{",
"}",
")",
"*",
"PropArg",
"{",
"return",
"&",
"PropArg",
"{",
"Label",
":",
"strings",
".",
"Join",
"(",
"genResult",
".",
"Labels",
",",
"\"",
"\"",
")",
",",
"Arg",
":",
"value",
",",
"OrigArg",
":",
"origValue",
",",
"Shrinks",
":",
"shrinks",
",",
"}",
"\n",
"}"
] |
// NewPropArg creates a new PropArg.
|
[
"NewPropArg",
"creates",
"a",
"new",
"PropArg",
"."
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/prop_arg.go#L25-L32
|
9,328 |
leanovate/gopter
|
gen/slice_shrink.go
|
SliceShrinkerOne
|
func SliceShrinkerOne(elementShrinker gopter.Shrinker) gopter.Shrinker {
return func(v interface{}) gopter.Shrink {
rv := reflect.ValueOf(v)
if rv.Kind() != reflect.Slice {
panic(fmt.Sprintf("%#v is not a slice", v))
}
shrinks := make([]gopter.Shrink, 0, rv.Len())
for i := 0; i < rv.Len(); i++ {
sliceShrinkOne := &sliceShrinkOne{
original: rv,
index: i,
elementShrink: elementShrinker(rv.Index(i).Interface()),
}
shrinks = append(shrinks, sliceShrinkOne.Next)
}
return gopter.ConcatShrinks(shrinks...)
}
}
|
go
|
func SliceShrinkerOne(elementShrinker gopter.Shrinker) gopter.Shrinker {
return func(v interface{}) gopter.Shrink {
rv := reflect.ValueOf(v)
if rv.Kind() != reflect.Slice {
panic(fmt.Sprintf("%#v is not a slice", v))
}
shrinks := make([]gopter.Shrink, 0, rv.Len())
for i := 0; i < rv.Len(); i++ {
sliceShrinkOne := &sliceShrinkOne{
original: rv,
index: i,
elementShrink: elementShrinker(rv.Index(i).Interface()),
}
shrinks = append(shrinks, sliceShrinkOne.Next)
}
return gopter.ConcatShrinks(shrinks...)
}
}
|
[
"func",
"SliceShrinkerOne",
"(",
"elementShrinker",
"gopter",
".",
"Shrinker",
")",
"gopter",
".",
"Shrinker",
"{",
"return",
"func",
"(",
"v",
"interface",
"{",
"}",
")",
"gopter",
".",
"Shrink",
"{",
"rv",
":=",
"reflect",
".",
"ValueOf",
"(",
"v",
")",
"\n",
"if",
"rv",
".",
"Kind",
"(",
")",
"!=",
"reflect",
".",
"Slice",
"{",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"v",
")",
")",
"\n",
"}",
"\n\n",
"shrinks",
":=",
"make",
"(",
"[",
"]",
"gopter",
".",
"Shrink",
",",
"0",
",",
"rv",
".",
"Len",
"(",
")",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"rv",
".",
"Len",
"(",
")",
";",
"i",
"++",
"{",
"sliceShrinkOne",
":=",
"&",
"sliceShrinkOne",
"{",
"original",
":",
"rv",
",",
"index",
":",
"i",
",",
"elementShrink",
":",
"elementShrinker",
"(",
"rv",
".",
"Index",
"(",
"i",
")",
".",
"Interface",
"(",
")",
")",
",",
"}",
"\n",
"shrinks",
"=",
"append",
"(",
"shrinks",
",",
"sliceShrinkOne",
".",
"Next",
")",
"\n",
"}",
"\n",
"return",
"gopter",
".",
"ConcatShrinks",
"(",
"shrinks",
"...",
")",
"\n",
"}",
"\n",
"}"
] |
// SliceShrinkerOne creates a slice shrinker from a shrinker for the elements of the slice.
// The length of the slice will remains unchanged, instead each element is shrunk after the
// other.
|
[
"SliceShrinkerOne",
"creates",
"a",
"slice",
"shrinker",
"from",
"a",
"shrinker",
"for",
"the",
"elements",
"of",
"the",
"slice",
".",
"The",
"length",
"of",
"the",
"slice",
"will",
"remains",
"unchanged",
"instead",
"each",
"element",
"is",
"shrunk",
"after",
"the",
"other",
"."
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen/slice_shrink.go#L35-L53
|
9,329 |
leanovate/gopter
|
prop/forall_no_shrink.go
|
ForAllNoShrink1
|
func ForAllNoShrink1(gen gopter.Gen, check func(interface{}) (interface{}, error)) gopter.Prop {
return gopter.SaveProp(func(genParams *gopter.GenParameters) *gopter.PropResult {
genResult := gen(genParams)
value, ok := genResult.Retrieve()
if !ok {
return &gopter.PropResult{
Status: gopter.PropUndecided,
}
}
return convertResult(check(value)).AddArgs(gopter.NewPropArg(genResult, 0, value, value))
})
}
|
go
|
func ForAllNoShrink1(gen gopter.Gen, check func(interface{}) (interface{}, error)) gopter.Prop {
return gopter.SaveProp(func(genParams *gopter.GenParameters) *gopter.PropResult {
genResult := gen(genParams)
value, ok := genResult.Retrieve()
if !ok {
return &gopter.PropResult{
Status: gopter.PropUndecided,
}
}
return convertResult(check(value)).AddArgs(gopter.NewPropArg(genResult, 0, value, value))
})
}
|
[
"func",
"ForAllNoShrink1",
"(",
"gen",
"gopter",
".",
"Gen",
",",
"check",
"func",
"(",
"interface",
"{",
"}",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
")",
"gopter",
".",
"Prop",
"{",
"return",
"gopter",
".",
"SaveProp",
"(",
"func",
"(",
"genParams",
"*",
"gopter",
".",
"GenParameters",
")",
"*",
"gopter",
".",
"PropResult",
"{",
"genResult",
":=",
"gen",
"(",
"genParams",
")",
"\n",
"value",
",",
"ok",
":=",
"genResult",
".",
"Retrieve",
"(",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"&",
"gopter",
".",
"PropResult",
"{",
"Status",
":",
"gopter",
".",
"PropUndecided",
",",
"}",
"\n",
"}",
"\n",
"return",
"convertResult",
"(",
"check",
"(",
"value",
")",
")",
".",
"AddArgs",
"(",
"gopter",
".",
"NewPropArg",
"(",
"genResult",
",",
"0",
",",
"value",
",",
"value",
")",
")",
"\n",
"}",
")",
"\n",
"}"
] |
// ForAllNoShrink1 creates a property that requires the check condition to be true for all values
// As the name suggests the generated values will not be shrunk if the condition falsiies
|
[
"ForAllNoShrink1",
"creates",
"a",
"property",
"that",
"requires",
"the",
"check",
"condition",
"to",
"be",
"true",
"for",
"all",
"values",
"As",
"the",
"name",
"suggests",
"the",
"generated",
"values",
"will",
"not",
"be",
"shrunk",
"if",
"the",
"condition",
"falsiies"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/prop/forall_no_shrink.go#L48-L59
|
9,330 |
leanovate/gopter
|
commands/commands.go
|
GenCommand
|
func (p *ProtoCommands) GenCommand(state State) gopter.Gen {
if p.GenCommandFunc != nil {
return p.GenCommandFunc(state)
}
return gen.Fail(reflect.TypeOf((*Command)(nil)).Elem())
}
|
go
|
func (p *ProtoCommands) GenCommand(state State) gopter.Gen {
if p.GenCommandFunc != nil {
return p.GenCommandFunc(state)
}
return gen.Fail(reflect.TypeOf((*Command)(nil)).Elem())
}
|
[
"func",
"(",
"p",
"*",
"ProtoCommands",
")",
"GenCommand",
"(",
"state",
"State",
")",
"gopter",
".",
"Gen",
"{",
"if",
"p",
".",
"GenCommandFunc",
"!=",
"nil",
"{",
"return",
"p",
".",
"GenCommandFunc",
"(",
"state",
")",
"\n",
"}",
"\n",
"return",
"gen",
".",
"Fail",
"(",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"Command",
")",
"(",
"nil",
")",
")",
".",
"Elem",
"(",
")",
")",
"\n",
"}"
] |
// GenCommand provides a generator for applicable commands to for a state
|
[
"GenCommand",
"provides",
"a",
"generator",
"for",
"applicable",
"commands",
"to",
"for",
"a",
"state"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/commands/commands.go#L54-L59
|
9,331 |
leanovate/gopter
|
commands/commands.go
|
GenInitialState
|
func (p *ProtoCommands) GenInitialState() gopter.Gen {
return p.InitialStateGen.SuchThat(func(state State) bool {
return p.InitialPreCondition(state)
})
}
|
go
|
func (p *ProtoCommands) GenInitialState() gopter.Gen {
return p.InitialStateGen.SuchThat(func(state State) bool {
return p.InitialPreCondition(state)
})
}
|
[
"func",
"(",
"p",
"*",
"ProtoCommands",
")",
"GenInitialState",
"(",
")",
"gopter",
".",
"Gen",
"{",
"return",
"p",
".",
"InitialStateGen",
".",
"SuchThat",
"(",
"func",
"(",
"state",
"State",
")",
"bool",
"{",
"return",
"p",
".",
"InitialPreCondition",
"(",
"state",
")",
"\n",
"}",
")",
"\n",
"}"
] |
// GenInitialState provides a generator for the initial State
|
[
"GenInitialState",
"provides",
"a",
"generator",
"for",
"the",
"initial",
"State"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/commands/commands.go#L62-L66
|
9,332 |
leanovate/gopter
|
commands/commands.go
|
InitialPreCondition
|
func (p *ProtoCommands) InitialPreCondition(state State) bool {
if p.InitialPreConditionFunc != nil {
return p.InitialPreConditionFunc(state)
}
return true
}
|
go
|
func (p *ProtoCommands) InitialPreCondition(state State) bool {
if p.InitialPreConditionFunc != nil {
return p.InitialPreConditionFunc(state)
}
return true
}
|
[
"func",
"(",
"p",
"*",
"ProtoCommands",
")",
"InitialPreCondition",
"(",
"state",
"State",
")",
"bool",
"{",
"if",
"p",
".",
"InitialPreConditionFunc",
"!=",
"nil",
"{",
"return",
"p",
".",
"InitialPreConditionFunc",
"(",
"state",
")",
"\n",
"}",
"\n",
"return",
"true",
"\n",
"}"
] |
// InitialPreCondition checks if the initial state is valid
|
[
"InitialPreCondition",
"checks",
"if",
"the",
"initial",
"state",
"is",
"valid"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/commands/commands.go#L69-L74
|
9,333 |
leanovate/gopter
|
commands/commands.go
|
Prop
|
func Prop(commands Commands) gopter.Prop {
return prop.ForAll(func(actions *actions) (*gopter.PropResult, error) {
systemUnderTest := commands.NewSystemUnderTest(actions.initialStateProvider())
defer commands.DestroySystemUnderTest(systemUnderTest)
return actions.run(systemUnderTest)
}, genActions(commands))
}
|
go
|
func Prop(commands Commands) gopter.Prop {
return prop.ForAll(func(actions *actions) (*gopter.PropResult, error) {
systemUnderTest := commands.NewSystemUnderTest(actions.initialStateProvider())
defer commands.DestroySystemUnderTest(systemUnderTest)
return actions.run(systemUnderTest)
}, genActions(commands))
}
|
[
"func",
"Prop",
"(",
"commands",
"Commands",
")",
"gopter",
".",
"Prop",
"{",
"return",
"prop",
".",
"ForAll",
"(",
"func",
"(",
"actions",
"*",
"actions",
")",
"(",
"*",
"gopter",
".",
"PropResult",
",",
"error",
")",
"{",
"systemUnderTest",
":=",
"commands",
".",
"NewSystemUnderTest",
"(",
"actions",
".",
"initialStateProvider",
"(",
")",
")",
"\n",
"defer",
"commands",
".",
"DestroySystemUnderTest",
"(",
"systemUnderTest",
")",
"\n\n",
"return",
"actions",
".",
"run",
"(",
"systemUnderTest",
")",
"\n",
"}",
",",
"genActions",
"(",
"commands",
")",
")",
"\n",
"}"
] |
// Prop creates a gopter.Prop from Commands
|
[
"Prop",
"creates",
"a",
"gopter",
".",
"Prop",
"from",
"Commands"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/commands/commands.go#L77-L84
|
9,334 |
leanovate/gopter
|
arbitrary/arbitraries.go
|
DefaultArbitraries
|
func DefaultArbitraries() *Arbitraries {
return &Arbitraries{
generators: map[reflect.Type]gopter.Gen{
reflect.TypeOf(time.Now()): gen.Time(),
},
}
}
|
go
|
func DefaultArbitraries() *Arbitraries {
return &Arbitraries{
generators: map[reflect.Type]gopter.Gen{
reflect.TypeOf(time.Now()): gen.Time(),
},
}
}
|
[
"func",
"DefaultArbitraries",
"(",
")",
"*",
"Arbitraries",
"{",
"return",
"&",
"Arbitraries",
"{",
"generators",
":",
"map",
"[",
"reflect",
".",
"Type",
"]",
"gopter",
".",
"Gen",
"{",
"reflect",
".",
"TypeOf",
"(",
"time",
".",
"Now",
"(",
")",
")",
":",
"gen",
".",
"Time",
"(",
")",
",",
"}",
",",
"}",
"\n",
"}"
] |
// DefaultArbitraries creates a default arbitrary context with the widest
// possible ranges for all types.
|
[
"DefaultArbitraries",
"creates",
"a",
"default",
"arbitrary",
"context",
"with",
"the",
"widest",
"possible",
"ranges",
"for",
"all",
"types",
"."
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/arbitrary/arbitraries.go#L20-L26
|
9,335 |
leanovate/gopter
|
arbitrary/arbitraries.go
|
GenForType
|
func (a *Arbitraries) GenForType(rt reflect.Type) gopter.Gen {
if gen, ok := a.generators[rt]; ok {
return gen
}
return a.genForKind(rt)
}
|
go
|
func (a *Arbitraries) GenForType(rt reflect.Type) gopter.Gen {
if gen, ok := a.generators[rt]; ok {
return gen
}
return a.genForKind(rt)
}
|
[
"func",
"(",
"a",
"*",
"Arbitraries",
")",
"GenForType",
"(",
"rt",
"reflect",
".",
"Type",
")",
"gopter",
".",
"Gen",
"{",
"if",
"gen",
",",
"ok",
":=",
"a",
".",
"generators",
"[",
"rt",
"]",
";",
"ok",
"{",
"return",
"gen",
"\n",
"}",
"\n",
"return",
"a",
".",
"genForKind",
"(",
"rt",
")",
"\n",
"}"
] |
// GenForType gets a generator for a generator for a type
|
[
"GenForType",
"gets",
"a",
"generator",
"for",
"a",
"generator",
"for",
"a",
"type"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/arbitrary/arbitraries.go#L29-L34
|
9,336 |
leanovate/gopter
|
arbitrary/arbitraries.go
|
RegisterGen
|
func (a *Arbitraries) RegisterGen(gen gopter.Gen) {
result := gen(gopter.MinGenParams)
rt := result.ResultType
a.generators[rt] = gen
}
|
go
|
func (a *Arbitraries) RegisterGen(gen gopter.Gen) {
result := gen(gopter.MinGenParams)
rt := result.ResultType
a.generators[rt] = gen
}
|
[
"func",
"(",
"a",
"*",
"Arbitraries",
")",
"RegisterGen",
"(",
"gen",
"gopter",
".",
"Gen",
")",
"{",
"result",
":=",
"gen",
"(",
"gopter",
".",
"MinGenParams",
")",
"\n",
"rt",
":=",
"result",
".",
"ResultType",
"\n",
"a",
".",
"generators",
"[",
"rt",
"]",
"=",
"gen",
"\n",
"}"
] |
// RegisterGen registers a generator
|
[
"RegisterGen",
"registers",
"a",
"generator"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/arbitrary/arbitraries.go#L37-L41
|
9,337 |
leanovate/gopter
|
gen/complex.go
|
Complex128
|
func Complex128() gopter.Gen {
return gopter.CombineGens(
Float64(),
Float64(),
).Map(func(values []interface{}) complex128 {
return complex(values[0].(float64), values[1].(float64))
}).WithShrinker(Complex128Shrinker)
}
|
go
|
func Complex128() gopter.Gen {
return gopter.CombineGens(
Float64(),
Float64(),
).Map(func(values []interface{}) complex128 {
return complex(values[0].(float64), values[1].(float64))
}).WithShrinker(Complex128Shrinker)
}
|
[
"func",
"Complex128",
"(",
")",
"gopter",
".",
"Gen",
"{",
"return",
"gopter",
".",
"CombineGens",
"(",
"Float64",
"(",
")",
",",
"Float64",
"(",
")",
",",
")",
".",
"Map",
"(",
"func",
"(",
"values",
"[",
"]",
"interface",
"{",
"}",
")",
"complex128",
"{",
"return",
"complex",
"(",
"values",
"[",
"0",
"]",
".",
"(",
"float64",
")",
",",
"values",
"[",
"1",
"]",
".",
"(",
"float64",
")",
")",
"\n",
"}",
")",
".",
"WithShrinker",
"(",
"Complex128Shrinker",
")",
"\n",
"}"
] |
// Complex128 generate arbitrary complex128 numbers
|
[
"Complex128",
"generate",
"arbitrary",
"complex128",
"numbers"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen/complex.go#L19-L26
|
9,338 |
leanovate/gopter
|
gen/complex.go
|
Complex64
|
func Complex64() gopter.Gen {
return gopter.CombineGens(
Float32(),
Float32(),
).Map(func(values []interface{}) complex64 {
return complex(values[0].(float32), values[1].(float32))
}).WithShrinker(Complex64Shrinker)
}
|
go
|
func Complex64() gopter.Gen {
return gopter.CombineGens(
Float32(),
Float32(),
).Map(func(values []interface{}) complex64 {
return complex(values[0].(float32), values[1].(float32))
}).WithShrinker(Complex64Shrinker)
}
|
[
"func",
"Complex64",
"(",
")",
"gopter",
".",
"Gen",
"{",
"return",
"gopter",
".",
"CombineGens",
"(",
"Float32",
"(",
")",
",",
"Float32",
"(",
")",
",",
")",
".",
"Map",
"(",
"func",
"(",
"values",
"[",
"]",
"interface",
"{",
"}",
")",
"complex64",
"{",
"return",
"complex",
"(",
"values",
"[",
"0",
"]",
".",
"(",
"float32",
")",
",",
"values",
"[",
"1",
"]",
".",
"(",
"float32",
")",
")",
"\n",
"}",
")",
".",
"WithShrinker",
"(",
"Complex64Shrinker",
")",
"\n",
"}"
] |
// Complex64 generate arbitrary complex64 numbers
|
[
"Complex64",
"generate",
"arbitrary",
"complex64",
"numbers"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen/complex.go#L42-L49
|
9,339 |
leanovate/gopter
|
gen/sized.go
|
Sized
|
func Sized(f func(int) gopter.Gen) gopter.Gen {
return func(params *gopter.GenParameters) *gopter.GenResult {
var size int
if params.MaxSize == params.MinSize {
size = params.MaxSize
} else {
size = params.Rng.Intn(params.MaxSize-params.MinSize) + params.MinSize
}
return f(size)(params)
}
}
|
go
|
func Sized(f func(int) gopter.Gen) gopter.Gen {
return func(params *gopter.GenParameters) *gopter.GenResult {
var size int
if params.MaxSize == params.MinSize {
size = params.MaxSize
} else {
size = params.Rng.Intn(params.MaxSize-params.MinSize) + params.MinSize
}
return f(size)(params)
}
}
|
[
"func",
"Sized",
"(",
"f",
"func",
"(",
"int",
")",
"gopter",
".",
"Gen",
")",
"gopter",
".",
"Gen",
"{",
"return",
"func",
"(",
"params",
"*",
"gopter",
".",
"GenParameters",
")",
"*",
"gopter",
".",
"GenResult",
"{",
"var",
"size",
"int",
"\n",
"if",
"params",
".",
"MaxSize",
"==",
"params",
".",
"MinSize",
"{",
"size",
"=",
"params",
".",
"MaxSize",
"\n",
"}",
"else",
"{",
"size",
"=",
"params",
".",
"Rng",
".",
"Intn",
"(",
"params",
".",
"MaxSize",
"-",
"params",
".",
"MinSize",
")",
"+",
"params",
".",
"MinSize",
"\n",
"}",
"\n",
"return",
"f",
"(",
"size",
")",
"(",
"params",
")",
"\n",
"}",
"\n",
"}"
] |
// Sized derives a generator from based on size
// This honors the `MinSize` and `MaxSize` of the `GenParameters` of the test suite.
// Keep an eye on memory consumption, by default MaxSize is 100.
|
[
"Sized",
"derives",
"a",
"generator",
"from",
"based",
"on",
"size",
"This",
"honors",
"the",
"MinSize",
"and",
"MaxSize",
"of",
"the",
"GenParameters",
"of",
"the",
"test",
"suite",
".",
"Keep",
"an",
"eye",
"on",
"memory",
"consumption",
"by",
"default",
"MaxSize",
"is",
"100",
"."
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen/sized.go#L10-L20
|
9,340 |
leanovate/gopter
|
gen_result.go
|
Retrieve
|
func (r *GenResult) Retrieve() (interface{}, bool) {
if (r.Sieve == nil && r.Result != nil) || (r.Sieve != nil && r.Sieve(r.Result)) {
return r.Result, true
}
return nil, false
}
|
go
|
func (r *GenResult) Retrieve() (interface{}, bool) {
if (r.Sieve == nil && r.Result != nil) || (r.Sieve != nil && r.Sieve(r.Result)) {
return r.Result, true
}
return nil, false
}
|
[
"func",
"(",
"r",
"*",
"GenResult",
")",
"Retrieve",
"(",
")",
"(",
"interface",
"{",
"}",
",",
"bool",
")",
"{",
"if",
"(",
"r",
".",
"Sieve",
"==",
"nil",
"&&",
"r",
".",
"Result",
"!=",
"nil",
")",
"||",
"(",
"r",
".",
"Sieve",
"!=",
"nil",
"&&",
"r",
".",
"Sieve",
"(",
"r",
".",
"Result",
")",
")",
"{",
"return",
"r",
".",
"Result",
",",
"true",
"\n",
"}",
"\n",
"return",
"nil",
",",
"false",
"\n",
"}"
] |
// Retrieve gets the concrete generator result.
// If the result is invalid or does not pass the sieve there is no concrete
// value and the property using the generator should be undecided.
|
[
"Retrieve",
"gets",
"the",
"concrete",
"generator",
"result",
".",
"If",
"the",
"result",
"is",
"invalid",
"or",
"does",
"not",
"pass",
"the",
"sieve",
"there",
"is",
"no",
"concrete",
"value",
"and",
"the",
"property",
"using",
"the",
"generator",
"should",
"be",
"undecided",
"."
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen_result.go#L38-L43
|
9,341 |
leanovate/gopter
|
gen_result.go
|
RetrieveAsValue
|
func (r *GenResult) RetrieveAsValue() (reflect.Value, bool) {
if r.Result != nil && (r.Sieve == nil || r.Sieve(r.Result)) {
return reflect.ValueOf(r.Result), true
} else if r.Result == nil && r.Sieve != nil && r.Sieve(r.Result) {
return reflect.Zero(r.ResultType), true
}
return reflect.Zero(r.ResultType), false
}
|
go
|
func (r *GenResult) RetrieveAsValue() (reflect.Value, bool) {
if r.Result != nil && (r.Sieve == nil || r.Sieve(r.Result)) {
return reflect.ValueOf(r.Result), true
} else if r.Result == nil && r.Sieve != nil && r.Sieve(r.Result) {
return reflect.Zero(r.ResultType), true
}
return reflect.Zero(r.ResultType), false
}
|
[
"func",
"(",
"r",
"*",
"GenResult",
")",
"RetrieveAsValue",
"(",
")",
"(",
"reflect",
".",
"Value",
",",
"bool",
")",
"{",
"if",
"r",
".",
"Result",
"!=",
"nil",
"&&",
"(",
"r",
".",
"Sieve",
"==",
"nil",
"||",
"r",
".",
"Sieve",
"(",
"r",
".",
"Result",
")",
")",
"{",
"return",
"reflect",
".",
"ValueOf",
"(",
"r",
".",
"Result",
")",
",",
"true",
"\n",
"}",
"else",
"if",
"r",
".",
"Result",
"==",
"nil",
"&&",
"r",
".",
"Sieve",
"!=",
"nil",
"&&",
"r",
".",
"Sieve",
"(",
"r",
".",
"Result",
")",
"{",
"return",
"reflect",
".",
"Zero",
"(",
"r",
".",
"ResultType",
")",
",",
"true",
"\n",
"}",
"\n",
"return",
"reflect",
".",
"Zero",
"(",
"r",
".",
"ResultType",
")",
",",
"false",
"\n",
"}"
] |
// RetrieveAsValue get the concrete generator result as reflect value.
// If the result is invalid or does not pass the sieve there is no concrete
// value and the property using the generator should be undecided.
|
[
"RetrieveAsValue",
"get",
"the",
"concrete",
"generator",
"result",
"as",
"reflect",
"value",
".",
"If",
"the",
"result",
"is",
"invalid",
"or",
"does",
"not",
"pass",
"the",
"sieve",
"there",
"is",
"no",
"concrete",
"value",
"and",
"the",
"property",
"using",
"the",
"generator",
"should",
"be",
"undecided",
"."
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen_result.go#L48-L55
|
9,342 |
leanovate/gopter
|
gen/integers.go
|
Int64Range
|
func Int64Range(min, max int64) gopter.Gen {
if max < min {
return Fail(reflect.TypeOf(int64(0)))
}
if max == math.MaxInt64 && min == math.MinInt64 { // Check for range overflow
return func(genParams *gopter.GenParameters) *gopter.GenResult {
return gopter.NewGenResult(genParams.NextInt64(), Int64Shrinker)
}
}
rangeSize := uint64(max - min + 1)
return func(genParams *gopter.GenParameters) *gopter.GenResult {
var nextResult = uint64(min) + (genParams.NextUint64() % rangeSize)
genResult := gopter.NewGenResult(int64(nextResult), Int64Shrinker)
genResult.Sieve = func(v interface{}) bool {
return v.(int64) >= min && v.(int64) <= max
}
return genResult
}
}
|
go
|
func Int64Range(min, max int64) gopter.Gen {
if max < min {
return Fail(reflect.TypeOf(int64(0)))
}
if max == math.MaxInt64 && min == math.MinInt64 { // Check for range overflow
return func(genParams *gopter.GenParameters) *gopter.GenResult {
return gopter.NewGenResult(genParams.NextInt64(), Int64Shrinker)
}
}
rangeSize := uint64(max - min + 1)
return func(genParams *gopter.GenParameters) *gopter.GenResult {
var nextResult = uint64(min) + (genParams.NextUint64() % rangeSize)
genResult := gopter.NewGenResult(int64(nextResult), Int64Shrinker)
genResult.Sieve = func(v interface{}) bool {
return v.(int64) >= min && v.(int64) <= max
}
return genResult
}
}
|
[
"func",
"Int64Range",
"(",
"min",
",",
"max",
"int64",
")",
"gopter",
".",
"Gen",
"{",
"if",
"max",
"<",
"min",
"{",
"return",
"Fail",
"(",
"reflect",
".",
"TypeOf",
"(",
"int64",
"(",
"0",
")",
")",
")",
"\n",
"}",
"\n",
"if",
"max",
"==",
"math",
".",
"MaxInt64",
"&&",
"min",
"==",
"math",
".",
"MinInt64",
"{",
"// Check for range overflow",
"return",
"func",
"(",
"genParams",
"*",
"gopter",
".",
"GenParameters",
")",
"*",
"gopter",
".",
"GenResult",
"{",
"return",
"gopter",
".",
"NewGenResult",
"(",
"genParams",
".",
"NextInt64",
"(",
")",
",",
"Int64Shrinker",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"rangeSize",
":=",
"uint64",
"(",
"max",
"-",
"min",
"+",
"1",
")",
"\n",
"return",
"func",
"(",
"genParams",
"*",
"gopter",
".",
"GenParameters",
")",
"*",
"gopter",
".",
"GenResult",
"{",
"var",
"nextResult",
"=",
"uint64",
"(",
"min",
")",
"+",
"(",
"genParams",
".",
"NextUint64",
"(",
")",
"%",
"rangeSize",
")",
"\n",
"genResult",
":=",
"gopter",
".",
"NewGenResult",
"(",
"int64",
"(",
"nextResult",
")",
",",
"Int64Shrinker",
")",
"\n",
"genResult",
".",
"Sieve",
"=",
"func",
"(",
"v",
"interface",
"{",
"}",
")",
"bool",
"{",
"return",
"v",
".",
"(",
"int64",
")",
">=",
"min",
"&&",
"v",
".",
"(",
"int64",
")",
"<=",
"max",
"\n",
"}",
"\n",
"return",
"genResult",
"\n",
"}",
"\n",
"}"
] |
// Int64Range generates int64 numbers within a given range
|
[
"Int64Range",
"generates",
"int64",
"numbers",
"within",
"a",
"given",
"range"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen/integers.go#L11-L30
|
9,343 |
leanovate/gopter
|
gen/integers.go
|
UInt64Range
|
func UInt64Range(min, max uint64) gopter.Gen {
if max < min {
return Fail(reflect.TypeOf(uint64(0)))
}
d := max - min + 1
if d == 0 { // Check overflow (i.e. max = MaxInt64, min = MinInt64)
return func(genParams *gopter.GenParameters) *gopter.GenResult {
return gopter.NewGenResult(genParams.NextUint64(), UInt64Shrinker)
}
}
return func(genParams *gopter.GenParameters) *gopter.GenResult {
genResult := gopter.NewGenResult(min+genParams.NextUint64()%d, UInt64Shrinker)
genResult.Sieve = func(v interface{}) bool {
return v.(uint64) >= min && v.(uint64) <= max
}
return genResult
}
}
|
go
|
func UInt64Range(min, max uint64) gopter.Gen {
if max < min {
return Fail(reflect.TypeOf(uint64(0)))
}
d := max - min + 1
if d == 0 { // Check overflow (i.e. max = MaxInt64, min = MinInt64)
return func(genParams *gopter.GenParameters) *gopter.GenResult {
return gopter.NewGenResult(genParams.NextUint64(), UInt64Shrinker)
}
}
return func(genParams *gopter.GenParameters) *gopter.GenResult {
genResult := gopter.NewGenResult(min+genParams.NextUint64()%d, UInt64Shrinker)
genResult.Sieve = func(v interface{}) bool {
return v.(uint64) >= min && v.(uint64) <= max
}
return genResult
}
}
|
[
"func",
"UInt64Range",
"(",
"min",
",",
"max",
"uint64",
")",
"gopter",
".",
"Gen",
"{",
"if",
"max",
"<",
"min",
"{",
"return",
"Fail",
"(",
"reflect",
".",
"TypeOf",
"(",
"uint64",
"(",
"0",
")",
")",
")",
"\n",
"}",
"\n",
"d",
":=",
"max",
"-",
"min",
"+",
"1",
"\n",
"if",
"d",
"==",
"0",
"{",
"// Check overflow (i.e. max = MaxInt64, min = MinInt64)",
"return",
"func",
"(",
"genParams",
"*",
"gopter",
".",
"GenParameters",
")",
"*",
"gopter",
".",
"GenResult",
"{",
"return",
"gopter",
".",
"NewGenResult",
"(",
"genParams",
".",
"NextUint64",
"(",
")",
",",
"UInt64Shrinker",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"func",
"(",
"genParams",
"*",
"gopter",
".",
"GenParameters",
")",
"*",
"gopter",
".",
"GenResult",
"{",
"genResult",
":=",
"gopter",
".",
"NewGenResult",
"(",
"min",
"+",
"genParams",
".",
"NextUint64",
"(",
")",
"%",
"d",
",",
"UInt64Shrinker",
")",
"\n",
"genResult",
".",
"Sieve",
"=",
"func",
"(",
"v",
"interface",
"{",
"}",
")",
"bool",
"{",
"return",
"v",
".",
"(",
"uint64",
")",
">=",
"min",
"&&",
"v",
".",
"(",
"uint64",
")",
"<=",
"max",
"\n",
"}",
"\n",
"return",
"genResult",
"\n",
"}",
"\n",
"}"
] |
// UInt64Range generates uint64 numbers within a given range
|
[
"UInt64Range",
"generates",
"uint64",
"numbers",
"within",
"a",
"given",
"range"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen/integers.go#L33-L50
|
9,344 |
leanovate/gopter
|
gen/integers.go
|
Int32Range
|
func Int32Range(min, max int32) gopter.Gen {
return Int64Range(int64(min), int64(max)).
Map(int64To32).
WithShrinker(Int32Shrinker).
SuchThat(func(v int32) bool {
return v >= min && v <= max
})
}
|
go
|
func Int32Range(min, max int32) gopter.Gen {
return Int64Range(int64(min), int64(max)).
Map(int64To32).
WithShrinker(Int32Shrinker).
SuchThat(func(v int32) bool {
return v >= min && v <= max
})
}
|
[
"func",
"Int32Range",
"(",
"min",
",",
"max",
"int32",
")",
"gopter",
".",
"Gen",
"{",
"return",
"Int64Range",
"(",
"int64",
"(",
"min",
")",
",",
"int64",
"(",
"max",
")",
")",
".",
"Map",
"(",
"int64To32",
")",
".",
"WithShrinker",
"(",
"Int32Shrinker",
")",
".",
"SuchThat",
"(",
"func",
"(",
"v",
"int32",
")",
"bool",
"{",
"return",
"v",
">=",
"min",
"&&",
"v",
"<=",
"max",
"\n",
"}",
")",
"\n",
"}"
] |
// Int32Range generates int32 numbers within a given range
|
[
"Int32Range",
"generates",
"int32",
"numbers",
"within",
"a",
"given",
"range"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen/integers.go#L63-L70
|
9,345 |
leanovate/gopter
|
gen/integers.go
|
UInt32Range
|
func UInt32Range(min, max uint32) gopter.Gen {
return UInt64Range(uint64(min), uint64(max)).
Map(uint64To32).
WithShrinker(UInt32Shrinker).
SuchThat(func(v uint32) bool {
return v >= min && v <= max
})
}
|
go
|
func UInt32Range(min, max uint32) gopter.Gen {
return UInt64Range(uint64(min), uint64(max)).
Map(uint64To32).
WithShrinker(UInt32Shrinker).
SuchThat(func(v uint32) bool {
return v >= min && v <= max
})
}
|
[
"func",
"UInt32Range",
"(",
"min",
",",
"max",
"uint32",
")",
"gopter",
".",
"Gen",
"{",
"return",
"UInt64Range",
"(",
"uint64",
"(",
"min",
")",
",",
"uint64",
"(",
"max",
")",
")",
".",
"Map",
"(",
"uint64To32",
")",
".",
"WithShrinker",
"(",
"UInt32Shrinker",
")",
".",
"SuchThat",
"(",
"func",
"(",
"v",
"uint32",
")",
"bool",
"{",
"return",
"v",
">=",
"min",
"&&",
"v",
"<=",
"max",
"\n",
"}",
")",
"\n",
"}"
] |
// UInt32Range generates uint32 numbers within a given range
|
[
"UInt32Range",
"generates",
"uint32",
"numbers",
"within",
"a",
"given",
"range"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen/integers.go#L73-L80
|
9,346 |
leanovate/gopter
|
gen/integers.go
|
Int16Range
|
func Int16Range(min, max int16) gopter.Gen {
return Int64Range(int64(min), int64(max)).
Map(int64To16).
WithShrinker(Int16Shrinker).
SuchThat(func(v int16) bool {
return v >= min && v <= max
})
}
|
go
|
func Int16Range(min, max int16) gopter.Gen {
return Int64Range(int64(min), int64(max)).
Map(int64To16).
WithShrinker(Int16Shrinker).
SuchThat(func(v int16) bool {
return v >= min && v <= max
})
}
|
[
"func",
"Int16Range",
"(",
"min",
",",
"max",
"int16",
")",
"gopter",
".",
"Gen",
"{",
"return",
"Int64Range",
"(",
"int64",
"(",
"min",
")",
",",
"int64",
"(",
"max",
")",
")",
".",
"Map",
"(",
"int64To16",
")",
".",
"WithShrinker",
"(",
"Int16Shrinker",
")",
".",
"SuchThat",
"(",
"func",
"(",
"v",
"int16",
")",
"bool",
"{",
"return",
"v",
">=",
"min",
"&&",
"v",
"<=",
"max",
"\n",
"}",
")",
"\n",
"}"
] |
// Int16Range generates int16 numbers within a given range
|
[
"Int16Range",
"generates",
"int16",
"numbers",
"within",
"a",
"given",
"range"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen/integers.go#L93-L100
|
9,347 |
leanovate/gopter
|
gen/integers.go
|
UInt16Range
|
func UInt16Range(min, max uint16) gopter.Gen {
return UInt64Range(uint64(min), uint64(max)).
Map(uint64To16).
WithShrinker(UInt16Shrinker).
SuchThat(func(v uint16) bool {
return v >= min && v <= max
})
}
|
go
|
func UInt16Range(min, max uint16) gopter.Gen {
return UInt64Range(uint64(min), uint64(max)).
Map(uint64To16).
WithShrinker(UInt16Shrinker).
SuchThat(func(v uint16) bool {
return v >= min && v <= max
})
}
|
[
"func",
"UInt16Range",
"(",
"min",
",",
"max",
"uint16",
")",
"gopter",
".",
"Gen",
"{",
"return",
"UInt64Range",
"(",
"uint64",
"(",
"min",
")",
",",
"uint64",
"(",
"max",
")",
")",
".",
"Map",
"(",
"uint64To16",
")",
".",
"WithShrinker",
"(",
"UInt16Shrinker",
")",
".",
"SuchThat",
"(",
"func",
"(",
"v",
"uint16",
")",
"bool",
"{",
"return",
"v",
">=",
"min",
"&&",
"v",
"<=",
"max",
"\n",
"}",
")",
"\n",
"}"
] |
// UInt16Range generates uint16 numbers within a given range
|
[
"UInt16Range",
"generates",
"uint16",
"numbers",
"within",
"a",
"given",
"range"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen/integers.go#L103-L110
|
9,348 |
leanovate/gopter
|
gen/integers.go
|
Int8Range
|
func Int8Range(min, max int8) gopter.Gen {
return Int64Range(int64(min), int64(max)).
Map(int64To8).
WithShrinker(Int8Shrinker).
SuchThat(func(v int8) bool {
return v >= min && v <= max
})
}
|
go
|
func Int8Range(min, max int8) gopter.Gen {
return Int64Range(int64(min), int64(max)).
Map(int64To8).
WithShrinker(Int8Shrinker).
SuchThat(func(v int8) bool {
return v >= min && v <= max
})
}
|
[
"func",
"Int8Range",
"(",
"min",
",",
"max",
"int8",
")",
"gopter",
".",
"Gen",
"{",
"return",
"Int64Range",
"(",
"int64",
"(",
"min",
")",
",",
"int64",
"(",
"max",
")",
")",
".",
"Map",
"(",
"int64To8",
")",
".",
"WithShrinker",
"(",
"Int8Shrinker",
")",
".",
"SuchThat",
"(",
"func",
"(",
"v",
"int8",
")",
"bool",
"{",
"return",
"v",
">=",
"min",
"&&",
"v",
"<=",
"max",
"\n",
"}",
")",
"\n",
"}"
] |
// Int8Range generates int8 numbers within a given range
|
[
"Int8Range",
"generates",
"int8",
"numbers",
"within",
"a",
"given",
"range"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen/integers.go#L123-L130
|
9,349 |
leanovate/gopter
|
gen/integers.go
|
UInt8Range
|
func UInt8Range(min, max uint8) gopter.Gen {
return UInt64Range(uint64(min), uint64(max)).
Map(uint64To8).
WithShrinker(UInt8Shrinker).
SuchThat(func(v uint8) bool {
return v >= min && v <= max
})
}
|
go
|
func UInt8Range(min, max uint8) gopter.Gen {
return UInt64Range(uint64(min), uint64(max)).
Map(uint64To8).
WithShrinker(UInt8Shrinker).
SuchThat(func(v uint8) bool {
return v >= min && v <= max
})
}
|
[
"func",
"UInt8Range",
"(",
"min",
",",
"max",
"uint8",
")",
"gopter",
".",
"Gen",
"{",
"return",
"UInt64Range",
"(",
"uint64",
"(",
"min",
")",
",",
"uint64",
"(",
"max",
")",
")",
".",
"Map",
"(",
"uint64To8",
")",
".",
"WithShrinker",
"(",
"UInt8Shrinker",
")",
".",
"SuchThat",
"(",
"func",
"(",
"v",
"uint8",
")",
"bool",
"{",
"return",
"v",
">=",
"min",
"&&",
"v",
"<=",
"max",
"\n",
"}",
")",
"\n",
"}"
] |
// UInt8Range generates uint8 numbers within a given range
|
[
"UInt8Range",
"generates",
"uint8",
"numbers",
"within",
"a",
"given",
"range"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen/integers.go#L133-L140
|
9,350 |
leanovate/gopter
|
gen/integers.go
|
IntRange
|
func IntRange(min, max int) gopter.Gen {
return Int64Range(int64(min), int64(max)).
Map(int64ToInt).
WithShrinker(IntShrinker).
SuchThat(func(v int) bool {
return v >= min && v <= max
})
}
|
go
|
func IntRange(min, max int) gopter.Gen {
return Int64Range(int64(min), int64(max)).
Map(int64ToInt).
WithShrinker(IntShrinker).
SuchThat(func(v int) bool {
return v >= min && v <= max
})
}
|
[
"func",
"IntRange",
"(",
"min",
",",
"max",
"int",
")",
"gopter",
".",
"Gen",
"{",
"return",
"Int64Range",
"(",
"int64",
"(",
"min",
")",
",",
"int64",
"(",
"max",
")",
")",
".",
"Map",
"(",
"int64ToInt",
")",
".",
"WithShrinker",
"(",
"IntShrinker",
")",
".",
"SuchThat",
"(",
"func",
"(",
"v",
"int",
")",
"bool",
"{",
"return",
"v",
">=",
"min",
"&&",
"v",
"<=",
"max",
"\n",
"}",
")",
"\n",
"}"
] |
// IntRange generates int numbers within a given range
|
[
"IntRange",
"generates",
"int",
"numbers",
"within",
"a",
"given",
"range"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen/integers.go#L153-L160
|
9,351 |
leanovate/gopter
|
gen/integers.go
|
Int
|
func Int() gopter.Gen {
return Int64Range(math.MinInt32, math.MaxInt32).
Map(int64ToInt).
WithShrinker(IntShrinker)
}
|
go
|
func Int() gopter.Gen {
return Int64Range(math.MinInt32, math.MaxInt32).
Map(int64ToInt).
WithShrinker(IntShrinker)
}
|
[
"func",
"Int",
"(",
")",
"gopter",
".",
"Gen",
"{",
"return",
"Int64Range",
"(",
"math",
".",
"MinInt32",
",",
"math",
".",
"MaxInt32",
")",
".",
"Map",
"(",
"int64ToInt",
")",
".",
"WithShrinker",
"(",
"IntShrinker",
")",
"\n",
"}"
] |
// Int generate arbitrary int numbers
|
[
"Int",
"generate",
"arbitrary",
"int",
"numbers"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen/integers.go#L163-L167
|
9,352 |
leanovate/gopter
|
gen/integers.go
|
UIntRange
|
func UIntRange(min, max uint) gopter.Gen {
return UInt64Range(uint64(min), uint64(max)).
Map(uint64ToUint).
WithShrinker(UIntShrinker).
SuchThat(func(v uint) bool {
return v >= min && v <= max
})
}
|
go
|
func UIntRange(min, max uint) gopter.Gen {
return UInt64Range(uint64(min), uint64(max)).
Map(uint64ToUint).
WithShrinker(UIntShrinker).
SuchThat(func(v uint) bool {
return v >= min && v <= max
})
}
|
[
"func",
"UIntRange",
"(",
"min",
",",
"max",
"uint",
")",
"gopter",
".",
"Gen",
"{",
"return",
"UInt64Range",
"(",
"uint64",
"(",
"min",
")",
",",
"uint64",
"(",
"max",
")",
")",
".",
"Map",
"(",
"uint64ToUint",
")",
".",
"WithShrinker",
"(",
"UIntShrinker",
")",
".",
"SuchThat",
"(",
"func",
"(",
"v",
"uint",
")",
"bool",
"{",
"return",
"v",
">=",
"min",
"&&",
"v",
"<=",
"max",
"\n",
"}",
")",
"\n",
"}"
] |
// UIntRange generates uint numbers within a given range
|
[
"UIntRange",
"generates",
"uint",
"numbers",
"within",
"a",
"given",
"range"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen/integers.go#L170-L177
|
9,353 |
leanovate/gopter
|
gen/integers.go
|
UInt
|
func UInt() gopter.Gen {
return UInt64Range(0, math.MaxUint32).
Map(uint64ToUint).
WithShrinker(UIntShrinker)
}
|
go
|
func UInt() gopter.Gen {
return UInt64Range(0, math.MaxUint32).
Map(uint64ToUint).
WithShrinker(UIntShrinker)
}
|
[
"func",
"UInt",
"(",
")",
"gopter",
".",
"Gen",
"{",
"return",
"UInt64Range",
"(",
"0",
",",
"math",
".",
"MaxUint32",
")",
".",
"Map",
"(",
"uint64ToUint",
")",
".",
"WithShrinker",
"(",
"UIntShrinker",
")",
"\n",
"}"
] |
// UInt generate arbitrary uint numbers
|
[
"UInt",
"generate",
"arbitrary",
"uint",
"numbers"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen/integers.go#L180-L184
|
9,354 |
leanovate/gopter
|
gen/integers.go
|
Size
|
func Size() gopter.Gen {
return func(genParams *gopter.GenParameters) *gopter.GenResult {
return gopter.NewGenResult(genParams.MaxSize, IntShrinker)
}
}
|
go
|
func Size() gopter.Gen {
return func(genParams *gopter.GenParameters) *gopter.GenResult {
return gopter.NewGenResult(genParams.MaxSize, IntShrinker)
}
}
|
[
"func",
"Size",
"(",
")",
"gopter",
".",
"Gen",
"{",
"return",
"func",
"(",
"genParams",
"*",
"gopter",
".",
"GenParameters",
")",
"*",
"gopter",
".",
"GenResult",
"{",
"return",
"gopter",
".",
"NewGenResult",
"(",
"genParams",
".",
"MaxSize",
",",
"IntShrinker",
")",
"\n",
"}",
"\n",
"}"
] |
// Size just extracts the MaxSize field of the GenParameters.
// This can be helpful to generate limited integer value in a more structued
// manner.
|
[
"Size",
"just",
"extracts",
"the",
"MaxSize",
"field",
"of",
"the",
"GenParameters",
".",
"This",
"can",
"be",
"helpful",
"to",
"generate",
"limited",
"integer",
"value",
"in",
"a",
"more",
"structued",
"manner",
"."
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen/integers.go#L189-L193
|
9,355 |
leanovate/gopter
|
formated_reporter.go
|
NewFormatedReporter
|
func NewFormatedReporter(verbose bool, width int, output io.Writer) Reporter {
return &FormatedReporter{
verbose: verbose,
width: width,
output: output,
}
}
|
go
|
func NewFormatedReporter(verbose bool, width int, output io.Writer) Reporter {
return &FormatedReporter{
verbose: verbose,
width: width,
output: output,
}
}
|
[
"func",
"NewFormatedReporter",
"(",
"verbose",
"bool",
",",
"width",
"int",
",",
"output",
"io",
".",
"Writer",
")",
"Reporter",
"{",
"return",
"&",
"FormatedReporter",
"{",
"verbose",
":",
"verbose",
",",
"width",
":",
"width",
",",
"output",
":",
"output",
",",
"}",
"\n",
"}"
] |
// NewFormatedReporter create a new formated reporter
// verbose toggles verbose output of the property results
// width is the maximal width per line
// output is the writer were the report will be written to
|
[
"NewFormatedReporter",
"create",
"a",
"new",
"formated",
"reporter",
"verbose",
"toggles",
"verbose",
"output",
"of",
"the",
"property",
"results",
"width",
"is",
"the",
"maximal",
"width",
"per",
"line",
"output",
"is",
"the",
"writer",
"were",
"the",
"report",
"will",
"be",
"written",
"to"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/formated_reporter.go#L24-L30
|
9,356 |
leanovate/gopter
|
gen/integers_shrink.go
|
Int64Shrinker
|
func Int64Shrinker(v interface{}) gopter.Shrink {
negShrink := int64Shrink{
original: -v.(int64),
half: -v.(int64),
}
posShrink := int64Shrink{
original: v.(int64),
half: v.(int64) / 2,
}
return gopter.Shrink(negShrink.Next).Interleave(gopter.Shrink(posShrink.Next))
}
|
go
|
func Int64Shrinker(v interface{}) gopter.Shrink {
negShrink := int64Shrink{
original: -v.(int64),
half: -v.(int64),
}
posShrink := int64Shrink{
original: v.(int64),
half: v.(int64) / 2,
}
return gopter.Shrink(negShrink.Next).Interleave(gopter.Shrink(posShrink.Next))
}
|
[
"func",
"Int64Shrinker",
"(",
"v",
"interface",
"{",
"}",
")",
"gopter",
".",
"Shrink",
"{",
"negShrink",
":=",
"int64Shrink",
"{",
"original",
":",
"-",
"v",
".",
"(",
"int64",
")",
",",
"half",
":",
"-",
"v",
".",
"(",
"int64",
")",
",",
"}",
"\n",
"posShrink",
":=",
"int64Shrink",
"{",
"original",
":",
"v",
".",
"(",
"int64",
")",
",",
"half",
":",
"v",
".",
"(",
"int64",
")",
"/",
"2",
",",
"}",
"\n",
"return",
"gopter",
".",
"Shrink",
"(",
"negShrink",
".",
"Next",
")",
".",
"Interleave",
"(",
"gopter",
".",
"Shrink",
"(",
"posShrink",
".",
"Next",
")",
")",
"\n",
"}"
] |
// Int64Shrinker is a shrinker for int64 numbers
|
[
"Int64Shrinker",
"is",
"a",
"shrinker",
"for",
"int64",
"numbers"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen/integers_shrink.go#L36-L46
|
9,357 |
leanovate/gopter
|
gen/integers_shrink.go
|
UInt64Shrinker
|
func UInt64Shrinker(v interface{}) gopter.Shrink {
shrink := uint64Shrink{
original: v.(uint64),
half: v.(uint64),
}
return shrink.Next
}
|
go
|
func UInt64Shrinker(v interface{}) gopter.Shrink {
shrink := uint64Shrink{
original: v.(uint64),
half: v.(uint64),
}
return shrink.Next
}
|
[
"func",
"UInt64Shrinker",
"(",
"v",
"interface",
"{",
"}",
")",
"gopter",
".",
"Shrink",
"{",
"shrink",
":=",
"uint64Shrink",
"{",
"original",
":",
"v",
".",
"(",
"uint64",
")",
",",
"half",
":",
"v",
".",
"(",
"uint64",
")",
",",
"}",
"\n",
"return",
"shrink",
".",
"Next",
"\n",
"}"
] |
// UInt64Shrinker is a shrinker for uint64 numbers
|
[
"UInt64Shrinker",
"is",
"a",
"shrinker",
"for",
"uint64",
"numbers"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen/integers_shrink.go#L49-L55
|
9,358 |
leanovate/gopter
|
gen/integers_shrink.go
|
Int32Shrinker
|
func Int32Shrinker(v interface{}) gopter.Shrink {
return Int64Shrinker(int64(v.(int32))).Map(int64To32)
}
|
go
|
func Int32Shrinker(v interface{}) gopter.Shrink {
return Int64Shrinker(int64(v.(int32))).Map(int64To32)
}
|
[
"func",
"Int32Shrinker",
"(",
"v",
"interface",
"{",
"}",
")",
"gopter",
".",
"Shrink",
"{",
"return",
"Int64Shrinker",
"(",
"int64",
"(",
"v",
".",
"(",
"int32",
")",
")",
")",
".",
"Map",
"(",
"int64To32",
")",
"\n",
"}"
] |
// Int32Shrinker is a shrinker for int32 numbers
|
[
"Int32Shrinker",
"is",
"a",
"shrinker",
"for",
"int32",
"numbers"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen/integers_shrink.go#L58-L60
|
9,359 |
leanovate/gopter
|
gen/integers_shrink.go
|
UInt32Shrinker
|
func UInt32Shrinker(v interface{}) gopter.Shrink {
return UInt64Shrinker(uint64(v.(uint32))).Map(uint64To32)
}
|
go
|
func UInt32Shrinker(v interface{}) gopter.Shrink {
return UInt64Shrinker(uint64(v.(uint32))).Map(uint64To32)
}
|
[
"func",
"UInt32Shrinker",
"(",
"v",
"interface",
"{",
"}",
")",
"gopter",
".",
"Shrink",
"{",
"return",
"UInt64Shrinker",
"(",
"uint64",
"(",
"v",
".",
"(",
"uint32",
")",
")",
")",
".",
"Map",
"(",
"uint64To32",
")",
"\n",
"}"
] |
// UInt32Shrinker is a shrinker for uint32 numbers
|
[
"UInt32Shrinker",
"is",
"a",
"shrinker",
"for",
"uint32",
"numbers"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen/integers_shrink.go#L63-L65
|
9,360 |
leanovate/gopter
|
gen/integers_shrink.go
|
Int16Shrinker
|
func Int16Shrinker(v interface{}) gopter.Shrink {
return Int64Shrinker(int64(v.(int16))).Map(int64To16)
}
|
go
|
func Int16Shrinker(v interface{}) gopter.Shrink {
return Int64Shrinker(int64(v.(int16))).Map(int64To16)
}
|
[
"func",
"Int16Shrinker",
"(",
"v",
"interface",
"{",
"}",
")",
"gopter",
".",
"Shrink",
"{",
"return",
"Int64Shrinker",
"(",
"int64",
"(",
"v",
".",
"(",
"int16",
")",
")",
")",
".",
"Map",
"(",
"int64To16",
")",
"\n",
"}"
] |
// Int16Shrinker is a shrinker for int16 numbers
|
[
"Int16Shrinker",
"is",
"a",
"shrinker",
"for",
"int16",
"numbers"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen/integers_shrink.go#L68-L70
|
9,361 |
leanovate/gopter
|
gen/integers_shrink.go
|
UInt16Shrinker
|
func UInt16Shrinker(v interface{}) gopter.Shrink {
return UInt64Shrinker(uint64(v.(uint16))).Map(uint64To16)
}
|
go
|
func UInt16Shrinker(v interface{}) gopter.Shrink {
return UInt64Shrinker(uint64(v.(uint16))).Map(uint64To16)
}
|
[
"func",
"UInt16Shrinker",
"(",
"v",
"interface",
"{",
"}",
")",
"gopter",
".",
"Shrink",
"{",
"return",
"UInt64Shrinker",
"(",
"uint64",
"(",
"v",
".",
"(",
"uint16",
")",
")",
")",
".",
"Map",
"(",
"uint64To16",
")",
"\n",
"}"
] |
// UInt16Shrinker is a shrinker for uint16 numbers
|
[
"UInt16Shrinker",
"is",
"a",
"shrinker",
"for",
"uint16",
"numbers"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen/integers_shrink.go#L73-L75
|
9,362 |
leanovate/gopter
|
gen/integers_shrink.go
|
Int8Shrinker
|
func Int8Shrinker(v interface{}) gopter.Shrink {
return Int64Shrinker(int64(v.(int8))).Map(int64To8)
}
|
go
|
func Int8Shrinker(v interface{}) gopter.Shrink {
return Int64Shrinker(int64(v.(int8))).Map(int64To8)
}
|
[
"func",
"Int8Shrinker",
"(",
"v",
"interface",
"{",
"}",
")",
"gopter",
".",
"Shrink",
"{",
"return",
"Int64Shrinker",
"(",
"int64",
"(",
"v",
".",
"(",
"int8",
")",
")",
")",
".",
"Map",
"(",
"int64To8",
")",
"\n",
"}"
] |
// Int8Shrinker is a shrinker for int8 numbers
|
[
"Int8Shrinker",
"is",
"a",
"shrinker",
"for",
"int8",
"numbers"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen/integers_shrink.go#L78-L80
|
9,363 |
leanovate/gopter
|
gen/integers_shrink.go
|
UInt8Shrinker
|
func UInt8Shrinker(v interface{}) gopter.Shrink {
return UInt64Shrinker(uint64(v.(uint8))).Map(uint64To8)
}
|
go
|
func UInt8Shrinker(v interface{}) gopter.Shrink {
return UInt64Shrinker(uint64(v.(uint8))).Map(uint64To8)
}
|
[
"func",
"UInt8Shrinker",
"(",
"v",
"interface",
"{",
"}",
")",
"gopter",
".",
"Shrink",
"{",
"return",
"UInt64Shrinker",
"(",
"uint64",
"(",
"v",
".",
"(",
"uint8",
")",
")",
")",
".",
"Map",
"(",
"uint64To8",
")",
"\n",
"}"
] |
// UInt8Shrinker is a shrinker for uint8 numbers
|
[
"UInt8Shrinker",
"is",
"a",
"shrinker",
"for",
"uint8",
"numbers"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen/integers_shrink.go#L83-L85
|
9,364 |
leanovate/gopter
|
gen/integers_shrink.go
|
IntShrinker
|
func IntShrinker(v interface{}) gopter.Shrink {
return Int64Shrinker(int64(v.(int))).Map(int64ToInt)
}
|
go
|
func IntShrinker(v interface{}) gopter.Shrink {
return Int64Shrinker(int64(v.(int))).Map(int64ToInt)
}
|
[
"func",
"IntShrinker",
"(",
"v",
"interface",
"{",
"}",
")",
"gopter",
".",
"Shrink",
"{",
"return",
"Int64Shrinker",
"(",
"int64",
"(",
"v",
".",
"(",
"int",
")",
")",
")",
".",
"Map",
"(",
"int64ToInt",
")",
"\n",
"}"
] |
// IntShrinker is a shrinker for int numbers
|
[
"IntShrinker",
"is",
"a",
"shrinker",
"for",
"int",
"numbers"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen/integers_shrink.go#L88-L90
|
9,365 |
leanovate/gopter
|
gen/integers_shrink.go
|
UIntShrinker
|
func UIntShrinker(v interface{}) gopter.Shrink {
return UInt64Shrinker(uint64(v.(uint))).Map(uint64ToUint)
}
|
go
|
func UIntShrinker(v interface{}) gopter.Shrink {
return UInt64Shrinker(uint64(v.(uint))).Map(uint64ToUint)
}
|
[
"func",
"UIntShrinker",
"(",
"v",
"interface",
"{",
"}",
")",
"gopter",
".",
"Shrink",
"{",
"return",
"UInt64Shrinker",
"(",
"uint64",
"(",
"v",
".",
"(",
"uint",
")",
")",
")",
".",
"Map",
"(",
"uint64ToUint",
")",
"\n",
"}"
] |
// UIntShrinker is a shrinker for uint numbers
|
[
"UIntShrinker",
"is",
"a",
"shrinker",
"for",
"uint",
"numbers"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen/integers_shrink.go#L93-L95
|
9,366 |
leanovate/gopter
|
gen/time_shrink.go
|
TimeShrinker
|
func TimeShrinker(v interface{}) gopter.Shrink {
t := v.(time.Time)
sec := t.Unix()
nsec := int64(t.Nanosecond())
secShrink := uint64Shrink{
original: uint64(sec),
half: uint64(sec),
}
nsecShrink := uint64Shrink{
original: uint64(nsec),
half: uint64(nsec),
}
return gopter.Shrink(secShrink.Next).Map(func(v uint64) time.Time {
return time.Unix(int64(v), nsec)
}).Interleave(gopter.Shrink(nsecShrink.Next).Map(func(v uint64) time.Time {
return time.Unix(sec, int64(v))
}))
}
|
go
|
func TimeShrinker(v interface{}) gopter.Shrink {
t := v.(time.Time)
sec := t.Unix()
nsec := int64(t.Nanosecond())
secShrink := uint64Shrink{
original: uint64(sec),
half: uint64(sec),
}
nsecShrink := uint64Shrink{
original: uint64(nsec),
half: uint64(nsec),
}
return gopter.Shrink(secShrink.Next).Map(func(v uint64) time.Time {
return time.Unix(int64(v), nsec)
}).Interleave(gopter.Shrink(nsecShrink.Next).Map(func(v uint64) time.Time {
return time.Unix(sec, int64(v))
}))
}
|
[
"func",
"TimeShrinker",
"(",
"v",
"interface",
"{",
"}",
")",
"gopter",
".",
"Shrink",
"{",
"t",
":=",
"v",
".",
"(",
"time",
".",
"Time",
")",
"\n",
"sec",
":=",
"t",
".",
"Unix",
"(",
")",
"\n",
"nsec",
":=",
"int64",
"(",
"t",
".",
"Nanosecond",
"(",
")",
")",
"\n",
"secShrink",
":=",
"uint64Shrink",
"{",
"original",
":",
"uint64",
"(",
"sec",
")",
",",
"half",
":",
"uint64",
"(",
"sec",
")",
",",
"}",
"\n",
"nsecShrink",
":=",
"uint64Shrink",
"{",
"original",
":",
"uint64",
"(",
"nsec",
")",
",",
"half",
":",
"uint64",
"(",
"nsec",
")",
",",
"}",
"\n",
"return",
"gopter",
".",
"Shrink",
"(",
"secShrink",
".",
"Next",
")",
".",
"Map",
"(",
"func",
"(",
"v",
"uint64",
")",
"time",
".",
"Time",
"{",
"return",
"time",
".",
"Unix",
"(",
"int64",
"(",
"v",
")",
",",
"nsec",
")",
"\n",
"}",
")",
".",
"Interleave",
"(",
"gopter",
".",
"Shrink",
"(",
"nsecShrink",
".",
"Next",
")",
".",
"Map",
"(",
"func",
"(",
"v",
"uint64",
")",
"time",
".",
"Time",
"{",
"return",
"time",
".",
"Unix",
"(",
"sec",
",",
"int64",
"(",
"v",
")",
")",
"\n",
"}",
")",
")",
"\n",
"}"
] |
// TimeShrinker is a shrinker for time.Time structs
|
[
"TimeShrinker",
"is",
"a",
"shrinker",
"for",
"time",
".",
"Time",
"structs"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen/time_shrink.go#L10-L27
|
9,367 |
leanovate/gopter
|
gen/weighted.go
|
Weighted
|
func Weighted(weightedGens []WeightedGen) gopter.Gen {
if len(weightedGens) == 0 {
panic("weightedGens must be non-empty")
}
weights := make(sort.IntSlice, 0, len(weightedGens))
totalWeight := 0
for _, weightedGen := range weightedGens {
w := weightedGen.Weight
if w <= 0 {
panic(fmt.Sprintf(
"weightedGens must have positive weights; got %d",
w))
}
totalWeight += weightedGen.Weight
weights = append(weights, totalWeight)
}
return func(genParams *gopter.GenParameters) *gopter.GenResult {
idx := weights.Search(1 + genParams.Rng.Intn(totalWeight))
gen := weightedGens[idx].Gen
result := gen(genParams)
result.Sieve = nil
return result
}
}
|
go
|
func Weighted(weightedGens []WeightedGen) gopter.Gen {
if len(weightedGens) == 0 {
panic("weightedGens must be non-empty")
}
weights := make(sort.IntSlice, 0, len(weightedGens))
totalWeight := 0
for _, weightedGen := range weightedGens {
w := weightedGen.Weight
if w <= 0 {
panic(fmt.Sprintf(
"weightedGens must have positive weights; got %d",
w))
}
totalWeight += weightedGen.Weight
weights = append(weights, totalWeight)
}
return func(genParams *gopter.GenParameters) *gopter.GenResult {
idx := weights.Search(1 + genParams.Rng.Intn(totalWeight))
gen := weightedGens[idx].Gen
result := gen(genParams)
result.Sieve = nil
return result
}
}
|
[
"func",
"Weighted",
"(",
"weightedGens",
"[",
"]",
"WeightedGen",
")",
"gopter",
".",
"Gen",
"{",
"if",
"len",
"(",
"weightedGens",
")",
"==",
"0",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"weights",
":=",
"make",
"(",
"sort",
".",
"IntSlice",
",",
"0",
",",
"len",
"(",
"weightedGens",
")",
")",
"\n\n",
"totalWeight",
":=",
"0",
"\n",
"for",
"_",
",",
"weightedGen",
":=",
"range",
"weightedGens",
"{",
"w",
":=",
"weightedGen",
".",
"Weight",
"\n",
"if",
"w",
"<=",
"0",
"{",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"w",
")",
")",
"\n",
"}",
"\n",
"totalWeight",
"+=",
"weightedGen",
".",
"Weight",
"\n",
"weights",
"=",
"append",
"(",
"weights",
",",
"totalWeight",
")",
"\n",
"}",
"\n",
"return",
"func",
"(",
"genParams",
"*",
"gopter",
".",
"GenParameters",
")",
"*",
"gopter",
".",
"GenResult",
"{",
"idx",
":=",
"weights",
".",
"Search",
"(",
"1",
"+",
"genParams",
".",
"Rng",
".",
"Intn",
"(",
"totalWeight",
")",
")",
"\n",
"gen",
":=",
"weightedGens",
"[",
"idx",
"]",
".",
"Gen",
"\n",
"result",
":=",
"gen",
"(",
"genParams",
")",
"\n",
"result",
".",
"Sieve",
"=",
"nil",
"\n",
"return",
"result",
"\n",
"}",
"\n",
"}"
] |
// Weighted combines multiple generators, where each generator has a weight.
// The weight of a generator is proportional to the probability that the
// generator gets selected.
|
[
"Weighted",
"combines",
"multiple",
"generators",
"where",
"each",
"generator",
"has",
"a",
"weight",
".",
"The",
"weight",
"of",
"a",
"generator",
"is",
"proportional",
"to",
"the",
"probability",
"that",
"the",
"generator",
"gets",
"selected",
"."
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen/weighted.go#L20-L44
|
9,368 |
leanovate/gopter
|
gen/const.go
|
Const
|
func Const(value interface{}) gopter.Gen {
return func(*gopter.GenParameters) *gopter.GenResult {
return gopter.NewGenResult(value, gopter.NoShrinker)
}
}
|
go
|
func Const(value interface{}) gopter.Gen {
return func(*gopter.GenParameters) *gopter.GenResult {
return gopter.NewGenResult(value, gopter.NoShrinker)
}
}
|
[
"func",
"Const",
"(",
"value",
"interface",
"{",
"}",
")",
"gopter",
".",
"Gen",
"{",
"return",
"func",
"(",
"*",
"gopter",
".",
"GenParameters",
")",
"*",
"gopter",
".",
"GenResult",
"{",
"return",
"gopter",
".",
"NewGenResult",
"(",
"value",
",",
"gopter",
".",
"NoShrinker",
")",
"\n",
"}",
"\n",
"}"
] |
// Const creates a generator for a constant value
// Not the most exciting generator, but can be helpful from time to time
|
[
"Const",
"creates",
"a",
"generator",
"for",
"a",
"constant",
"value",
"Not",
"the",
"most",
"exciting",
"generator",
"but",
"can",
"be",
"helpful",
"from",
"time",
"to",
"time"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen/const.go#L7-L11
|
9,369 |
leanovate/gopter
|
gen/one_of.go
|
OneConstOf
|
func OneConstOf(consts ...interface{}) gopter.Gen {
if len(consts) == 0 {
return Fail(reflect.TypeOf(nil))
}
return func(genParams *gopter.GenParameters) *gopter.GenResult {
idx := genParams.Rng.Intn(len(consts))
return gopter.NewGenResult(consts[idx], gopter.NoShrinker)
}
}
|
go
|
func OneConstOf(consts ...interface{}) gopter.Gen {
if len(consts) == 0 {
return Fail(reflect.TypeOf(nil))
}
return func(genParams *gopter.GenParameters) *gopter.GenResult {
idx := genParams.Rng.Intn(len(consts))
return gopter.NewGenResult(consts[idx], gopter.NoShrinker)
}
}
|
[
"func",
"OneConstOf",
"(",
"consts",
"...",
"interface",
"{",
"}",
")",
"gopter",
".",
"Gen",
"{",
"if",
"len",
"(",
"consts",
")",
"==",
"0",
"{",
"return",
"Fail",
"(",
"reflect",
".",
"TypeOf",
"(",
"nil",
")",
")",
"\n",
"}",
"\n",
"return",
"func",
"(",
"genParams",
"*",
"gopter",
".",
"GenParameters",
")",
"*",
"gopter",
".",
"GenResult",
"{",
"idx",
":=",
"genParams",
".",
"Rng",
".",
"Intn",
"(",
"len",
"(",
"consts",
")",
")",
"\n",
"return",
"gopter",
".",
"NewGenResult",
"(",
"consts",
"[",
"idx",
"]",
",",
"gopter",
".",
"NoShrinker",
")",
"\n",
"}",
"\n",
"}"
] |
// OneConstOf generate one of a list of constant values
|
[
"OneConstOf",
"generate",
"one",
"of",
"a",
"list",
"of",
"constant",
"values"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen/one_of.go#L10-L18
|
9,370 |
leanovate/gopter
|
gen/one_of.go
|
OneGenOf
|
func OneGenOf(gens ...gopter.Gen) gopter.Gen {
if len(gens) == 0 {
return Fail(reflect.TypeOf(nil))
}
return func(genParams *gopter.GenParameters) *gopter.GenResult {
idx := genParams.Rng.Intn(len(gens))
return gens[idx](genParams)
}
}
|
go
|
func OneGenOf(gens ...gopter.Gen) gopter.Gen {
if len(gens) == 0 {
return Fail(reflect.TypeOf(nil))
}
return func(genParams *gopter.GenParameters) *gopter.GenResult {
idx := genParams.Rng.Intn(len(gens))
return gens[idx](genParams)
}
}
|
[
"func",
"OneGenOf",
"(",
"gens",
"...",
"gopter",
".",
"Gen",
")",
"gopter",
".",
"Gen",
"{",
"if",
"len",
"(",
"gens",
")",
"==",
"0",
"{",
"return",
"Fail",
"(",
"reflect",
".",
"TypeOf",
"(",
"nil",
")",
")",
"\n",
"}",
"\n",
"return",
"func",
"(",
"genParams",
"*",
"gopter",
".",
"GenParameters",
")",
"*",
"gopter",
".",
"GenResult",
"{",
"idx",
":=",
"genParams",
".",
"Rng",
".",
"Intn",
"(",
"len",
"(",
"gens",
")",
")",
"\n",
"return",
"gens",
"[",
"idx",
"]",
"(",
"genParams",
")",
"\n",
"}",
"\n",
"}"
] |
// OneGenOf generate one value from a a list of generators
|
[
"OneGenOf",
"generate",
"one",
"value",
"from",
"a",
"a",
"list",
"of",
"generators"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen/one_of.go#L21-L29
|
9,371 |
leanovate/gopter
|
gen/floats_shrink.go
|
Float64Shrinker
|
func Float64Shrinker(v interface{}) gopter.Shrink {
negShrink := float64Shrink{
original: -v.(float64),
half: -v.(float64),
}
posShrink := float64Shrink{
original: v.(float64),
half: v.(float64) / 2,
}
return gopter.Shrink(negShrink.Next).Interleave(gopter.Shrink(posShrink.Next))
}
|
go
|
func Float64Shrinker(v interface{}) gopter.Shrink {
negShrink := float64Shrink{
original: -v.(float64),
half: -v.(float64),
}
posShrink := float64Shrink{
original: v.(float64),
half: v.(float64) / 2,
}
return gopter.Shrink(negShrink.Next).Interleave(gopter.Shrink(posShrink.Next))
}
|
[
"func",
"Float64Shrinker",
"(",
"v",
"interface",
"{",
"}",
")",
"gopter",
".",
"Shrink",
"{",
"negShrink",
":=",
"float64Shrink",
"{",
"original",
":",
"-",
"v",
".",
"(",
"float64",
")",
",",
"half",
":",
"-",
"v",
".",
"(",
"float64",
")",
",",
"}",
"\n",
"posShrink",
":=",
"float64Shrink",
"{",
"original",
":",
"v",
".",
"(",
"float64",
")",
",",
"half",
":",
"v",
".",
"(",
"float64",
")",
"/",
"2",
",",
"}",
"\n",
"return",
"gopter",
".",
"Shrink",
"(",
"negShrink",
".",
"Next",
")",
".",
"Interleave",
"(",
"gopter",
".",
"Shrink",
"(",
"posShrink",
".",
"Next",
")",
")",
"\n",
"}"
] |
// Float64Shrinker is a shrinker for float64 numbers
|
[
"Float64Shrinker",
"is",
"a",
"shrinker",
"for",
"float64",
"numbers"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen/floats_shrink.go#L32-L42
|
9,372 |
leanovate/gopter
|
gen/floats_shrink.go
|
Float32Shrinker
|
func Float32Shrinker(v interface{}) gopter.Shrink {
return Float64Shrinker(float64(v.(float32))).Map(func(e float64) float32 {
return float32(e)
})
}
|
go
|
func Float32Shrinker(v interface{}) gopter.Shrink {
return Float64Shrinker(float64(v.(float32))).Map(func(e float64) float32 {
return float32(e)
})
}
|
[
"func",
"Float32Shrinker",
"(",
"v",
"interface",
"{",
"}",
")",
"gopter",
".",
"Shrink",
"{",
"return",
"Float64Shrinker",
"(",
"float64",
"(",
"v",
".",
"(",
"float32",
")",
")",
")",
".",
"Map",
"(",
"func",
"(",
"e",
"float64",
")",
"float32",
"{",
"return",
"float32",
"(",
"e",
")",
"\n",
"}",
")",
"\n",
"}"
] |
// Float32Shrinker is a shrinker for float32 numbers
|
[
"Float32Shrinker",
"is",
"a",
"shrinker",
"for",
"float32",
"numbers"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen/floats_shrink.go#L45-L49
|
9,373 |
leanovate/gopter
|
prop/forall.go
|
ForAll1
|
func ForAll1(gen gopter.Gen, check func(v interface{}) (interface{}, error)) gopter.Prop {
checkFunc := func(v interface{}) *gopter.PropResult {
return convertResult(check(v))
}
return gopter.SaveProp(func(genParams *gopter.GenParameters) *gopter.PropResult {
genResult := gen(genParams)
value, ok := genResult.Retrieve()
if !ok {
return &gopter.PropResult{
Status: gopter.PropUndecided,
}
}
result := checkFunc(value)
if result.Success() {
return result.AddArgs(gopter.NewPropArg(genResult, 0, value, value))
}
result, _ = shrinkValue(genParams.MaxShrinkCount, genResult, value, result, checkFunc)
return result
})
}
|
go
|
func ForAll1(gen gopter.Gen, check func(v interface{}) (interface{}, error)) gopter.Prop {
checkFunc := func(v interface{}) *gopter.PropResult {
return convertResult(check(v))
}
return gopter.SaveProp(func(genParams *gopter.GenParameters) *gopter.PropResult {
genResult := gen(genParams)
value, ok := genResult.Retrieve()
if !ok {
return &gopter.PropResult{
Status: gopter.PropUndecided,
}
}
result := checkFunc(value)
if result.Success() {
return result.AddArgs(gopter.NewPropArg(genResult, 0, value, value))
}
result, _ = shrinkValue(genParams.MaxShrinkCount, genResult, value, result, checkFunc)
return result
})
}
|
[
"func",
"ForAll1",
"(",
"gen",
"gopter",
".",
"Gen",
",",
"check",
"func",
"(",
"v",
"interface",
"{",
"}",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
")",
"gopter",
".",
"Prop",
"{",
"checkFunc",
":=",
"func",
"(",
"v",
"interface",
"{",
"}",
")",
"*",
"gopter",
".",
"PropResult",
"{",
"return",
"convertResult",
"(",
"check",
"(",
"v",
")",
")",
"\n",
"}",
"\n",
"return",
"gopter",
".",
"SaveProp",
"(",
"func",
"(",
"genParams",
"*",
"gopter",
".",
"GenParameters",
")",
"*",
"gopter",
".",
"PropResult",
"{",
"genResult",
":=",
"gen",
"(",
"genParams",
")",
"\n",
"value",
",",
"ok",
":=",
"genResult",
".",
"Retrieve",
"(",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"&",
"gopter",
".",
"PropResult",
"{",
"Status",
":",
"gopter",
".",
"PropUndecided",
",",
"}",
"\n",
"}",
"\n",
"result",
":=",
"checkFunc",
"(",
"value",
")",
"\n",
"if",
"result",
".",
"Success",
"(",
")",
"{",
"return",
"result",
".",
"AddArgs",
"(",
"gopter",
".",
"NewPropArg",
"(",
"genResult",
",",
"0",
",",
"value",
",",
"value",
")",
")",
"\n",
"}",
"\n\n",
"result",
",",
"_",
"=",
"shrinkValue",
"(",
"genParams",
".",
"MaxShrinkCount",
",",
"genResult",
",",
"value",
",",
"result",
",",
"checkFunc",
")",
"\n",
"return",
"result",
"\n",
"}",
")",
"\n",
"}"
] |
// ForAll1 legacy interface to be removed in the future
|
[
"ForAll1",
"legacy",
"interface",
"to",
"be",
"removed",
"in",
"the",
"future"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/prop/forall.go#L71-L91
|
9,374 |
leanovate/gopter
|
gen/bool.go
|
Bool
|
func Bool() gopter.Gen {
return func(genParams *gopter.GenParameters) *gopter.GenResult {
return gopter.NewGenResult(genParams.NextBool(), gopter.NoShrinker)
}
}
|
go
|
func Bool() gopter.Gen {
return func(genParams *gopter.GenParameters) *gopter.GenResult {
return gopter.NewGenResult(genParams.NextBool(), gopter.NoShrinker)
}
}
|
[
"func",
"Bool",
"(",
")",
"gopter",
".",
"Gen",
"{",
"return",
"func",
"(",
"genParams",
"*",
"gopter",
".",
"GenParameters",
")",
"*",
"gopter",
".",
"GenResult",
"{",
"return",
"gopter",
".",
"NewGenResult",
"(",
"genParams",
".",
"NextBool",
"(",
")",
",",
"gopter",
".",
"NoShrinker",
")",
"\n",
"}",
"\n",
"}"
] |
// Bool generates an arbitrary bool value
|
[
"Bool",
"generates",
"an",
"arbitrary",
"bool",
"value"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen/bool.go#L6-L10
|
9,375 |
leanovate/gopter
|
prop.go
|
SaveProp
|
func SaveProp(prop Prop) Prop {
return func(genParams *GenParameters) (result *PropResult) {
defer func() {
if r := recover(); r != nil {
result = &PropResult{
Status: PropError,
Error: fmt.Errorf("Check paniced: %v", r),
ErrorStack: debug.Stack(),
}
}
}()
return prop(genParams)
}
}
|
go
|
func SaveProp(prop Prop) Prop {
return func(genParams *GenParameters) (result *PropResult) {
defer func() {
if r := recover(); r != nil {
result = &PropResult{
Status: PropError,
Error: fmt.Errorf("Check paniced: %v", r),
ErrorStack: debug.Stack(),
}
}
}()
return prop(genParams)
}
}
|
[
"func",
"SaveProp",
"(",
"prop",
"Prop",
")",
"Prop",
"{",
"return",
"func",
"(",
"genParams",
"*",
"GenParameters",
")",
"(",
"result",
"*",
"PropResult",
")",
"{",
"defer",
"func",
"(",
")",
"{",
"if",
"r",
":=",
"recover",
"(",
")",
";",
"r",
"!=",
"nil",
"{",
"result",
"=",
"&",
"PropResult",
"{",
"Status",
":",
"PropError",
",",
"Error",
":",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"r",
")",
",",
"ErrorStack",
":",
"debug",
".",
"Stack",
"(",
")",
",",
"}",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n\n",
"return",
"prop",
"(",
"genParams",
")",
"\n",
"}",
"\n",
"}"
] |
// SaveProp creates s save property by handling all panics from an inner property
|
[
"SaveProp",
"creates",
"s",
"save",
"property",
"by",
"handling",
"all",
"panics",
"from",
"an",
"inner",
"property"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/prop.go#L13-L27
|
9,376 |
leanovate/gopter
|
prop.go
|
Check
|
func (prop Prop) Check(parameters *TestParameters) *TestResult {
iterations := math.Ceil(float64(parameters.MinSuccessfulTests) / float64(parameters.Workers))
sizeStep := float64(parameters.MaxSize-parameters.MinSize) / (iterations * float64(parameters.Workers))
genParameters := GenParameters{
MinSize: parameters.MinSize,
MaxSize: parameters.MaxSize,
MaxShrinkCount: parameters.MaxShrinkCount,
Rng: parameters.Rng,
}
runner := &runner{
parameters: parameters,
worker: func(workerIdx int, shouldStop shouldStop) *TestResult {
var n int
var d int
isExhaused := func() bool {
return n+d > parameters.MinSuccessfulTests &&
1.0+float64(parameters.Workers*n)*parameters.MaxDiscardRatio < float64(d)
}
for !shouldStop() && n < int(iterations) {
size := float64(parameters.MinSize) + (sizeStep * float64(workerIdx+(parameters.Workers*(n+d))))
propResult := prop(genParameters.WithSize(int(size)))
switch propResult.Status {
case PropUndecided:
d++
if isExhaused() {
return &TestResult{
Status: TestExhausted,
Succeeded: n,
Discarded: d,
}
}
case PropTrue:
n++
case PropProof:
n++
return &TestResult{
Status: TestProved,
Succeeded: n,
Discarded: d,
Labels: propResult.Labels,
Args: propResult.Args,
}
case PropFalse:
return &TestResult{
Status: TestFailed,
Succeeded: n,
Discarded: d,
Labels: propResult.Labels,
Args: propResult.Args,
}
case PropError:
return &TestResult{
Status: TestError,
Succeeded: n,
Discarded: d,
Labels: propResult.Labels,
Error: propResult.Error,
ErrorStack: propResult.ErrorStack,
Args: propResult.Args,
}
}
}
if isExhaused() {
return &TestResult{
Status: TestExhausted,
Succeeded: n,
Discarded: d,
}
}
return &TestResult{
Status: TestPassed,
Succeeded: n,
Discarded: d,
}
},
}
return runner.runWorkers()
}
|
go
|
func (prop Prop) Check(parameters *TestParameters) *TestResult {
iterations := math.Ceil(float64(parameters.MinSuccessfulTests) / float64(parameters.Workers))
sizeStep := float64(parameters.MaxSize-parameters.MinSize) / (iterations * float64(parameters.Workers))
genParameters := GenParameters{
MinSize: parameters.MinSize,
MaxSize: parameters.MaxSize,
MaxShrinkCount: parameters.MaxShrinkCount,
Rng: parameters.Rng,
}
runner := &runner{
parameters: parameters,
worker: func(workerIdx int, shouldStop shouldStop) *TestResult {
var n int
var d int
isExhaused := func() bool {
return n+d > parameters.MinSuccessfulTests &&
1.0+float64(parameters.Workers*n)*parameters.MaxDiscardRatio < float64(d)
}
for !shouldStop() && n < int(iterations) {
size := float64(parameters.MinSize) + (sizeStep * float64(workerIdx+(parameters.Workers*(n+d))))
propResult := prop(genParameters.WithSize(int(size)))
switch propResult.Status {
case PropUndecided:
d++
if isExhaused() {
return &TestResult{
Status: TestExhausted,
Succeeded: n,
Discarded: d,
}
}
case PropTrue:
n++
case PropProof:
n++
return &TestResult{
Status: TestProved,
Succeeded: n,
Discarded: d,
Labels: propResult.Labels,
Args: propResult.Args,
}
case PropFalse:
return &TestResult{
Status: TestFailed,
Succeeded: n,
Discarded: d,
Labels: propResult.Labels,
Args: propResult.Args,
}
case PropError:
return &TestResult{
Status: TestError,
Succeeded: n,
Discarded: d,
Labels: propResult.Labels,
Error: propResult.Error,
ErrorStack: propResult.ErrorStack,
Args: propResult.Args,
}
}
}
if isExhaused() {
return &TestResult{
Status: TestExhausted,
Succeeded: n,
Discarded: d,
}
}
return &TestResult{
Status: TestPassed,
Succeeded: n,
Discarded: d,
}
},
}
return runner.runWorkers()
}
|
[
"func",
"(",
"prop",
"Prop",
")",
"Check",
"(",
"parameters",
"*",
"TestParameters",
")",
"*",
"TestResult",
"{",
"iterations",
":=",
"math",
".",
"Ceil",
"(",
"float64",
"(",
"parameters",
".",
"MinSuccessfulTests",
")",
"/",
"float64",
"(",
"parameters",
".",
"Workers",
")",
")",
"\n",
"sizeStep",
":=",
"float64",
"(",
"parameters",
".",
"MaxSize",
"-",
"parameters",
".",
"MinSize",
")",
"/",
"(",
"iterations",
"*",
"float64",
"(",
"parameters",
".",
"Workers",
")",
")",
"\n\n",
"genParameters",
":=",
"GenParameters",
"{",
"MinSize",
":",
"parameters",
".",
"MinSize",
",",
"MaxSize",
":",
"parameters",
".",
"MaxSize",
",",
"MaxShrinkCount",
":",
"parameters",
".",
"MaxShrinkCount",
",",
"Rng",
":",
"parameters",
".",
"Rng",
",",
"}",
"\n",
"runner",
":=",
"&",
"runner",
"{",
"parameters",
":",
"parameters",
",",
"worker",
":",
"func",
"(",
"workerIdx",
"int",
",",
"shouldStop",
"shouldStop",
")",
"*",
"TestResult",
"{",
"var",
"n",
"int",
"\n",
"var",
"d",
"int",
"\n\n",
"isExhaused",
":=",
"func",
"(",
")",
"bool",
"{",
"return",
"n",
"+",
"d",
">",
"parameters",
".",
"MinSuccessfulTests",
"&&",
"1.0",
"+",
"float64",
"(",
"parameters",
".",
"Workers",
"*",
"n",
")",
"*",
"parameters",
".",
"MaxDiscardRatio",
"<",
"float64",
"(",
"d",
")",
"\n",
"}",
"\n\n",
"for",
"!",
"shouldStop",
"(",
")",
"&&",
"n",
"<",
"int",
"(",
"iterations",
")",
"{",
"size",
":=",
"float64",
"(",
"parameters",
".",
"MinSize",
")",
"+",
"(",
"sizeStep",
"*",
"float64",
"(",
"workerIdx",
"+",
"(",
"parameters",
".",
"Workers",
"*",
"(",
"n",
"+",
"d",
")",
")",
")",
")",
"\n",
"propResult",
":=",
"prop",
"(",
"genParameters",
".",
"WithSize",
"(",
"int",
"(",
"size",
")",
")",
")",
"\n\n",
"switch",
"propResult",
".",
"Status",
"{",
"case",
"PropUndecided",
":",
"d",
"++",
"\n",
"if",
"isExhaused",
"(",
")",
"{",
"return",
"&",
"TestResult",
"{",
"Status",
":",
"TestExhausted",
",",
"Succeeded",
":",
"n",
",",
"Discarded",
":",
"d",
",",
"}",
"\n",
"}",
"\n",
"case",
"PropTrue",
":",
"n",
"++",
"\n",
"case",
"PropProof",
":",
"n",
"++",
"\n",
"return",
"&",
"TestResult",
"{",
"Status",
":",
"TestProved",
",",
"Succeeded",
":",
"n",
",",
"Discarded",
":",
"d",
",",
"Labels",
":",
"propResult",
".",
"Labels",
",",
"Args",
":",
"propResult",
".",
"Args",
",",
"}",
"\n",
"case",
"PropFalse",
":",
"return",
"&",
"TestResult",
"{",
"Status",
":",
"TestFailed",
",",
"Succeeded",
":",
"n",
",",
"Discarded",
":",
"d",
",",
"Labels",
":",
"propResult",
".",
"Labels",
",",
"Args",
":",
"propResult",
".",
"Args",
",",
"}",
"\n",
"case",
"PropError",
":",
"return",
"&",
"TestResult",
"{",
"Status",
":",
"TestError",
",",
"Succeeded",
":",
"n",
",",
"Discarded",
":",
"d",
",",
"Labels",
":",
"propResult",
".",
"Labels",
",",
"Error",
":",
"propResult",
".",
"Error",
",",
"ErrorStack",
":",
"propResult",
".",
"ErrorStack",
",",
"Args",
":",
"propResult",
".",
"Args",
",",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"isExhaused",
"(",
")",
"{",
"return",
"&",
"TestResult",
"{",
"Status",
":",
"TestExhausted",
",",
"Succeeded",
":",
"n",
",",
"Discarded",
":",
"d",
",",
"}",
"\n",
"}",
"\n",
"return",
"&",
"TestResult",
"{",
"Status",
":",
"TestPassed",
",",
"Succeeded",
":",
"n",
",",
"Discarded",
":",
"d",
",",
"}",
"\n",
"}",
",",
"}",
"\n\n",
"return",
"runner",
".",
"runWorkers",
"(",
")",
"\n",
"}"
] |
// Check the property using specific parameters
|
[
"Check",
"the",
"property",
"using",
"specific",
"parameters"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/prop.go#L30-L113
|
9,377 |
leanovate/gopter
|
gen/fail.go
|
Fail
|
func Fail(resultType reflect.Type) gopter.Gen {
return func(*gopter.GenParameters) *gopter.GenResult {
return gopter.NewEmptyResult(resultType)
}
}
|
go
|
func Fail(resultType reflect.Type) gopter.Gen {
return func(*gopter.GenParameters) *gopter.GenResult {
return gopter.NewEmptyResult(resultType)
}
}
|
[
"func",
"Fail",
"(",
"resultType",
"reflect",
".",
"Type",
")",
"gopter",
".",
"Gen",
"{",
"return",
"func",
"(",
"*",
"gopter",
".",
"GenParameters",
")",
"*",
"gopter",
".",
"GenResult",
"{",
"return",
"gopter",
".",
"NewEmptyResult",
"(",
"resultType",
")",
"\n",
"}",
"\n",
"}"
] |
// Fail is a generator that always fails to generate a value
// Useful as fallback
|
[
"Fail",
"is",
"a",
"generator",
"that",
"always",
"fails",
"to",
"generate",
"a",
"value",
"Useful",
"as",
"fallback"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen/fail.go#L11-L15
|
9,378 |
leanovate/gopter
|
gen/ptr_of.go
|
PtrOf
|
func PtrOf(elementGen gopter.Gen) gopter.Gen {
return func(genParams *gopter.GenParameters) *gopter.GenResult {
element := elementGen(genParams)
elementShrinker := element.Shrinker
elementSieve := element.Sieve
value, ok := element.Retrieve()
if !ok || genParams.NextBool() {
result := gopter.NewEmptyResult(reflect.PtrTo(element.ResultType))
result.Sieve = func(v interface{}) bool {
if elementSieve == nil {
return true
}
r := reflect.ValueOf(v)
return !r.IsValid() || r.IsNil() || elementSieve(r.Elem().Interface())
}
return result
}
// To get the right pointer type we have to create a slice with one element
slice := reflect.MakeSlice(reflect.SliceOf(element.ResultType), 0, 1)
slice = reflect.Append(slice, reflect.ValueOf(value))
result := gopter.NewGenResult(slice.Index(0).Addr().Interface(), PtrShrinker(elementShrinker))
result.Sieve = func(v interface{}) bool {
if elementSieve == nil {
return true
}
r := reflect.ValueOf(v)
return !r.IsValid() || r.IsNil() || elementSieve(r.Elem().Interface())
}
return result
}
}
|
go
|
func PtrOf(elementGen gopter.Gen) gopter.Gen {
return func(genParams *gopter.GenParameters) *gopter.GenResult {
element := elementGen(genParams)
elementShrinker := element.Shrinker
elementSieve := element.Sieve
value, ok := element.Retrieve()
if !ok || genParams.NextBool() {
result := gopter.NewEmptyResult(reflect.PtrTo(element.ResultType))
result.Sieve = func(v interface{}) bool {
if elementSieve == nil {
return true
}
r := reflect.ValueOf(v)
return !r.IsValid() || r.IsNil() || elementSieve(r.Elem().Interface())
}
return result
}
// To get the right pointer type we have to create a slice with one element
slice := reflect.MakeSlice(reflect.SliceOf(element.ResultType), 0, 1)
slice = reflect.Append(slice, reflect.ValueOf(value))
result := gopter.NewGenResult(slice.Index(0).Addr().Interface(), PtrShrinker(elementShrinker))
result.Sieve = func(v interface{}) bool {
if elementSieve == nil {
return true
}
r := reflect.ValueOf(v)
return !r.IsValid() || r.IsNil() || elementSieve(r.Elem().Interface())
}
return result
}
}
|
[
"func",
"PtrOf",
"(",
"elementGen",
"gopter",
".",
"Gen",
")",
"gopter",
".",
"Gen",
"{",
"return",
"func",
"(",
"genParams",
"*",
"gopter",
".",
"GenParameters",
")",
"*",
"gopter",
".",
"GenResult",
"{",
"element",
":=",
"elementGen",
"(",
"genParams",
")",
"\n",
"elementShrinker",
":=",
"element",
".",
"Shrinker",
"\n",
"elementSieve",
":=",
"element",
".",
"Sieve",
"\n",
"value",
",",
"ok",
":=",
"element",
".",
"Retrieve",
"(",
")",
"\n",
"if",
"!",
"ok",
"||",
"genParams",
".",
"NextBool",
"(",
")",
"{",
"result",
":=",
"gopter",
".",
"NewEmptyResult",
"(",
"reflect",
".",
"PtrTo",
"(",
"element",
".",
"ResultType",
")",
")",
"\n",
"result",
".",
"Sieve",
"=",
"func",
"(",
"v",
"interface",
"{",
"}",
")",
"bool",
"{",
"if",
"elementSieve",
"==",
"nil",
"{",
"return",
"true",
"\n",
"}",
"\n",
"r",
":=",
"reflect",
".",
"ValueOf",
"(",
"v",
")",
"\n",
"return",
"!",
"r",
".",
"IsValid",
"(",
")",
"||",
"r",
".",
"IsNil",
"(",
")",
"||",
"elementSieve",
"(",
"r",
".",
"Elem",
"(",
")",
".",
"Interface",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"result",
"\n",
"}",
"\n",
"// To get the right pointer type we have to create a slice with one element",
"slice",
":=",
"reflect",
".",
"MakeSlice",
"(",
"reflect",
".",
"SliceOf",
"(",
"element",
".",
"ResultType",
")",
",",
"0",
",",
"1",
")",
"\n",
"slice",
"=",
"reflect",
".",
"Append",
"(",
"slice",
",",
"reflect",
".",
"ValueOf",
"(",
"value",
")",
")",
"\n\n",
"result",
":=",
"gopter",
".",
"NewGenResult",
"(",
"slice",
".",
"Index",
"(",
"0",
")",
".",
"Addr",
"(",
")",
".",
"Interface",
"(",
")",
",",
"PtrShrinker",
"(",
"elementShrinker",
")",
")",
"\n",
"result",
".",
"Sieve",
"=",
"func",
"(",
"v",
"interface",
"{",
"}",
")",
"bool",
"{",
"if",
"elementSieve",
"==",
"nil",
"{",
"return",
"true",
"\n",
"}",
"\n",
"r",
":=",
"reflect",
".",
"ValueOf",
"(",
"v",
")",
"\n",
"return",
"!",
"r",
".",
"IsValid",
"(",
")",
"||",
"r",
".",
"IsNil",
"(",
")",
"||",
"elementSieve",
"(",
"r",
".",
"Elem",
"(",
")",
".",
"Interface",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"result",
"\n",
"}",
"\n",
"}"
] |
// PtrOf generates either a pointer to a generated element or a nil pointer
|
[
"PtrOf",
"generates",
"either",
"a",
"pointer",
"to",
"a",
"generated",
"element",
"or",
"a",
"nil",
"pointer"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen/ptr_of.go#L10-L41
|
9,379 |
leanovate/gopter
|
bi_mapper.go
|
ConvertUp
|
func (b *BiMapper) ConvertUp(down []interface{}) []interface{} {
if len(down) != len(b.DownTypes) {
panic(fmt.Sprintf("Expected %d values != %d", len(b.DownTypes), len(down)))
}
downVals := make([]reflect.Value, len(b.DownTypes))
for i, val := range down {
if val == nil {
downVals[i] = reflect.Zero(b.DownTypes[i])
} else {
downVals[i] = reflect.ValueOf(val)
}
}
upVals := b.Upstream.Call(downVals)
up := make([]interface{}, len(upVals))
for i, upVal := range upVals {
up[i] = upVal.Interface()
}
return up
}
|
go
|
func (b *BiMapper) ConvertUp(down []interface{}) []interface{} {
if len(down) != len(b.DownTypes) {
panic(fmt.Sprintf("Expected %d values != %d", len(b.DownTypes), len(down)))
}
downVals := make([]reflect.Value, len(b.DownTypes))
for i, val := range down {
if val == nil {
downVals[i] = reflect.Zero(b.DownTypes[i])
} else {
downVals[i] = reflect.ValueOf(val)
}
}
upVals := b.Upstream.Call(downVals)
up := make([]interface{}, len(upVals))
for i, upVal := range upVals {
up[i] = upVal.Interface()
}
return up
}
|
[
"func",
"(",
"b",
"*",
"BiMapper",
")",
"ConvertUp",
"(",
"down",
"[",
"]",
"interface",
"{",
"}",
")",
"[",
"]",
"interface",
"{",
"}",
"{",
"if",
"len",
"(",
"down",
")",
"!=",
"len",
"(",
"b",
".",
"DownTypes",
")",
"{",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"len",
"(",
"b",
".",
"DownTypes",
")",
",",
"len",
"(",
"down",
")",
")",
")",
"\n",
"}",
"\n",
"downVals",
":=",
"make",
"(",
"[",
"]",
"reflect",
".",
"Value",
",",
"len",
"(",
"b",
".",
"DownTypes",
")",
")",
"\n",
"for",
"i",
",",
"val",
":=",
"range",
"down",
"{",
"if",
"val",
"==",
"nil",
"{",
"downVals",
"[",
"i",
"]",
"=",
"reflect",
".",
"Zero",
"(",
"b",
".",
"DownTypes",
"[",
"i",
"]",
")",
"\n",
"}",
"else",
"{",
"downVals",
"[",
"i",
"]",
"=",
"reflect",
".",
"ValueOf",
"(",
"val",
")",
"\n",
"}",
"\n",
"}",
"\n",
"upVals",
":=",
"b",
".",
"Upstream",
".",
"Call",
"(",
"downVals",
")",
"\n",
"up",
":=",
"make",
"(",
"[",
"]",
"interface",
"{",
"}",
",",
"len",
"(",
"upVals",
")",
")",
"\n",
"for",
"i",
",",
"upVal",
":=",
"range",
"upVals",
"{",
"up",
"[",
"i",
"]",
"=",
"upVal",
".",
"Interface",
"(",
")",
"\n",
"}",
"\n\n",
"return",
"up",
"\n",
"}"
] |
// ConvertUp calls the Upstream function on the arguments in the down array
// and returns the results.
|
[
"ConvertUp",
"calls",
"the",
"Upstream",
"function",
"on",
"the",
"arguments",
"in",
"the",
"down",
"array",
"and",
"returns",
"the",
"results",
"."
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/bi_mapper.go#L69-L88
|
9,380 |
leanovate/gopter
|
bi_mapper.go
|
ConvertDown
|
func (b *BiMapper) ConvertDown(up []interface{}) []interface{} {
if len(up) != len(b.UpTypes) {
panic(fmt.Sprintf("Expected %d values != %d", len(b.UpTypes), len(up)))
}
upVals := make([]reflect.Value, len(b.UpTypes))
for i, val := range up {
if val == nil {
upVals[i] = reflect.Zero(b.UpTypes[i])
} else {
upVals[i] = reflect.ValueOf(val)
}
}
downVals := b.Downstream.Call(upVals)
down := make([]interface{}, len(downVals))
for i, downVal := range downVals {
down[i] = downVal.Interface()
}
return down
}
|
go
|
func (b *BiMapper) ConvertDown(up []interface{}) []interface{} {
if len(up) != len(b.UpTypes) {
panic(fmt.Sprintf("Expected %d values != %d", len(b.UpTypes), len(up)))
}
upVals := make([]reflect.Value, len(b.UpTypes))
for i, val := range up {
if val == nil {
upVals[i] = reflect.Zero(b.UpTypes[i])
} else {
upVals[i] = reflect.ValueOf(val)
}
}
downVals := b.Downstream.Call(upVals)
down := make([]interface{}, len(downVals))
for i, downVal := range downVals {
down[i] = downVal.Interface()
}
return down
}
|
[
"func",
"(",
"b",
"*",
"BiMapper",
")",
"ConvertDown",
"(",
"up",
"[",
"]",
"interface",
"{",
"}",
")",
"[",
"]",
"interface",
"{",
"}",
"{",
"if",
"len",
"(",
"up",
")",
"!=",
"len",
"(",
"b",
".",
"UpTypes",
")",
"{",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"len",
"(",
"b",
".",
"UpTypes",
")",
",",
"len",
"(",
"up",
")",
")",
")",
"\n",
"}",
"\n",
"upVals",
":=",
"make",
"(",
"[",
"]",
"reflect",
".",
"Value",
",",
"len",
"(",
"b",
".",
"UpTypes",
")",
")",
"\n",
"for",
"i",
",",
"val",
":=",
"range",
"up",
"{",
"if",
"val",
"==",
"nil",
"{",
"upVals",
"[",
"i",
"]",
"=",
"reflect",
".",
"Zero",
"(",
"b",
".",
"UpTypes",
"[",
"i",
"]",
")",
"\n",
"}",
"else",
"{",
"upVals",
"[",
"i",
"]",
"=",
"reflect",
".",
"ValueOf",
"(",
"val",
")",
"\n",
"}",
"\n",
"}",
"\n",
"downVals",
":=",
"b",
".",
"Downstream",
".",
"Call",
"(",
"upVals",
")",
"\n",
"down",
":=",
"make",
"(",
"[",
"]",
"interface",
"{",
"}",
",",
"len",
"(",
"downVals",
")",
")",
"\n",
"for",
"i",
",",
"downVal",
":=",
"range",
"downVals",
"{",
"down",
"[",
"i",
"]",
"=",
"downVal",
".",
"Interface",
"(",
")",
"\n",
"}",
"\n\n",
"return",
"down",
"\n",
"}"
] |
// ConvertDown calls the Downstream function on the elements of the up array
// and returns the results.
|
[
"ConvertDown",
"calls",
"the",
"Downstream",
"function",
"on",
"the",
"elements",
"of",
"the",
"up",
"array",
"and",
"returns",
"the",
"results",
"."
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/bi_mapper.go#L92-L111
|
9,381 |
leanovate/gopter
|
shrink.go
|
Filter
|
func (s Shrink) Filter(condition func(interface{}) bool) Shrink {
if condition == nil {
return s
}
return func() (interface{}, bool) {
value, ok := s()
for ok && !condition(value) {
value, ok = s()
}
return value, ok
}
}
|
go
|
func (s Shrink) Filter(condition func(interface{}) bool) Shrink {
if condition == nil {
return s
}
return func() (interface{}, bool) {
value, ok := s()
for ok && !condition(value) {
value, ok = s()
}
return value, ok
}
}
|
[
"func",
"(",
"s",
"Shrink",
")",
"Filter",
"(",
"condition",
"func",
"(",
"interface",
"{",
"}",
")",
"bool",
")",
"Shrink",
"{",
"if",
"condition",
"==",
"nil",
"{",
"return",
"s",
"\n",
"}",
"\n",
"return",
"func",
"(",
")",
"(",
"interface",
"{",
"}",
",",
"bool",
")",
"{",
"value",
",",
"ok",
":=",
"s",
"(",
")",
"\n",
"for",
"ok",
"&&",
"!",
"condition",
"(",
"value",
")",
"{",
"value",
",",
"ok",
"=",
"s",
"(",
")",
"\n",
"}",
"\n",
"return",
"value",
",",
"ok",
"\n",
"}",
"\n",
"}"
] |
// Filter creates a shrink filtered by a condition
|
[
"Filter",
"creates",
"a",
"shrink",
"filtered",
"by",
"a",
"condition"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/shrink.go#L19-L30
|
9,382 |
leanovate/gopter
|
shrink.go
|
All
|
func (s Shrink) All() []interface{} {
result := []interface{}{}
value, ok := s()
for ok {
result = append(result, value)
value, ok = s()
}
return result
}
|
go
|
func (s Shrink) All() []interface{} {
result := []interface{}{}
value, ok := s()
for ok {
result = append(result, value)
value, ok = s()
}
return result
}
|
[
"func",
"(",
"s",
"Shrink",
")",
"All",
"(",
")",
"[",
"]",
"interface",
"{",
"}",
"{",
"result",
":=",
"[",
"]",
"interface",
"{",
"}",
"{",
"}",
"\n",
"value",
",",
"ok",
":=",
"s",
"(",
")",
"\n",
"for",
"ok",
"{",
"result",
"=",
"append",
"(",
"result",
",",
"value",
")",
"\n",
"value",
",",
"ok",
"=",
"s",
"(",
")",
"\n",
"}",
"\n",
"return",
"result",
"\n",
"}"
] |
// All collects all shrinks as a slice. Use with care as this might create
// large results depending on the complexity of the shrink
|
[
"All",
"collects",
"all",
"shrinks",
"as",
"a",
"slice",
".",
"Use",
"with",
"care",
"as",
"this",
"might",
"create",
"large",
"results",
"depending",
"on",
"the",
"complexity",
"of",
"the",
"shrink"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/shrink.go#L59-L67
|
9,383 |
leanovate/gopter
|
shrink.go
|
ConcatShrinks
|
func ConcatShrinks(shrinks ...Shrink) Shrink {
concated := &concatedShrink{
index: 0,
shrinks: shrinks,
}
return concated.Next
}
|
go
|
func ConcatShrinks(shrinks ...Shrink) Shrink {
concated := &concatedShrink{
index: 0,
shrinks: shrinks,
}
return concated.Next
}
|
[
"func",
"ConcatShrinks",
"(",
"shrinks",
"...",
"Shrink",
")",
"Shrink",
"{",
"concated",
":=",
"&",
"concatedShrink",
"{",
"index",
":",
"0",
",",
"shrinks",
":",
"shrinks",
",",
"}",
"\n",
"return",
"concated",
".",
"Next",
"\n",
"}"
] |
// ConcatShrinks concats an array of shrinks to a single shrinks
|
[
"ConcatShrinks",
"concats",
"an",
"array",
"of",
"shrinks",
"to",
"a",
"single",
"shrinks"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/shrink.go#L86-L92
|
9,384 |
leanovate/gopter
|
shrink.go
|
Interleave
|
func (s Shrink) Interleave(other Shrink) Shrink {
interleaved := &interleaved{
first: s,
second: other,
}
return interleaved.Next
}
|
go
|
func (s Shrink) Interleave(other Shrink) Shrink {
interleaved := &interleaved{
first: s,
second: other,
}
return interleaved.Next
}
|
[
"func",
"(",
"s",
"Shrink",
")",
"Interleave",
"(",
"other",
"Shrink",
")",
"Shrink",
"{",
"interleaved",
":=",
"&",
"interleaved",
"{",
"first",
":",
"s",
",",
"second",
":",
"other",
",",
"}",
"\n",
"return",
"interleaved",
".",
"Next",
"\n",
"}"
] |
// Interleave this shrink with another
// Both shrinks are expected to produce the same result
|
[
"Interleave",
"this",
"shrink",
"with",
"another",
"Both",
"shrinks",
"are",
"expected",
"to",
"produce",
"the",
"same",
"result"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/shrink.go#L124-L130
|
9,385 |
leanovate/gopter
|
gen/strings.go
|
RuneRange
|
func RuneRange(min, max rune) gopter.Gen {
return genRune(Int64Range(int64(min), int64(max)))
}
|
go
|
func RuneRange(min, max rune) gopter.Gen {
return genRune(Int64Range(int64(min), int64(max)))
}
|
[
"func",
"RuneRange",
"(",
"min",
",",
"max",
"rune",
")",
"gopter",
".",
"Gen",
"{",
"return",
"genRune",
"(",
"Int64Range",
"(",
"int64",
"(",
"min",
")",
",",
"int64",
"(",
"max",
")",
")",
")",
"\n",
"}"
] |
// RuneRange generates runes within a given range
|
[
"RuneRange",
"generates",
"runes",
"within",
"a",
"given",
"range"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen/strings.go#L12-L14
|
9,386 |
leanovate/gopter
|
gen/strings.go
|
Rune
|
func Rune() gopter.Gen {
return genRune(Frequency(map[int]gopter.Gen{
0xD800: Int64Range(0, 0xD800),
utf8.MaxRune - 0xDFFF: Int64Range(0xDFFF, int64(utf8.MaxRune)),
}))
}
|
go
|
func Rune() gopter.Gen {
return genRune(Frequency(map[int]gopter.Gen{
0xD800: Int64Range(0, 0xD800),
utf8.MaxRune - 0xDFFF: Int64Range(0xDFFF, int64(utf8.MaxRune)),
}))
}
|
[
"func",
"Rune",
"(",
")",
"gopter",
".",
"Gen",
"{",
"return",
"genRune",
"(",
"Frequency",
"(",
"map",
"[",
"int",
"]",
"gopter",
".",
"Gen",
"{",
"0xD800",
":",
"Int64Range",
"(",
"0",
",",
"0xD800",
")",
",",
"utf8",
".",
"MaxRune",
"-",
"0xDFFF",
":",
"Int64Range",
"(",
"0xDFFF",
",",
"int64",
"(",
"utf8",
".",
"MaxRune",
")",
")",
",",
"}",
")",
")",
"\n",
"}"
] |
// Rune generates an arbitrary character rune
|
[
"Rune",
"generates",
"an",
"arbitrary",
"character",
"rune"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen/strings.go#L17-L22
|
9,387 |
leanovate/gopter
|
gen/strings.go
|
UnicodeChar
|
func UnicodeChar(table *unicode.RangeTable) gopter.Gen {
if table == nil || len(table.R16)+len(table.R32) == 0 {
return Fail(reflect.TypeOf(rune('a')))
}
return func(genParams *gopter.GenParameters) *gopter.GenResult {
tableIdx := genParams.Rng.Intn(len(table.R16) + len(table.R32))
var selectedRune rune
if tableIdx < len(table.R16) {
r := table.R16[tableIdx]
runeOffset := uint16(genParams.Rng.Int63n(int64((r.Hi-r.Lo+1)/r.Stride))) * r.Stride
selectedRune = rune(runeOffset + r.Lo)
} else {
r := table.R32[tableIdx-len(table.R16)]
runeOffset := uint32(genParams.Rng.Int63n(int64((r.Hi-r.Lo+1)/r.Stride))) * r.Stride
selectedRune = rune(runeOffset + r.Lo)
}
genResult := gopter.NewGenResult(selectedRune, gopter.NoShrinker)
genResult.Sieve = func(v interface{}) bool {
return unicode.Is(table, v.(rune))
}
return genResult
}
}
|
go
|
func UnicodeChar(table *unicode.RangeTable) gopter.Gen {
if table == nil || len(table.R16)+len(table.R32) == 0 {
return Fail(reflect.TypeOf(rune('a')))
}
return func(genParams *gopter.GenParameters) *gopter.GenResult {
tableIdx := genParams.Rng.Intn(len(table.R16) + len(table.R32))
var selectedRune rune
if tableIdx < len(table.R16) {
r := table.R16[tableIdx]
runeOffset := uint16(genParams.Rng.Int63n(int64((r.Hi-r.Lo+1)/r.Stride))) * r.Stride
selectedRune = rune(runeOffset + r.Lo)
} else {
r := table.R32[tableIdx-len(table.R16)]
runeOffset := uint32(genParams.Rng.Int63n(int64((r.Hi-r.Lo+1)/r.Stride))) * r.Stride
selectedRune = rune(runeOffset + r.Lo)
}
genResult := gopter.NewGenResult(selectedRune, gopter.NoShrinker)
genResult.Sieve = func(v interface{}) bool {
return unicode.Is(table, v.(rune))
}
return genResult
}
}
|
[
"func",
"UnicodeChar",
"(",
"table",
"*",
"unicode",
".",
"RangeTable",
")",
"gopter",
".",
"Gen",
"{",
"if",
"table",
"==",
"nil",
"||",
"len",
"(",
"table",
".",
"R16",
")",
"+",
"len",
"(",
"table",
".",
"R32",
")",
"==",
"0",
"{",
"return",
"Fail",
"(",
"reflect",
".",
"TypeOf",
"(",
"rune",
"(",
"'a'",
")",
")",
")",
"\n",
"}",
"\n",
"return",
"func",
"(",
"genParams",
"*",
"gopter",
".",
"GenParameters",
")",
"*",
"gopter",
".",
"GenResult",
"{",
"tableIdx",
":=",
"genParams",
".",
"Rng",
".",
"Intn",
"(",
"len",
"(",
"table",
".",
"R16",
")",
"+",
"len",
"(",
"table",
".",
"R32",
")",
")",
"\n\n",
"var",
"selectedRune",
"rune",
"\n",
"if",
"tableIdx",
"<",
"len",
"(",
"table",
".",
"R16",
")",
"{",
"r",
":=",
"table",
".",
"R16",
"[",
"tableIdx",
"]",
"\n",
"runeOffset",
":=",
"uint16",
"(",
"genParams",
".",
"Rng",
".",
"Int63n",
"(",
"int64",
"(",
"(",
"r",
".",
"Hi",
"-",
"r",
".",
"Lo",
"+",
"1",
")",
"/",
"r",
".",
"Stride",
")",
")",
")",
"*",
"r",
".",
"Stride",
"\n",
"selectedRune",
"=",
"rune",
"(",
"runeOffset",
"+",
"r",
".",
"Lo",
")",
"\n",
"}",
"else",
"{",
"r",
":=",
"table",
".",
"R32",
"[",
"tableIdx",
"-",
"len",
"(",
"table",
".",
"R16",
")",
"]",
"\n",
"runeOffset",
":=",
"uint32",
"(",
"genParams",
".",
"Rng",
".",
"Int63n",
"(",
"int64",
"(",
"(",
"r",
".",
"Hi",
"-",
"r",
".",
"Lo",
"+",
"1",
")",
"/",
"r",
".",
"Stride",
")",
")",
")",
"*",
"r",
".",
"Stride",
"\n",
"selectedRune",
"=",
"rune",
"(",
"runeOffset",
"+",
"r",
".",
"Lo",
")",
"\n",
"}",
"\n",
"genResult",
":=",
"gopter",
".",
"NewGenResult",
"(",
"selectedRune",
",",
"gopter",
".",
"NoShrinker",
")",
"\n",
"genResult",
".",
"Sieve",
"=",
"func",
"(",
"v",
"interface",
"{",
"}",
")",
"bool",
"{",
"return",
"unicode",
".",
"Is",
"(",
"table",
",",
"v",
".",
"(",
"rune",
")",
")",
"\n",
"}",
"\n",
"return",
"genResult",
"\n",
"}",
"\n",
"}"
] |
// UnicodeChar generates arbitrary character runes with a given unicode table
|
[
"UnicodeChar",
"generates",
"arbitrary",
"character",
"runes",
"with",
"a",
"given",
"unicode",
"table"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen/strings.go#L72-L95
|
9,388 |
leanovate/gopter
|
gen/strings.go
|
Identifier
|
func Identifier() gopter.Gen {
return gopter.CombineGens(
AlphaLowerChar(),
SliceOf(AlphaNumChar()),
).Map(func(values []interface{}) string {
first := values[0].(rune)
tail := values[1].([]rune)
result := make([]rune, 0, len(tail)+1)
return string(append(append(result, first), tail...))
}).SuchThat(func(str string) bool {
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)
}
|
go
|
func Identifier() gopter.Gen {
return gopter.CombineGens(
AlphaLowerChar(),
SliceOf(AlphaNumChar()),
).Map(func(values []interface{}) string {
first := values[0].(rune)
tail := values[1].([]rune)
result := make([]rune, 0, len(tail)+1)
return string(append(append(result, first), tail...))
}).SuchThat(func(str string) bool {
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)
}
|
[
"func",
"Identifier",
"(",
")",
"gopter",
".",
"Gen",
"{",
"return",
"gopter",
".",
"CombineGens",
"(",
"AlphaLowerChar",
"(",
")",
",",
"SliceOf",
"(",
"AlphaNumChar",
"(",
")",
")",
",",
")",
".",
"Map",
"(",
"func",
"(",
"values",
"[",
"]",
"interface",
"{",
"}",
")",
"string",
"{",
"first",
":=",
"values",
"[",
"0",
"]",
".",
"(",
"rune",
")",
"\n",
"tail",
":=",
"values",
"[",
"1",
"]",
".",
"(",
"[",
"]",
"rune",
")",
"\n",
"result",
":=",
"make",
"(",
"[",
"]",
"rune",
",",
"0",
",",
"len",
"(",
"tail",
")",
"+",
"1",
")",
"\n",
"return",
"string",
"(",
"append",
"(",
"append",
"(",
"result",
",",
"first",
")",
",",
"tail",
"...",
")",
")",
"\n",
"}",
")",
".",
"SuchThat",
"(",
"func",
"(",
"str",
"string",
")",
"bool",
"{",
"if",
"len",
"(",
"str",
")",
"<",
"1",
"||",
"!",
"unicode",
".",
"IsLower",
"(",
"(",
"[",
"]",
"rune",
"(",
"str",
")",
")",
"[",
"0",
"]",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"for",
"_",
",",
"ch",
":=",
"range",
"str",
"{",
"if",
"!",
"unicode",
".",
"IsLetter",
"(",
"ch",
")",
"&&",
"!",
"unicode",
".",
"IsDigit",
"(",
"ch",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"true",
"\n",
"}",
")",
".",
"WithShrinker",
"(",
"StringShrinker",
")",
"\n",
"}"
] |
// Identifier generates an arbitrary identifier string
// Identitiers are supporsed to start with a lowercase letter and contain only
// letters and digits
|
[
"Identifier",
"generates",
"an",
"arbitrary",
"identifier",
"string",
"Identitiers",
"are",
"supporsed",
"to",
"start",
"with",
"a",
"lowercase",
"letter",
"and",
"contain",
"only",
"letters",
"and",
"digits"
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen/strings.go#L115-L135
|
9,389 |
leanovate/gopter
|
gen/strings.go
|
UnicodeString
|
func UnicodeString(table *unicode.RangeTable) gopter.Gen {
return genString(UnicodeChar(table), func(ch rune) bool {
return unicode.Is(table, ch)
})
}
|
go
|
func UnicodeString(table *unicode.RangeTable) gopter.Gen {
return genString(UnicodeChar(table), func(ch rune) bool {
return unicode.Is(table, ch)
})
}
|
[
"func",
"UnicodeString",
"(",
"table",
"*",
"unicode",
".",
"RangeTable",
")",
"gopter",
".",
"Gen",
"{",
"return",
"genString",
"(",
"UnicodeChar",
"(",
"table",
")",
",",
"func",
"(",
"ch",
"rune",
")",
"bool",
"{",
"return",
"unicode",
".",
"Is",
"(",
"table",
",",
"ch",
")",
"\n",
"}",
")",
"\n",
"}"
] |
// UnicodeString generates an arbitrary string from a given
// unicode table.
|
[
"UnicodeString",
"generates",
"an",
"arbitrary",
"string",
"from",
"a",
"given",
"unicode",
"table",
"."
] |
634a59d12406abc51545000deab7cf43ebc32378
|
https://github.com/leanovate/gopter/blob/634a59d12406abc51545000deab7cf43ebc32378/gen/strings.go#L139-L143
|
9,390 |
hyperhq/runv
|
hypervisor/network/network_linux.go
|
addToBridge
|
func addToBridge(iface, master netlink.Link, options string) error {
switch master.Type() {
case "openvswitch":
return addToOpenvswitchBridge(iface, master, options)
case "bridge":
return netlink.LinkSetMaster(iface, master.(*netlink.Bridge))
default:
return fmt.Errorf("unknown link type:%+v", master.Type())
}
}
|
go
|
func addToBridge(iface, master netlink.Link, options string) error {
switch master.Type() {
case "openvswitch":
return addToOpenvswitchBridge(iface, master, options)
case "bridge":
return netlink.LinkSetMaster(iface, master.(*netlink.Bridge))
default:
return fmt.Errorf("unknown link type:%+v", master.Type())
}
}
|
[
"func",
"addToBridge",
"(",
"iface",
",",
"master",
"netlink",
".",
"Link",
",",
"options",
"string",
")",
"error",
"{",
"switch",
"master",
".",
"Type",
"(",
")",
"{",
"case",
"\"",
"\"",
":",
"return",
"addToOpenvswitchBridge",
"(",
"iface",
",",
"master",
",",
"options",
")",
"\n",
"case",
"\"",
"\"",
":",
"return",
"netlink",
".",
"LinkSetMaster",
"(",
"iface",
",",
"master",
".",
"(",
"*",
"netlink",
".",
"Bridge",
")",
")",
"\n",
"default",
":",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"master",
".",
"Type",
"(",
")",
")",
"\n",
"}",
"\n",
"}"
] |
// addToBridge attch interface to the bridge,
// we only support ovs bridge and linux bridge at present.
|
[
"addToBridge",
"attch",
"interface",
"to",
"the",
"bridge",
"we",
"only",
"support",
"ovs",
"bridge",
"and",
"linux",
"bridge",
"at",
"present",
"."
] |
10eb6877d5df825f4438f69864a9256f9694741d
|
https://github.com/hyperhq/runv/blob/10eb6877d5df825f4438f69864a9256f9694741d/hypervisor/network/network_linux.go#L152-L161
|
9,391 |
hyperhq/runv
|
hypervisor/events.go
|
ResultId
|
func (df *DeviceFailed) ResultId() string {
switch s := df.Session.(type) {
case *InterfaceCreated:
return s.Id
case *NetDevInsertedEvent:
return s.Id
default:
return ""
}
}
|
go
|
func (df *DeviceFailed) ResultId() string {
switch s := df.Session.(type) {
case *InterfaceCreated:
return s.Id
case *NetDevInsertedEvent:
return s.Id
default:
return ""
}
}
|
[
"func",
"(",
"df",
"*",
"DeviceFailed",
")",
"ResultId",
"(",
")",
"string",
"{",
"switch",
"s",
":=",
"df",
".",
"Session",
".",
"(",
"type",
")",
"{",
"case",
"*",
"InterfaceCreated",
":",
"return",
"s",
".",
"Id",
"\n",
"case",
"*",
"NetDevInsertedEvent",
":",
"return",
"s",
".",
"Id",
"\n",
"default",
":",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"}"
] |
//Device Failed as api.Result
|
[
"Device",
"Failed",
"as",
"api",
".",
"Result"
] |
10eb6877d5df825f4438f69864a9256f9694741d
|
https://github.com/hyperhq/runv/blob/10eb6877d5df825f4438f69864a9256f9694741d/hypervisor/events.go#L88-L97
|
9,392 |
hyperhq/runv
|
lib/runvxenlight/xenlight.go
|
toC
|
func (gbm Bitmap) toC() (cbm C.libxl_bitmap) {
C.libxl_bitmap_init(&cbm)
size := len(gbm.bitmap)
cbm._map = (*C.uint8_t)(C.malloc(C.size_t(size)))
cbm.size = C.uint32_t(size)
if cbm._map == nil {
panic("C.calloc failed!")
}
// Make a slice pointing to the C array
mapslice := (*[1 << 30]C.uint8_t)(unsafe.Pointer(cbm._map))[:size:size]
// And copy the Go array into the C array
copy(mapslice, gbm.bitmap)
return
}
|
go
|
func (gbm Bitmap) toC() (cbm C.libxl_bitmap) {
C.libxl_bitmap_init(&cbm)
size := len(gbm.bitmap)
cbm._map = (*C.uint8_t)(C.malloc(C.size_t(size)))
cbm.size = C.uint32_t(size)
if cbm._map == nil {
panic("C.calloc failed!")
}
// Make a slice pointing to the C array
mapslice := (*[1 << 30]C.uint8_t)(unsafe.Pointer(cbm._map))[:size:size]
// And copy the Go array into the C array
copy(mapslice, gbm.bitmap)
return
}
|
[
"func",
"(",
"gbm",
"Bitmap",
")",
"toC",
"(",
")",
"(",
"cbm",
"C",
".",
"libxl_bitmap",
")",
"{",
"C",
".",
"libxl_bitmap_init",
"(",
"&",
"cbm",
")",
"\n\n",
"size",
":=",
"len",
"(",
"gbm",
".",
"bitmap",
")",
"\n",
"cbm",
".",
"_map",
"=",
"(",
"*",
"C",
".",
"uint8_t",
")",
"(",
"C",
".",
"malloc",
"(",
"C",
".",
"size_t",
"(",
"size",
")",
")",
")",
"\n",
"cbm",
".",
"size",
"=",
"C",
".",
"uint32_t",
"(",
"size",
")",
"\n",
"if",
"cbm",
".",
"_map",
"==",
"nil",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Make a slice pointing to the C array",
"mapslice",
":=",
"(",
"*",
"[",
"1",
"<<",
"30",
"]",
"C",
".",
"uint8_t",
")",
"(",
"unsafe",
".",
"Pointer",
"(",
"cbm",
".",
"_map",
")",
")",
"[",
":",
"size",
":",
"size",
"]",
"\n\n",
"// And copy the Go array into the C array",
"copy",
"(",
"mapslice",
",",
"gbm",
".",
"bitmap",
")",
"\n\n",
"return",
"\n",
"}"
] |
// Must be C.libxl_bitmap_dispose'd of afterwards
|
[
"Must",
"be",
"C",
".",
"libxl_bitmap_dispose",
"d",
"of",
"afterwards"
] |
10eb6877d5df825f4438f69864a9256f9694741d
|
https://github.com/hyperhq/runv/blob/10eb6877d5df825f4438f69864a9256f9694741d/lib/runvxenlight/xenlight.go#L705-L722
|
9,393 |
hyperhq/runv
|
agent/kata.go
|
NewKataAgent
|
func NewKataAgent(kataAgentSock string) (SandboxAgent, error) {
grpclog.SetLogger(log.New(ioutil.Discard, "", log.LstdFlags))
dialOpts := []grpc.DialOption{grpc.WithInsecure(), grpc.WithTimeout(5 * time.Second)}
dialOpts = append(dialOpts,
grpc.WithDialer(func(addr string, timeout time.Duration) (net.Conn, error) {
return net.DialTimeout("unix", addr, timeout)
},
))
conn, err := grpc.Dial(kataAgentSock, dialOpts...)
if err != nil {
return nil, err
}
return &kataAgent{
conn: conn,
agent: kagenta.NewAgentServiceClient(conn),
}, nil
}
|
go
|
func NewKataAgent(kataAgentSock string) (SandboxAgent, error) {
grpclog.SetLogger(log.New(ioutil.Discard, "", log.LstdFlags))
dialOpts := []grpc.DialOption{grpc.WithInsecure(), grpc.WithTimeout(5 * time.Second)}
dialOpts = append(dialOpts,
grpc.WithDialer(func(addr string, timeout time.Duration) (net.Conn, error) {
return net.DialTimeout("unix", addr, timeout)
},
))
conn, err := grpc.Dial(kataAgentSock, dialOpts...)
if err != nil {
return nil, err
}
return &kataAgent{
conn: conn,
agent: kagenta.NewAgentServiceClient(conn),
}, nil
}
|
[
"func",
"NewKataAgent",
"(",
"kataAgentSock",
"string",
")",
"(",
"SandboxAgent",
",",
"error",
")",
"{",
"grpclog",
".",
"SetLogger",
"(",
"log",
".",
"New",
"(",
"ioutil",
".",
"Discard",
",",
"\"",
"\"",
",",
"log",
".",
"LstdFlags",
")",
")",
"\n",
"dialOpts",
":=",
"[",
"]",
"grpc",
".",
"DialOption",
"{",
"grpc",
".",
"WithInsecure",
"(",
")",
",",
"grpc",
".",
"WithTimeout",
"(",
"5",
"*",
"time",
".",
"Second",
")",
"}",
"\n",
"dialOpts",
"=",
"append",
"(",
"dialOpts",
",",
"grpc",
".",
"WithDialer",
"(",
"func",
"(",
"addr",
"string",
",",
"timeout",
"time",
".",
"Duration",
")",
"(",
"net",
".",
"Conn",
",",
"error",
")",
"{",
"return",
"net",
".",
"DialTimeout",
"(",
"\"",
"\"",
",",
"addr",
",",
"timeout",
")",
"\n",
"}",
",",
")",
")",
"\n",
"conn",
",",
"err",
":=",
"grpc",
".",
"Dial",
"(",
"kataAgentSock",
",",
"dialOpts",
"...",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"kataAgent",
"{",
"conn",
":",
"conn",
",",
"agent",
":",
"kagenta",
".",
"NewAgentServiceClient",
"(",
"conn",
")",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// NewKataAgent create a SandboxAgent with kata protocol
|
[
"NewKataAgent",
"create",
"a",
"SandboxAgent",
"with",
"kata",
"protocol"
] |
10eb6877d5df825f4438f69864a9256f9694741d
|
https://github.com/hyperhq/runv/blob/10eb6877d5df825f4438f69864a9256f9694741d/agent/kata.go#L27-L43
|
9,394 |
hyperhq/runv
|
hypervisor/network/ipallocator/ipallocator.go
|
RegisterSubnet
|
func (a *IPAllocator) RegisterSubnet(network *net.IPNet, subnet *net.IPNet) error {
a.mutex.Lock()
defer a.mutex.Unlock()
key := network.String()
if _, ok := a.allocatedIPs[key]; ok {
return ErrNetworkAlreadyRegistered
}
n := newAllocatedMap(network)
beginIP, endIP := NetworkRange(subnet)
begin := big.NewInt(0).Add(ipToBigInt(beginIP), big.NewInt(1))
end := big.NewInt(0).Sub(ipToBigInt(endIP), big.NewInt(1))
// Check that subnet is within network
if !(begin.Cmp(n.begin) >= 0 && end.Cmp(n.end) <= 0 && begin.Cmp(end) == -1) {
return ErrBadSubnet
}
n.begin.Set(begin)
n.end.Set(end)
n.last.Sub(begin, big.NewInt(1))
a.allocatedIPs[key] = n
return nil
}
|
go
|
func (a *IPAllocator) RegisterSubnet(network *net.IPNet, subnet *net.IPNet) error {
a.mutex.Lock()
defer a.mutex.Unlock()
key := network.String()
if _, ok := a.allocatedIPs[key]; ok {
return ErrNetworkAlreadyRegistered
}
n := newAllocatedMap(network)
beginIP, endIP := NetworkRange(subnet)
begin := big.NewInt(0).Add(ipToBigInt(beginIP), big.NewInt(1))
end := big.NewInt(0).Sub(ipToBigInt(endIP), big.NewInt(1))
// Check that subnet is within network
if !(begin.Cmp(n.begin) >= 0 && end.Cmp(n.end) <= 0 && begin.Cmp(end) == -1) {
return ErrBadSubnet
}
n.begin.Set(begin)
n.end.Set(end)
n.last.Sub(begin, big.NewInt(1))
a.allocatedIPs[key] = n
return nil
}
|
[
"func",
"(",
"a",
"*",
"IPAllocator",
")",
"RegisterSubnet",
"(",
"network",
"*",
"net",
".",
"IPNet",
",",
"subnet",
"*",
"net",
".",
"IPNet",
")",
"error",
"{",
"a",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"a",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"key",
":=",
"network",
".",
"String",
"(",
")",
"\n",
"if",
"_",
",",
"ok",
":=",
"a",
".",
"allocatedIPs",
"[",
"key",
"]",
";",
"ok",
"{",
"return",
"ErrNetworkAlreadyRegistered",
"\n",
"}",
"\n",
"n",
":=",
"newAllocatedMap",
"(",
"network",
")",
"\n",
"beginIP",
",",
"endIP",
":=",
"NetworkRange",
"(",
"subnet",
")",
"\n",
"begin",
":=",
"big",
".",
"NewInt",
"(",
"0",
")",
".",
"Add",
"(",
"ipToBigInt",
"(",
"beginIP",
")",
",",
"big",
".",
"NewInt",
"(",
"1",
")",
")",
"\n",
"end",
":=",
"big",
".",
"NewInt",
"(",
"0",
")",
".",
"Sub",
"(",
"ipToBigInt",
"(",
"endIP",
")",
",",
"big",
".",
"NewInt",
"(",
"1",
")",
")",
"\n\n",
"// Check that subnet is within network",
"if",
"!",
"(",
"begin",
".",
"Cmp",
"(",
"n",
".",
"begin",
")",
">=",
"0",
"&&",
"end",
".",
"Cmp",
"(",
"n",
".",
"end",
")",
"<=",
"0",
"&&",
"begin",
".",
"Cmp",
"(",
"end",
")",
"==",
"-",
"1",
")",
"{",
"return",
"ErrBadSubnet",
"\n",
"}",
"\n",
"n",
".",
"begin",
".",
"Set",
"(",
"begin",
")",
"\n",
"n",
".",
"end",
".",
"Set",
"(",
"end",
")",
"\n",
"n",
".",
"last",
".",
"Sub",
"(",
"begin",
",",
"big",
".",
"NewInt",
"(",
"1",
")",
")",
"\n",
"a",
".",
"allocatedIPs",
"[",
"key",
"]",
"=",
"n",
"\n",
"return",
"nil",
"\n",
"}"
] |
// RegisterSubnet registers network in global allocator with bounds
// defined by subnet. If you want to use network range you must call
// this method before first RequestIP, otherwise full network range will be used
|
[
"RegisterSubnet",
"registers",
"network",
"in",
"global",
"allocator",
"with",
"bounds",
"defined",
"by",
"subnet",
".",
"If",
"you",
"want",
"to",
"use",
"network",
"range",
"you",
"must",
"call",
"this",
"method",
"before",
"first",
"RequestIP",
"otherwise",
"full",
"network",
"range",
"will",
"be",
"used"
] |
10eb6877d5df825f4438f69864a9256f9694741d
|
https://github.com/hyperhq/runv/blob/10eb6877d5df825f4438f69864a9256f9694741d/hypervisor/network/ipallocator/ipallocator.go#L72-L94
|
9,395 |
hyperhq/runv
|
hypervisor/network/ipallocator/ipallocator.go
|
RequestIP
|
func (a *IPAllocator) RequestIP(network *net.IPNet, ip net.IP) (net.IP, error) {
if network == nil {
return nil, ErrBadSubnet
}
a.mutex.Lock()
defer a.mutex.Unlock()
key := network.String()
allocated, ok := a.allocatedIPs[key]
if !ok {
allocated = newAllocatedMap(network)
a.allocatedIPs[key] = allocated
}
if ip == nil {
return allocated.getNextIP()
}
return allocated.checkIP(ip)
}
|
go
|
func (a *IPAllocator) RequestIP(network *net.IPNet, ip net.IP) (net.IP, error) {
if network == nil {
return nil, ErrBadSubnet
}
a.mutex.Lock()
defer a.mutex.Unlock()
key := network.String()
allocated, ok := a.allocatedIPs[key]
if !ok {
allocated = newAllocatedMap(network)
a.allocatedIPs[key] = allocated
}
if ip == nil {
return allocated.getNextIP()
}
return allocated.checkIP(ip)
}
|
[
"func",
"(",
"a",
"*",
"IPAllocator",
")",
"RequestIP",
"(",
"network",
"*",
"net",
".",
"IPNet",
",",
"ip",
"net",
".",
"IP",
")",
"(",
"net",
".",
"IP",
",",
"error",
")",
"{",
"if",
"network",
"==",
"nil",
"{",
"return",
"nil",
",",
"ErrBadSubnet",
"\n",
"}",
"\n\n",
"a",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"a",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"key",
":=",
"network",
".",
"String",
"(",
")",
"\n",
"allocated",
",",
"ok",
":=",
"a",
".",
"allocatedIPs",
"[",
"key",
"]",
"\n",
"if",
"!",
"ok",
"{",
"allocated",
"=",
"newAllocatedMap",
"(",
"network",
")",
"\n",
"a",
".",
"allocatedIPs",
"[",
"key",
"]",
"=",
"allocated",
"\n",
"}",
"\n\n",
"if",
"ip",
"==",
"nil",
"{",
"return",
"allocated",
".",
"getNextIP",
"(",
")",
"\n",
"}",
"\n",
"return",
"allocated",
".",
"checkIP",
"(",
"ip",
")",
"\n",
"}"
] |
// RequestIP requests an available ip from the given network. It
// will return the next available ip if the ip provided is nil. If the
// ip provided is not nil it will validate that the provided ip is available
// for use or return an error
|
[
"RequestIP",
"requests",
"an",
"available",
"ip",
"from",
"the",
"given",
"network",
".",
"It",
"will",
"return",
"the",
"next",
"available",
"ip",
"if",
"the",
"ip",
"provided",
"is",
"nil",
".",
"If",
"the",
"ip",
"provided",
"is",
"not",
"nil",
"it",
"will",
"validate",
"that",
"the",
"provided",
"ip",
"is",
"available",
"for",
"use",
"or",
"return",
"an",
"error"
] |
10eb6877d5df825f4438f69864a9256f9694741d
|
https://github.com/hyperhq/runv/blob/10eb6877d5df825f4438f69864a9256f9694741d/hypervisor/network/ipallocator/ipallocator.go#L100-L119
|
9,396 |
hyperhq/runv
|
hypervisor/network/ipallocator/ipallocator.go
|
ReleaseIP
|
func (a *IPAllocator) ReleaseIP(network *net.IPNet, ip net.IP) error {
if network == nil {
return nil
}
a.mutex.Lock()
defer a.mutex.Unlock()
if allocated, exists := a.allocatedIPs[network.String()]; exists {
delete(allocated.p, ip.String())
}
return nil
}
|
go
|
func (a *IPAllocator) ReleaseIP(network *net.IPNet, ip net.IP) error {
if network == nil {
return nil
}
a.mutex.Lock()
defer a.mutex.Unlock()
if allocated, exists := a.allocatedIPs[network.String()]; exists {
delete(allocated.p, ip.String())
}
return nil
}
|
[
"func",
"(",
"a",
"*",
"IPAllocator",
")",
"ReleaseIP",
"(",
"network",
"*",
"net",
".",
"IPNet",
",",
"ip",
"net",
".",
"IP",
")",
"error",
"{",
"if",
"network",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"a",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"a",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"allocated",
",",
"exists",
":=",
"a",
".",
"allocatedIPs",
"[",
"network",
".",
"String",
"(",
")",
"]",
";",
"exists",
"{",
"delete",
"(",
"allocated",
".",
"p",
",",
"ip",
".",
"String",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// ReleaseIP adds the provided ip back into the pool of
// available ips to be returned for use.
|
[
"ReleaseIP",
"adds",
"the",
"provided",
"ip",
"back",
"into",
"the",
"pool",
"of",
"available",
"ips",
"to",
"be",
"returned",
"for",
"use",
"."
] |
10eb6877d5df825f4438f69864a9256f9694741d
|
https://github.com/hyperhq/runv/blob/10eb6877d5df825f4438f69864a9256f9694741d/hypervisor/network/ipallocator/ipallocator.go#L123-L135
|
9,397 |
hyperhq/runv
|
hypervisor/network/ipallocator/ipallocator.go
|
getNextIP
|
func (allocated *allocatedMap) getNextIP() (net.IP, error) {
pos := big.NewInt(0).Set(allocated.last)
allRange := big.NewInt(0).Sub(allocated.end, allocated.begin)
for i := big.NewInt(0); i.Cmp(allRange) <= 0; i.Add(i, big.NewInt(1)) {
pos.Add(pos, big.NewInt(1))
if pos.Cmp(allocated.end) == 1 {
pos.Set(allocated.begin)
}
if _, ok := allocated.p[bigIntToIP(pos).String()]; ok {
continue
}
allocated.p[bigIntToIP(pos).String()] = struct{}{}
allocated.last.Set(pos)
return bigIntToIP(pos), nil
}
return nil, ErrNoAvailableIPs
}
|
go
|
func (allocated *allocatedMap) getNextIP() (net.IP, error) {
pos := big.NewInt(0).Set(allocated.last)
allRange := big.NewInt(0).Sub(allocated.end, allocated.begin)
for i := big.NewInt(0); i.Cmp(allRange) <= 0; i.Add(i, big.NewInt(1)) {
pos.Add(pos, big.NewInt(1))
if pos.Cmp(allocated.end) == 1 {
pos.Set(allocated.begin)
}
if _, ok := allocated.p[bigIntToIP(pos).String()]; ok {
continue
}
allocated.p[bigIntToIP(pos).String()] = struct{}{}
allocated.last.Set(pos)
return bigIntToIP(pos), nil
}
return nil, ErrNoAvailableIPs
}
|
[
"func",
"(",
"allocated",
"*",
"allocatedMap",
")",
"getNextIP",
"(",
")",
"(",
"net",
".",
"IP",
",",
"error",
")",
"{",
"pos",
":=",
"big",
".",
"NewInt",
"(",
"0",
")",
".",
"Set",
"(",
"allocated",
".",
"last",
")",
"\n",
"allRange",
":=",
"big",
".",
"NewInt",
"(",
"0",
")",
".",
"Sub",
"(",
"allocated",
".",
"end",
",",
"allocated",
".",
"begin",
")",
"\n",
"for",
"i",
":=",
"big",
".",
"NewInt",
"(",
"0",
")",
";",
"i",
".",
"Cmp",
"(",
"allRange",
")",
"<=",
"0",
";",
"i",
".",
"Add",
"(",
"i",
",",
"big",
".",
"NewInt",
"(",
"1",
")",
")",
"{",
"pos",
".",
"Add",
"(",
"pos",
",",
"big",
".",
"NewInt",
"(",
"1",
")",
")",
"\n",
"if",
"pos",
".",
"Cmp",
"(",
"allocated",
".",
"end",
")",
"==",
"1",
"{",
"pos",
".",
"Set",
"(",
"allocated",
".",
"begin",
")",
"\n",
"}",
"\n",
"if",
"_",
",",
"ok",
":=",
"allocated",
".",
"p",
"[",
"bigIntToIP",
"(",
"pos",
")",
".",
"String",
"(",
")",
"]",
";",
"ok",
"{",
"continue",
"\n",
"}",
"\n",
"allocated",
".",
"p",
"[",
"bigIntToIP",
"(",
"pos",
")",
".",
"String",
"(",
")",
"]",
"=",
"struct",
"{",
"}",
"{",
"}",
"\n",
"allocated",
".",
"last",
".",
"Set",
"(",
"pos",
")",
"\n",
"return",
"bigIntToIP",
"(",
"pos",
")",
",",
"nil",
"\n",
"}",
"\n",
"return",
"nil",
",",
"ErrNoAvailableIPs",
"\n",
"}"
] |
// return an available ip if one is currently available. If not,
// return the next available ip for the network
|
[
"return",
"an",
"available",
"ip",
"if",
"one",
"is",
"currently",
"available",
".",
"If",
"not",
"return",
"the",
"next",
"available",
"ip",
"for",
"the",
"network"
] |
10eb6877d5df825f4438f69864a9256f9694741d
|
https://github.com/hyperhq/runv/blob/10eb6877d5df825f4438f69864a9256f9694741d/hypervisor/network/ipallocator/ipallocator.go#L156-L172
|
9,398 |
hyperhq/runv
|
hypervisor/network/ipallocator/ipallocator.go
|
ipToBigInt
|
func ipToBigInt(ip net.IP) *big.Int {
x := big.NewInt(0)
if ip4 := ip.To4(); ip4 != nil {
return x.SetBytes(ip4)
}
if ip6 := ip.To16(); ip6 != nil {
return x.SetBytes(ip6)
}
return nil
}
|
go
|
func ipToBigInt(ip net.IP) *big.Int {
x := big.NewInt(0)
if ip4 := ip.To4(); ip4 != nil {
return x.SetBytes(ip4)
}
if ip6 := ip.To16(); ip6 != nil {
return x.SetBytes(ip6)
}
return nil
}
|
[
"func",
"ipToBigInt",
"(",
"ip",
"net",
".",
"IP",
")",
"*",
"big",
".",
"Int",
"{",
"x",
":=",
"big",
".",
"NewInt",
"(",
"0",
")",
"\n",
"if",
"ip4",
":=",
"ip",
".",
"To4",
"(",
")",
";",
"ip4",
"!=",
"nil",
"{",
"return",
"x",
".",
"SetBytes",
"(",
"ip4",
")",
"\n",
"}",
"\n",
"if",
"ip6",
":=",
"ip",
".",
"To16",
"(",
")",
";",
"ip6",
"!=",
"nil",
"{",
"return",
"x",
".",
"SetBytes",
"(",
"ip6",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// Converts a 4 bytes IP into a 128 bit integer
|
[
"Converts",
"a",
"4",
"bytes",
"IP",
"into",
"a",
"128",
"bit",
"integer"
] |
10eb6877d5df825f4438f69864a9256f9694741d
|
https://github.com/hyperhq/runv/blob/10eb6877d5df825f4438f69864a9256f9694741d/hypervisor/network/ipallocator/ipallocator.go#L175-L185
|
9,399 |
hyperhq/runv
|
hypervisor/network/ipallocator/ipallocator.go
|
bigIntToIP
|
func bigIntToIP(v *big.Int) net.IP {
return net.IP(v.Bytes())
}
|
go
|
func bigIntToIP(v *big.Int) net.IP {
return net.IP(v.Bytes())
}
|
[
"func",
"bigIntToIP",
"(",
"v",
"*",
"big",
".",
"Int",
")",
"net",
".",
"IP",
"{",
"return",
"net",
".",
"IP",
"(",
"v",
".",
"Bytes",
"(",
")",
")",
"\n",
"}"
] |
// Converts 128 bit integer into a 4 bytes IP address
|
[
"Converts",
"128",
"bit",
"integer",
"into",
"a",
"4",
"bytes",
"IP",
"address"
] |
10eb6877d5df825f4438f69864a9256f9694741d
|
https://github.com/hyperhq/runv/blob/10eb6877d5df825f4438f69864a9256f9694741d/hypervisor/network/ipallocator/ipallocator.go#L188-L190
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.