_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q9300 | NextInt64 | train | func (p *GenParameters) NextInt64() int64 {
v := p.Rng.Int63()
if p.NextBool() {
return -v
}
return v
} | go | {
"resource": ""
} |
q9301 | NextUint64 | train | func (p *GenParameters) NextUint64() uint64 {
first := uint64(p.Rng.Int63())
second := uint64(p.Rng.Int63())
return (first << 1) ^ second
} | go | {
"resource": ""
} |
q9302 | DefaultGenParameters | train | func DefaultGenParameters() *GenParameters {
seed := time.Now().UnixNano()
return &GenParameters{
MinSize: 0,
MaxSize: 100,
MaxShrinkCount: 1000,
Rng: rand.New(NewLockedSource(seed)),
}
} | go | {
"resource": ""
} |
q9303 | Float64Range | train | 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 | {
"resource": ""
} |
q9304 | Float64 | train | 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 | {
"resource": ""
} |
q9305 | Float32Range | train | 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 | {
"resource": ""
} |
q9306 | Float32 | train | 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 | {
"resource": ""
} |
q9307 | StringShrinker | train | func StringShrinker(v interface{}) gopter.Shrink {
return runeSliceShrinker([]rune(v.(string))).Map(runesToString)
} | go | {
"resource": ""
} |
q9308 | NewProperties | train | 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 | {
"resource": ""
} |
q9309 | Run | train | 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 | {
"resource": ""
} |
q9310 | WithLabel | train | func (g Gen) WithLabel(label string) Gen {
return func(genParams *GenParameters) *GenResult {
result := g(genParams)
result.Labels = append(result.Labels, label)
return result
}
} | go | {
"resource": ""
} |
q9311 | WithShrinker | train | 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 | {
"resource": ""
} |
q9312 | FlatMap | train | 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 | {
"resource": ""
} |
q9313 | SliceOfN | train | 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 | {
"resource": ""
} |
q9314 | Struct | train | 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 | {
"resource": ""
} |
q9315 | StructPtr | train | 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 | {
"resource": ""
} |
q9316 | MapShrinker | train | 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 | {
"resource": ""
} |
q9317 | RegexMatch | train | 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 | {
"resource": ""
} |
q9318 | PtrShrinker | train | 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 | {
"resource": ""
} |
q9319 | NewPropResult | train | 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 | {
"resource": ""
} |
q9320 | Success | train | func (r *PropResult) Success() bool {
return r.Status == PropTrue || r.Status == PropProof
} | go | {
"resource": ""
} |
q9321 | WithArgs | train | func (r *PropResult) WithArgs(args []*PropArg) *PropResult {
r.Args = args
return r
} | go | {
"resource": ""
} |
q9322 | AddArgs | train | func (r *PropResult) AddArgs(args ...*PropArg) *PropResult {
r.Args = append(r.Args, args...)
return r
} | go | {
"resource": ""
} |
q9323 | And | train | 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 | {
"resource": ""
} |
q9324 | NewLockedSource | train | func NewLockedSource(seed int64) *lockedSource {
return &lockedSource{
src: rand.NewSource(seed).(rand.Source64),
}
} | go | {
"resource": ""
} |
q9325 | seedPos | train | func (r *lockedSource) seedPos(seed int64, readPos *int8) {
r.lk.Lock()
r.src.Seed(seed)
*readPos = 0
r.lk.Unlock()
} | go | {
"resource": ""
} |
q9326 | read | train | 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 | {
"resource": ""
} |
q9327 | NewPropArg | train | func NewPropArg(genResult *GenResult, shrinks int, value, origValue interface{}) *PropArg {
return &PropArg{
Label: strings.Join(genResult.Labels, ", "),
Arg: value,
OrigArg: origValue,
Shrinks: shrinks,
}
} | go | {
"resource": ""
} |
q9328 | SliceShrinkerOne | train | 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 | {
"resource": ""
} |
q9329 | ForAllNoShrink1 | train | 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 | {
"resource": ""
} |
q9330 | GenCommand | train | 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 | {
"resource": ""
} |
q9331 | GenInitialState | train | func (p *ProtoCommands) GenInitialState() gopter.Gen {
return p.InitialStateGen.SuchThat(func(state State) bool {
return p.InitialPreCondition(state)
})
} | go | {
"resource": ""
} |
q9332 | InitialPreCondition | train | func (p *ProtoCommands) InitialPreCondition(state State) bool {
if p.InitialPreConditionFunc != nil {
return p.InitialPreConditionFunc(state)
}
return true
} | go | {
"resource": ""
} |
q9333 | Prop | train | 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 | {
"resource": ""
} |
q9334 | DefaultArbitraries | train | func DefaultArbitraries() *Arbitraries {
return &Arbitraries{
generators: map[reflect.Type]gopter.Gen{
reflect.TypeOf(time.Now()): gen.Time(),
},
}
} | go | {
"resource": ""
} |
q9335 | GenForType | train | func (a *Arbitraries) GenForType(rt reflect.Type) gopter.Gen {
if gen, ok := a.generators[rt]; ok {
return gen
}
return a.genForKind(rt)
} | go | {
"resource": ""
} |
q9336 | RegisterGen | train | func (a *Arbitraries) RegisterGen(gen gopter.Gen) {
result := gen(gopter.MinGenParams)
rt := result.ResultType
a.generators[rt] = gen
} | go | {
"resource": ""
} |
q9337 | Complex128 | train | 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 | {
"resource": ""
} |
q9338 | Complex64 | train | 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 | {
"resource": ""
} |
q9339 | Sized | train | 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 | {
"resource": ""
} |
q9340 | Retrieve | train | 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 | {
"resource": ""
} |
q9341 | RetrieveAsValue | train | 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 | {
"resource": ""
} |
q9342 | Int64Range | train | 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 | {
"resource": ""
} |
q9343 | UInt64Range | train | 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 | {
"resource": ""
} |
q9344 | Int32Range | train | 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 | {
"resource": ""
} |
q9345 | UInt32Range | train | 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 | {
"resource": ""
} |
q9346 | Int16Range | train | 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 | {
"resource": ""
} |
q9347 | UInt16Range | train | 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 | {
"resource": ""
} |
q9348 | Int8Range | train | 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 | {
"resource": ""
} |
q9349 | UInt8Range | train | 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 | {
"resource": ""
} |
q9350 | IntRange | train | 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 | {
"resource": ""
} |
q9351 | Int | train | func Int() gopter.Gen {
return Int64Range(math.MinInt32, math.MaxInt32).
Map(int64ToInt).
WithShrinker(IntShrinker)
} | go | {
"resource": ""
} |
q9352 | UIntRange | train | 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 | {
"resource": ""
} |
q9353 | UInt | train | func UInt() gopter.Gen {
return UInt64Range(0, math.MaxUint32).
Map(uint64ToUint).
WithShrinker(UIntShrinker)
} | go | {
"resource": ""
} |
q9354 | Size | train | func Size() gopter.Gen {
return func(genParams *gopter.GenParameters) *gopter.GenResult {
return gopter.NewGenResult(genParams.MaxSize, IntShrinker)
}
} | go | {
"resource": ""
} |
q9355 | NewFormatedReporter | train | func NewFormatedReporter(verbose bool, width int, output io.Writer) Reporter {
return &FormatedReporter{
verbose: verbose,
width: width,
output: output,
}
} | go | {
"resource": ""
} |
q9356 | Int64Shrinker | train | 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 | {
"resource": ""
} |
q9357 | UInt64Shrinker | train | func UInt64Shrinker(v interface{}) gopter.Shrink {
shrink := uint64Shrink{
original: v.(uint64),
half: v.(uint64),
}
return shrink.Next
} | go | {
"resource": ""
} |
q9358 | Int32Shrinker | train | func Int32Shrinker(v interface{}) gopter.Shrink {
return Int64Shrinker(int64(v.(int32))).Map(int64To32)
} | go | {
"resource": ""
} |
q9359 | UInt32Shrinker | train | func UInt32Shrinker(v interface{}) gopter.Shrink {
return UInt64Shrinker(uint64(v.(uint32))).Map(uint64To32)
} | go | {
"resource": ""
} |
q9360 | Int16Shrinker | train | func Int16Shrinker(v interface{}) gopter.Shrink {
return Int64Shrinker(int64(v.(int16))).Map(int64To16)
} | go | {
"resource": ""
} |
q9361 | UInt16Shrinker | train | func UInt16Shrinker(v interface{}) gopter.Shrink {
return UInt64Shrinker(uint64(v.(uint16))).Map(uint64To16)
} | go | {
"resource": ""
} |
q9362 | Int8Shrinker | train | func Int8Shrinker(v interface{}) gopter.Shrink {
return Int64Shrinker(int64(v.(int8))).Map(int64To8)
} | go | {
"resource": ""
} |
q9363 | UInt8Shrinker | train | func UInt8Shrinker(v interface{}) gopter.Shrink {
return UInt64Shrinker(uint64(v.(uint8))).Map(uint64To8)
} | go | {
"resource": ""
} |
q9364 | IntShrinker | train | func IntShrinker(v interface{}) gopter.Shrink {
return Int64Shrinker(int64(v.(int))).Map(int64ToInt)
} | go | {
"resource": ""
} |
q9365 | UIntShrinker | train | func UIntShrinker(v interface{}) gopter.Shrink {
return UInt64Shrinker(uint64(v.(uint))).Map(uint64ToUint)
} | go | {
"resource": ""
} |
q9366 | TimeShrinker | train | 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 | {
"resource": ""
} |
q9367 | Weighted | train | 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 | {
"resource": ""
} |
q9368 | Const | train | func Const(value interface{}) gopter.Gen {
return func(*gopter.GenParameters) *gopter.GenResult {
return gopter.NewGenResult(value, gopter.NoShrinker)
}
} | go | {
"resource": ""
} |
q9369 | OneConstOf | train | 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 | {
"resource": ""
} |
q9370 | OneGenOf | train | 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 | {
"resource": ""
} |
q9371 | Float64Shrinker | train | 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 | {
"resource": ""
} |
q9372 | Float32Shrinker | train | func Float32Shrinker(v interface{}) gopter.Shrink {
return Float64Shrinker(float64(v.(float32))).Map(func(e float64) float32 {
return float32(e)
})
} | go | {
"resource": ""
} |
q9373 | ForAll1 | train | 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 | {
"resource": ""
} |
q9374 | Bool | train | func Bool() gopter.Gen {
return func(genParams *gopter.GenParameters) *gopter.GenResult {
return gopter.NewGenResult(genParams.NextBool(), gopter.NoShrinker)
}
} | go | {
"resource": ""
} |
q9375 | SaveProp | train | 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 | {
"resource": ""
} |
q9376 | Check | train | 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 | {
"resource": ""
} |
q9377 | Fail | train | func Fail(resultType reflect.Type) gopter.Gen {
return func(*gopter.GenParameters) *gopter.GenResult {
return gopter.NewEmptyResult(resultType)
}
} | go | {
"resource": ""
} |
q9378 | PtrOf | train | 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 | {
"resource": ""
} |
q9379 | ConvertUp | train | 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 | {
"resource": ""
} |
q9380 | ConvertDown | train | 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 | {
"resource": ""
} |
q9381 | Filter | train | 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 | {
"resource": ""
} |
q9382 | All | train | func (s Shrink) All() []interface{} {
result := []interface{}{}
value, ok := s()
for ok {
result = append(result, value)
value, ok = s()
}
return result
} | go | {
"resource": ""
} |
q9383 | ConcatShrinks | train | func ConcatShrinks(shrinks ...Shrink) Shrink {
concated := &concatedShrink{
index: 0,
shrinks: shrinks,
}
return concated.Next
} | go | {
"resource": ""
} |
q9384 | Interleave | train | func (s Shrink) Interleave(other Shrink) Shrink {
interleaved := &interleaved{
first: s,
second: other,
}
return interleaved.Next
} | go | {
"resource": ""
} |
q9385 | RuneRange | train | func RuneRange(min, max rune) gopter.Gen {
return genRune(Int64Range(int64(min), int64(max)))
} | go | {
"resource": ""
} |
q9386 | Rune | train | func Rune() gopter.Gen {
return genRune(Frequency(map[int]gopter.Gen{
0xD800: Int64Range(0, 0xD800),
utf8.MaxRune - 0xDFFF: Int64Range(0xDFFF, int64(utf8.MaxRune)),
}))
} | go | {
"resource": ""
} |
q9387 | UnicodeChar | train | 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 | {
"resource": ""
} |
q9388 | Identifier | train | 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 | {
"resource": ""
} |
q9389 | UnicodeString | train | func UnicodeString(table *unicode.RangeTable) gopter.Gen {
return genString(UnicodeChar(table), func(ch rune) bool {
return unicode.Is(table, ch)
})
} | go | {
"resource": ""
} |
q9390 | addToBridge | train | 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 | {
"resource": ""
} |
q9391 | ResultId | train | func (df *DeviceFailed) ResultId() string {
switch s := df.Session.(type) {
case *InterfaceCreated:
return s.Id
case *NetDevInsertedEvent:
return s.Id
default:
return ""
}
} | go | {
"resource": ""
} |
q9392 | toC | train | 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 | {
"resource": ""
} |
q9393 | NewKataAgent | train | 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 | {
"resource": ""
} |
q9394 | RegisterSubnet | train | 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 | {
"resource": ""
} |
q9395 | RequestIP | train | 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 | {
"resource": ""
} |
q9396 | ReleaseIP | train | 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 | {
"resource": ""
} |
q9397 | getNextIP | train | 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 | {
"resource": ""
} |
q9398 | ipToBigInt | train | 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 | {
"resource": ""
} |
q9399 | bigIntToIP | train | func bigIntToIP(v *big.Int) net.IP {
return net.IP(v.Bytes())
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.