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",
"(",
")",
")",
"... | // 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... | // 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",
"... | // 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",
")",
",",... | // 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",
"... | // 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",
")",
",",
")",
... | // 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",
":",
... | // 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",
... | // 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",
"=",
... | // 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",
"==",
... | // 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",
"{",
"resu... | // 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",
"(",
"typeOverride... | // 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"... | // 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",... | 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",
".",
"El... | // 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",
".",
"P... | 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",
... | // 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",
"("... | // 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",
".",
"... | // 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",
"}",
",",
"Ar... | // 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",
... | // 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",
"... | // 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",
... | // 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",
".",
... | // 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",
")"... | // 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",... | 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",
"(",... | // 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",
... | 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",
... | // 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",
... | // 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",
"re... | // 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",
":=",
"co... | // 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",
"(",
")",
")",... | // 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",
... | // 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",
"[",
"r... | // 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",
"{",
"}",
")",
"complex1... | // 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... | // 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",
"... | // 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",
... | 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"... | // 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",... | 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",
".",... | // 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... | 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",
"==",
"ma... | // 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",
"... | // 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",
"(",
"Int32Shrin... | // 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",
"(",
"UInt... | // 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",
"(",
"Int16Shrin... | // 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",
"(",
"UInt... | // 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"... | // 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",
"(",
"UInt8Sh... | // 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",... | // 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",
"(",
"UIntSh... | // 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",
",",
"IntS... | // 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... | // 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",... | 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",
")",
",",
"}",
"... | // 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",
"retur... | // 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",
".",
"Nanoseco... | // 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",
".",
"Int... | // 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",
",",
"go... | // 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",
... | // 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",... | // 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",
")",
",",
... | // 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",
"{... | // 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",
"{",
... | // 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",
"(",
")",... | // 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",
"!... | // 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",
... | // 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",
... | // 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",
... | // 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",... | // 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",
"... | // 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",
"{"... | // 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",... | // 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... | // 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",
"... | // 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",
"[",
"]",
"inter... | // 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",
"(... | // 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",
",",
"mast... | // 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",
"*",
"NetDevInserte... | //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",
"=",
... | // 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",... | // 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",
".",
"U... | // 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",
... | 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",
",",
"ErrBadSub... | // 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",
... | 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... | // 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",
":=",
"b... | // 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",
".",
"Set... | // 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.