id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c10800 |
err = multierr.Append(err, enc.AddArray("integerlist", (_List_List_List_I32_Zapper)(v.Integerlist)))
}
return err
} | |
c10801 |
}
if v.MapIntStrsetList != nil {
fields[i] = fmt.Sprintf("MapIntStrsetList: %v", v.MapIntStrsetList)
i++
}
return fmt.Sprintf("NestedMixedx2{%v}", strings.Join(fields[:i], ", "))
} | |
c10802 | }
if !((v.MapIntStrset == nil && rhs.MapIntStrset == nil) || (v.MapIntStrset != nil && rhs.MapIntStrset != nil && _Map_I32_Set_String_Equals(v.MapIntStrset, rhs.MapIntStrset))) {
return false
}
if !((v.MapIntStrsetList == nil && rhs.MapIntStrsetList == nil) || (v.MapIntStrsetList != nil && rhs.MapIntStrsetList !=... | |
c10803 |
err = multierr.Append(err, enc.AppendArray((_Set_I32_Zapper)(v)))
}
return err
} | |
c10804 | enc.AddArray("value", (_Set_String_Zapper)(v.Value)))
return err
} | |
c10805 | err = multierr.Append(err, enc.AppendObject(_Map_I32_Set_String_Item_Zapper{Key: k, Value: v}))
}
return err
} | |
c10806 | {
for _, v := range l {
err = multierr.Append(err, enc.AppendArray((_Map_I32_Set_String_Zapper)(v)))
}
return err
} | |
c10807 | if v.MapIntStrsetList != nil {
err = multierr.Append(err, enc.AddArray("map_int_strset_list", (_List_Map_I32_Set_String_Zapper)(v.MapIntStrsetList)))
}
return err
} | |
c10808 | nil {
return v.IntSetList
}
return
} | |
c10809 | {
if v != nil && v.MapIntStrset != nil {
return v.MapIntStrset
}
return
} | |
c10810 | {
if v != nil && v.MapIntStrsetList != nil {
return v.MapIntStrsetList
}
return
} | |
c10811 |
enc.AddString("name", "FIVE")
case 6:
enc.AddString("name", "SIX")
case 8:
enc.AddString("name", "EIGHT")
}
return nil
} | |
c10812 |
return "SIX"
case 8:
return "EIGHT"
}
return fmt.Sprintf("Numberz(%d)", w)
} | |
c10813 | fmt.Errorf("enum underflow from JSON %q for %q", text, "Numberz")
}
*v = (Numberz)(x)
return nil
case string:
return v.UnmarshalText([]byte(w))
default:
return fmt.Errorf("invalid JSON value %q (%T) to unmarshal into %q", t, t, "Numberz")
}
} | |
c10814 |
if v.Field != nil {
fields[i] = fmt.Sprintf("Field: %v", v.Field)
i++
}
return fmt.Sprintf("OneField{%v}", strings.Join(fields[:i], ", "))
} | |
c10815 |
}
if !((v.Field == nil && rhs.Field == nil) || (v.Field != nil && rhs.Field != nil && v.Field.Equals(rhs.Field))) {
return false
}
return true
} | |
c10816 | = multierr.Append(err, enc.AddObject("field", v.Field))
}
return err
} | |
c10817 | nil {
return v.Field
}
return
} | |
c10818 | v.S)
i++
return fmt.Sprintf("StructA{%v}", strings.Join(fields[:i], ", "))
} | |
c10819 | nil
} else if rhs == nil {
return false
}
if !(v.S == rhs.S) {
return false
}
return true
} | |
c10820 |
return nil
}
enc.AddString("s", v.S)
return err
} | |
c10821 | {
if v != nil {
o = v.S
}
return
} | |
c10822 |
fields[i] = fmt.Sprintf("Aa: %v", v.Aa)
i++
}
fields[i] = fmt.Sprintf("Ab: %v", v.Ab)
i++
return fmt.Sprintf("StructB{%v}", strings.Join(fields[:i], ", "))
} | |
c10823 | nil && v.Aa.Equals(rhs.Aa))) {
return false
}
if !v.Ab.Equals(rhs.Ab) {
return false
}
return true
} | |
c10824 | err = multierr.Append(err, enc.AddObject("aa", v.Aa))
}
err = multierr.Append(err, enc.AddObject("ab", v.Ab))
return err
} | |
c10825 | {
return v.Aa
}
return
} | |
c10826 | {
if v != nil {
o = v.Ab
}
return
} | |
c10827 | {
x := (int64)(v)
return wire.NewValueI64(x), error(nil)
} | |
c10828 | (int64)(v)
return fmt.Sprint(x)
} | |
c10829 | := w.GetI64(), error(nil)
*v = (UserId)(x)
return err
} | |
c10830 | ((int64)(lhs) == (int64)(rhs))
} | |
c10831 | i++
}
if v.OldString != nil {
fields[i] = fmt.Sprintf("OldString: %v", *(v.OldString))
i++
}
if v.EndInBoth != nil {
fields[i] = fmt.Sprintf("EndInBoth: %v", *(v.EndInBoth))
i++
}
return fmt.Sprintf("VersioningTestV1{%v}", strings.Join(fields[:i], ", "))
} | |
c10832 | if !_String_EqualsPtr(v.OldString, rhs.OldString) {
return false
}
if !_I32_EqualsPtr(v.EndInBoth, rhs.EndInBoth) {
return false
}
return true
} | |
c10833 |
enc.AddInt32("begin_in_both", *v.BeginInBoth)
}
if v.OldString != nil {
enc.AddString("old_string", *v.OldString)
}
if v.EndInBoth != nil {
enc.AddInt32("end_in_both", *v.EndInBoth)
}
return err
} | |
c10834 | nil {
return *v.OldString
}
return
} | |
c10835 | fmt.Sprintf("Newset: %v", v.Newset)
i++
}
if v.Newmap != nil {
fields[i] = fmt.Sprintf("Newmap: %v", v.Newmap)
i++
}
if v.Newstring != nil {
fields[i] = fmt.Sprintf("Newstring: %v", *(v.Newstring))
i++
}
if v.EndInBoth != nil {
fields[i] = fmt.Sprintf("EndInBoth: %v", *(v.EndInBoth))
i++
}
retur... | |
c10836 |
if !((v.Newstruct == nil && rhs.Newstruct == nil) || (v.Newstruct != nil && rhs.Newstruct != nil && v.Newstruct.Equals(rhs.Newstruct))) {
return false
}
if !((v.Newlist == nil && rhs.Newlist == nil) || (v.Newlist != nil && rhs.Newlist != nil && _List_I32_Equals(v.Newlist, rhs.Newlist))) {
return false
}
if !(... | |
c10837 | enc.AddInt32("key", v.Key)
enc.AddInt32("value", v.Value)
return err
} | |
c10838 | = multierr.Append(err, enc.AppendObject(_Map_I32_I32_Item_Zapper{Key: k, Value: v}))
}
return err
} | |
c10839 | err = multierr.Append(err, enc.AddArray("newlist", (_List_I32_Zapper)(v.Newlist)))
}
if v.Newset != nil {
err = multierr.Append(err, enc.AddArray("newset", (_Set_I32_Zapper)(v.Newset)))
}
if v.Newmap != nil {
err = multierr.Append(err, enc.AddArray("newmap", (_Map_I32_I32_Zapper)(v.Newmap)))
}
if v.Newstrin... | |
c10840 | nil {
return *v.Newint
}
return
} | |
c10841 | nil {
return *v.Newbyte
}
return
} | |
c10842 | nil {
return *v.Newshort
}
return
} | |
c10843 | nil {
return *v.Newlong
}
return
} | |
c10844 | nil {
return *v.Newdouble
}
return
} | |
c10845 | nil {
return v.Newstruct
}
return
} | |
c10846 | nil {
return v.Newlist
}
return
} | |
c10847 | {
if v != nil && v.Newset != nil {
return v.Newset
}
return
} | |
c10848 | nil {
return v.Newmap
}
return
} | |
c10849 | nil {
return *v.Newstring
}
return
} | |
c10850 | fmt.Sprintf("Message: %v", *(v.Message))
i++
}
return fmt.Sprintf("Xception{%v}", strings.Join(fields[:i], ", "))
} | |
c10851 | return false
}
if !_String_EqualsPtr(v.Message, rhs.Message) {
return false
}
return true
} | |
c10852 | }
if v.ErrorCode != nil {
enc.AddInt32("errorCode", *v.ErrorCode)
}
if v.Message != nil {
enc.AddString("message", *v.Message)
}
return err
} | |
c10853 | *(v.ErrorCode))
i++
}
if v.StructThing != nil {
fields[i] = fmt.Sprintf("StructThing: %v", v.StructThing)
i++
}
return fmt.Sprintf("Xception2{%v}", strings.Join(fields[:i], ", "))
} | |
c10854 | (v.StructThing != nil && rhs.StructThing != nil && v.StructThing.Equals(rhs.StructThing))) {
return false
}
return true
} | |
c10855 | nil {
enc.AddInt32("errorCode", *v.ErrorCode)
}
if v.StructThing != nil {
err = multierr.Append(err, enc.AddObject("struct_thing", v.StructThing))
}
return err
} | |
c10856 | nil {
fields[i] = fmt.Sprintf("I32Thing: %v", *(v.I32Thing))
i++
}
if v.I64Thing != nil {
fields[i] = fmt.Sprintf("I64Thing: %v", *(v.I64Thing))
i++
}
return fmt.Sprintf("Xtruct{%v}", strings.Join(fields[:i], ", "))
} | |
c10857 |
if !_I32_EqualsPtr(v.I32Thing, rhs.I32Thing) {
return false
}
if !_I64_EqualsPtr(v.I64Thing, rhs.I64Thing) {
return false
}
return true
} | |
c10858 | != nil {
enc.AddInt32("i32_thing", *v.I32Thing)
}
if v.I64Thing != nil {
enc.AddInt64("i64_thing", *v.I64Thing)
}
return err
} | |
c10859 |
i++
}
if v.I32Thing != nil {
fields[i] = fmt.Sprintf("I32Thing: %v", *(v.I32Thing))
i++
}
return fmt.Sprintf("Xtruct2{%v}", strings.Join(fields[:i], ", "))
} | |
c10860 | != nil && v.StructThing.Equals(rhs.StructThing))) {
return false
}
if !_I32_EqualsPtr(v.I32Thing, rhs.I32Thing) {
return false
}
return true
} | |
c10861 |
err = multierr.Append(err, enc.AddObject("struct_thing", v.StructThing))
}
if v.I32Thing != nil {
enc.AddInt32("i32_thing", *v.I32Thing)
}
return err
} | |
c10862 | {
fields[i] = fmt.Sprintf("Changed: %v", *(v.Changed))
i++
}
if v.I32Thing != nil {
fields[i] = fmt.Sprintf("I32Thing: %v", *(v.I32Thing))
i++
}
if v.I64Thing != nil {
fields[i] = fmt.Sprintf("I64Thing: %v", *(v.I64Thing))
i++
}
return fmt.Sprintf("Xtruct3{%v}", strings.Join(fields[:i], ", "))
} | |
c10863 |
if !_I32_EqualsPtr(v.I32Thing, rhs.I32Thing) {
return false
}
if !_I64_EqualsPtr(v.I64Thing, rhs.I64Thing) {
return false
}
return true
} | |
c10864 | != nil {
enc.AddInt32("i32_thing", *v.I32Thing)
}
if v.I64Thing != nil {
enc.AddInt64("i64_thing", *v.I64Thing)
}
return err
} | |
c10865 | v != nil && v.Changed != nil {
return *v.Changed
}
return
} | |
c10866 | crossdockpb.NewEchoYARPCClient(dispatcher.ClientConfig("yarpc-test"))
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
token := random.String(5)
pong, err := client.Echo(ctx, &crossdockpb.Ping{Beep: token})
crossdock.Fatals(t).NoError(err, "call to Echo::echo failed: %v", e... | |
c10867 | transportSpec.buildInbound,
BuildUnaryOutbound: transportSpec.buildUnaryOutbound,
BuildStreamOutbound: transportSpec.buildStreamOutbound,
}
} | |
c10868 |
fatals.FailNow("oneway json test failed", "client waited for server to fill channel")
default:
}
fatals.NoError(err, "call to oneway/json failed: %v", err)
fatals.NotNil(ack, "ack is nil")
serverToken := <-serverCalledBack
assert.Equal(token, string(serverToken), "JSON token mismatch")
} | |
c10869 | callBackAddr)
case "thrift":
Thrift(t, dispatcher, serverCalledBack, callBackAddr)
case "protobuf":
Protobuf(t, dispatcher, serverCalledBack, callBackAddr)
default:
crossdock.Fatals(t).Fail("unknown encoding", "%v", encoding)
}
} | |
c10870 | []byte)
return func(ctx context.Context, body []byte) error {
serverCalledBack <- body
return nil
}, serverCalledBack
} | |
c10871 | v := range from.Items() {
to.Add(hm.Prefix+k, v)
}
return to
} | |
c10872 | to = to.With(key, from.Get(k))
}
// Note: undefined behavior for multiple occurrences of the same header
}
return to
} | |
c10873 | TransportName: "tchannel.Transport",
PeerIdentifier: pid.Identifier(),
}
}
if err := p.Unsubscribe(sub); err != nil {
return err
}
if p.NumSubscribers() == 0 {
// Release the peer so that the connection retention loop stops.
p.Release()
delete(t.peers, pid.Identifier())
}
return nil
} | |
c10874 |
defer t.lock.Unlock()
p, ok := t.peers[tp.HostPort()]
if !ok {
return
}
p.OnStatusChanged()
} | |
c10875 | (v.Ping != nil && rhs.Ping != nil && v.Ping.Equals(rhs.Ping))) {
return false
}
return true
} | |
c10876 | err = multierr.Append(err, enc.AddObject("ping", v.Ping))
}
return err
} | |
c10877 | nil {
return v.Ping
}
return
} | |
c10878 | if v.Success != nil {
fields[i] = fmt.Sprintf("Success: %v", v.Success)
i++
}
return fmt.Sprintf("Echo_Echo_Result{%v}", strings.Join(fields[:i], ", "))
} | |
c10879 | transport: transport,
subscribers: make(map[peer.Subscriber]struct{}),
}
p.connectionStatus.Store(int32(peer.Unavailable))
return p
} | |
c10880 | p.subscribers[sub] = struct{}{}
p.lock.Unlock()
} | |
c10881 | PeerIdentifier: p.PeerIdentifier,
PeerSubscriber: sub,
}
}
delete(p.subscribers, sub)
return nil
} | |
c10882 |
subs := len(p.subscribers)
p.lock.RUnlock()
return subs
} | |
c10883 | int(p.pending.Load()),
ConnectionStatus: peer.ConnectionStatus(p.connectionStatus.Load()),
}
} | |
c10884 | not start Dispatcher")
defer dispatcher.Stop()
switch encoding {
case "raw":
runRaw(t, dispatcher)
case "json":
runJSON(t, dispatcher)
case "thrift":
runThrift(t, dispatcher)
default:
fatals.Fail("", "unknown encoding %q", encoding)
}
} | |
c10885 | reqSvcName == resSvcName[0], resSvcName[0]
}
return true, ""
} | |
c10886 | getInboundCall(ctx); ok {
return &Call{ic}
}
return nil
} | |
c10887 | }
return c.ic.req.Caller
} | |
c10888 | }
return c.ic.req.Service
} | |
c10889 | }
return c.ic.req.Transport
} | |
c10890 | }
return c.ic.req.Procedure
} | |
c10891 | return ""
}
return c.ic.req.Encoding
} | |
c10892 | names = append(names, k)
}
sort.Strings(names)
return names
} | |
c10893 | }
return c.ic.req.ShardKey
} | |
c10894 | }
return c.ic.req.RoutingKey
} | |
c10895 |
}
return c.ic.req.RoutingDelegate
} | |
c10896 | timeout")
if yarpcerrors.FromError(err).Code() == yarpcerrors.CodeInvalidArgument {
t.Skipf("sleep/raw method not implemented: %v", err)
return
}
assert.Equal(yarpcerrors.CodeDeadlineExceeded, yarpcerrors.FromError(err).Code(), "is an error with code CodeDeadlineExceeded: %v", err)
} | |
c10897 |
return func(options *transportOptions) {
options.keepAlive = t
}
} | |
c10898 | *transportOptions) {
options.innocenceWindow = d
}
} | |
c10899 | *transportOptions) {
options.tracer = tracer
}
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.