id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c9300 |
if p.NextBool() {
return -v
}
return v
} | |
c9301 |
second := uint64(p.Rng.Int63())
return (first << 1) ^ second
} | |
c9302 | 100,
MaxShrinkCount: 1000,
Rng: rand.New(NewLockedSource(seed)),
}
} | |
c9303 |
genResult.Sieve = func(v interface{}) bool {
return v.(float64) >= min && v.(float64) <= max
}
return genResult
}
} | |
c9304 | {
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)
} | |
c9305 |
genResult.Sieve = func(v interface{}) bool {
return v.(float32) >= min && v.(float32) <= max
}
return genResult
}
} | |
c9306 | {
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)
} | |
c9307 | {
return runeSliceShrinker([]rune(v.(string))).Map(runesToString)
} | |
c9308 |
props: make(map[string]Prop, 0),
propNames: make([]string, 0),
}
} | |
c9309 | reporter.ReportTestResult(propName, result)
if !result.Passed() {
success = false
}
}
return success
} | |
c9310 | result.Labels = append(result.Labels, label)
return result
}
} | |
c9311 | NoShrinker
} else {
result.Shrinker = shrinker
}
return result
}
} | |
c9312 | }
return &GenResult{
Shrinker: NoShrinker,
Result: nil,
Labels: result.Labels,
ResultType: resultType,
}
}
} | |
c9313 |
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
}
} | |
c9314 |
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{res... | |
c9315 |
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),
)
} | |
c9316 | 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...)
}
} | |
c9317 | regexMatchGen(regexSyntax.Simplify()).SuchThat(func(v string) bool {
return regex.MatchString(v)
}).WithShrinker(StringShrinker)
} | |
c9318 | 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()
}),
)
}
} | |
c9319 |
return &PropResult{
Status: PropFalse,
Labels: []string{label},
Args: make([]*PropArg, 0),
}
} | |
c9320 | PropTrue || r.Status == PropProof
} | |
c9321 | []*PropArg) *PropResult {
r.Args = args
return r
} | |
c9322 | = append(r.Args, args...)
return r
} | |
c9323 |
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
}
} | |
c9324 | src: rand.NewSource(seed).(rand.Source64),
}
} | |
c9325 |
r.src.Seed(seed)
*readPos = 0
r.lk.Unlock()
} | |
c9326 | = read(p, r.src.Int63, readVal, readPos)
r.lk.Unlock()
return
} | |
c9327 | strings.Join(genResult.Labels, ", "),
Arg: value,
OrigArg: origValue,
Shrinks: shrinks,
}
} | |
c9328 | rv,
index: i,
elementShrink: elementShrinker(rv.Index(i).Interface()),
}
shrinks = append(shrinks, sliceShrinkOne.Next)
}
return gopter.ConcatShrinks(shrinks...)
}
} | |
c9329 | return &gopter.PropResult{
Status: gopter.PropUndecided,
}
}
return convertResult(check(value)).AddArgs(gopter.NewPropArg(genResult, 0, value, value))
})
} | |
c9330 |
return gen.Fail(reflect.TypeOf((*Command)(nil)).Elem())
} | |
c9331 | State) bool {
return p.InitialPreCondition(state)
})
} | |
c9332 | if p.InitialPreConditionFunc != nil {
return p.InitialPreConditionFunc(state)
}
return true
} | |
c9333 | defer commands.DestroySystemUnderTest(systemUnderTest)
return actions.run(systemUnderTest)
}, genActions(commands))
} | |
c9334 | reflect.TypeOf(time.Now()): gen.Time(),
},
}
} | |
c9335 |
return gen
}
return a.genForKind(rt)
} | |
c9336 | := result.ResultType
a.generators[rt] = gen
} | |
c9337 | return complex(values[0].(float64), values[1].(float64))
}).WithShrinker(Complex128Shrinker)
} | |
c9338 | return complex(values[0].(float32), values[1].(float32))
}).WithShrinker(Complex64Shrinker)
} | |
c9339 |
size = params.Rng.Intn(params.MaxSize-params.MinSize) + params.MinSize
}
return f(size)(params)
}
} | |
c9340 | r.Result != nil) || (r.Sieve != nil && r.Sieve(r.Result)) {
return r.Result, true
}
return nil, false
} | |
c9341 | && r.Sieve != nil && r.Sieve(r.Result) {
return reflect.Zero(r.ResultType), true
}
return reflect.Zero(r.ResultType), false
} | |
c9342 | *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
}
} | |
c9343 |
genResult := gopter.NewGenResult(min+genParams.NextUint64()%d, UInt64Shrinker)
genResult.Sieve = func(v interface{}) bool {
return v.(uint64) >= min && v.(uint64) <= max
}
return genResult
}
} | |
c9344 |
Map(int64To32).
WithShrinker(Int32Shrinker).
SuchThat(func(v int32) bool {
return v >= min && v <= max
})
} | |
c9345 |
Map(uint64To32).
WithShrinker(UInt32Shrinker).
SuchThat(func(v uint32) bool {
return v >= min && v <= max
})
} | |
c9346 |
Map(int64To16).
WithShrinker(Int16Shrinker).
SuchThat(func(v int16) bool {
return v >= min && v <= max
})
} | |
c9347 |
Map(uint64To16).
WithShrinker(UInt16Shrinker).
SuchThat(func(v uint16) bool {
return v >= min && v <= max
})
} | |
c9348 |
Map(int64To8).
WithShrinker(Int8Shrinker).
SuchThat(func(v int8) bool {
return v >= min && v <= max
})
} | |
c9349 |
Map(uint64To8).
WithShrinker(UInt8Shrinker).
SuchThat(func(v uint8) bool {
return v >= min && v <= max
})
} | |
c9350 |
Map(int64ToInt).
WithShrinker(IntShrinker).
SuchThat(func(v int) bool {
return v >= min && v <= max
})
} | |
c9351 | math.MaxInt32).
Map(int64ToInt).
WithShrinker(IntShrinker)
} | |
c9352 |
Map(uint64ToUint).
WithShrinker(UIntShrinker).
SuchThat(func(v uint) bool {
return v >= min && v <= max
})
} | |
c9353 | math.MaxUint32).
Map(uint64ToUint).
WithShrinker(UIntShrinker)
} | |
c9354 | return gopter.NewGenResult(genParams.MaxSize, IntShrinker)
}
} | |
c9355 | Reporter {
return &FormatedReporter{
verbose: verbose,
width: width,
output: output,
}
} | |
c9356 | / 2,
}
return gopter.Shrink(negShrink.Next).Interleave(gopter.Shrink(posShrink.Next))
} | |
c9357 | uint64Shrink{
original: v.(uint64),
half: v.(uint64),
}
return shrink.Next
} | |
c9358 | {
return Int64Shrinker(int64(v.(int32))).Map(int64To32)
} | |
c9359 | {
return UInt64Shrinker(uint64(v.(uint32))).Map(uint64To32)
} | |
c9360 | {
return Int64Shrinker(int64(v.(int16))).Map(int64To16)
} | |
c9361 | {
return UInt64Shrinker(uint64(v.(uint16))).Map(uint64To16)
} | |
c9362 | {
return Int64Shrinker(int64(v.(int8))).Map(int64To8)
} | |
c9363 | {
return UInt64Shrinker(uint64(v.(uint8))).Map(uint64To8)
} | |
c9364 | {
return Int64Shrinker(int64(v.(int))).Map(int64ToInt)
} | |
c9365 | {
return UInt64Shrinker(uint64(v.(uint))).Map(uint64ToUint)
} | |
c9366 | 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))
}))
} | |
c9367 | 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
}
} | |
c9368 | return gopter.NewGenResult(value, gopter.NoShrinker)
}
} | |
c9369 | func(genParams *gopter.GenParameters) *gopter.GenResult {
idx := genParams.Rng.Intn(len(consts))
return gopter.NewGenResult(consts[idx], gopter.NoShrinker)
}
} | |
c9370 |
}
return func(genParams *gopter.GenParameters) *gopter.GenResult {
idx := genParams.Rng.Intn(len(gens))
return gens[idx](genParams)
}
} | |
c9371 | }
posShrink := float64Shrink{
original: v.(float64),
half: v.(float64) / 2,
}
return gopter.Shrink(negShrink.Next).Interleave(gopter.Shrink(posShrink.Next))
} | |
c9372 | .Map(func(e float64) float32 {
return float32(e)
})
} | |
c9373 | 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
})
} | |
c9374 | return gopter.NewGenResult(genParams.NextBool(), gopter.NoShrinker)
}
} | |
c9375 | nil {
result = &PropResult{
Status: PropError,
Error: fmt.Errorf("Check paniced: %v", r),
ErrorStack: debug.Stack(),
}
}
}()
return prop(genParams)
}
} | |
c9376 |
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{
... | |
c9377 | return gopter.NewEmptyResult(resultType)
}
} | |
c9378 | }
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, refle... | |
c9379 | 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
} | |
c9380 | }
downVals := b.Downstream.Call(upVals)
down := make([]interface{}, len(downVals))
for i, downVal := range downVals {
down[i] = downVal.Interface()
}
return down
} | |
c9381 | ok && !condition(value) {
value, ok = s()
}
return value, ok
}
} | |
c9382 | result = append(result, value)
value, ok = s()
}
return result
} | |
c9383 | shrinks: shrinks,
}
return concated.Next
} | |
c9384 | second: other,
}
return interleaved.Next
} | |
c9385 | {
return genRune(Int64Range(int64(min), int64(max)))
} | |
c9386 | utf8.MaxRune - 0xDFFF: Int64Range(0xDFFF, int64(utf8.MaxRune)),
}))
} | |
c9387 | 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
}
} | |
c9388 | 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)
} | |
c9389 | rune) bool {
return unicode.Is(table, ch)
})
} | |
c9390 | master.(*netlink.Bridge))
default:
return fmt.Errorf("unknown link type:%+v", master.Type())
}
} | |
c9391 | case *NetDevInsertedEvent:
return s.Id
default:
return ""
}
} | |
c9392 | 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
} | |
c9393 | },
))
conn, err := grpc.Dial(kataAgentSock, dialOpts...)
if err != nil {
return nil, err
}
return &kataAgent{
conn: conn,
agent: kagenta.NewAgentServiceClient(conn),
}, nil
} | |
c9394 | 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
} | |
c9395 | newAllocatedMap(network)
a.allocatedIPs[key] = allocated
}
if ip == nil {
return allocated.getNextIP()
}
return allocated.checkIP(ip)
} | |
c9396 | allocated, exists := a.allocatedIPs[network.String()]; exists {
delete(allocated.p, ip.String())
}
return nil
} | |
c9397 | }
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
} | |
c9398 | }
if ip6 := ip.To16(); ip6 != nil {
return x.SetBytes(ip6)
}
return nil
} | |
c9399 | net.IP(v.Bytes())
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.