github.com/annchain/OG@v0.0.9/p2p/protocol_gen_test.go (about) 1 package p2p 2 3 // Code generated by github.com/tinylib/msgp DO NOT EDIT. 4 5 import ( 6 "bytes" 7 "testing" 8 9 "github.com/tinylib/msgp/msgp" 10 ) 11 12 func TestMarshalUnmarshalCap(t *testing.T) { 13 v := Cap{} 14 bts, err := v.MarshalMsg(nil) 15 if err != nil { 16 t.Fatal(err) 17 } 18 left, err := v.UnmarshalMsg(bts) 19 if err != nil { 20 t.Fatal(err) 21 } 22 if len(left) > 0 { 23 t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left) 24 } 25 26 left, err = msgp.Skip(bts) 27 if err != nil { 28 t.Fatal(err) 29 } 30 if len(left) > 0 { 31 t.Errorf("%d bytes left over after Skip(): %q", len(left), left) 32 } 33 } 34 35 func BenchmarkMarshalMsgCap(b *testing.B) { 36 v := Cap{} 37 b.ReportAllocs() 38 b.ResetTimer() 39 for i := 0; i < b.N; i++ { 40 v.MarshalMsg(nil) 41 } 42 } 43 44 func BenchmarkAppendMsgCap(b *testing.B) { 45 v := Cap{} 46 bts := make([]byte, 0, v.Msgsize()) 47 bts, _ = v.MarshalMsg(bts[0:0]) 48 b.SetBytes(int64(len(bts))) 49 b.ReportAllocs() 50 b.ResetTimer() 51 for i := 0; i < b.N; i++ { 52 bts, _ = v.MarshalMsg(bts[0:0]) 53 } 54 } 55 56 func BenchmarkUnmarshalCap(b *testing.B) { 57 v := Cap{} 58 bts, _ := v.MarshalMsg(nil) 59 b.ReportAllocs() 60 b.SetBytes(int64(len(bts))) 61 b.ResetTimer() 62 for i := 0; i < b.N; i++ { 63 _, err := v.UnmarshalMsg(bts) 64 if err != nil { 65 b.Fatal(err) 66 } 67 } 68 } 69 70 func TestEncodeDecodeCap(t *testing.T) { 71 v := Cap{} 72 var buf bytes.Buffer 73 msgp.Encode(&buf, &v) 74 75 m := v.Msgsize() 76 if buf.Len() > m { 77 t.Logf("WARNING: Msgsize() for %v is inaccurate", v) 78 } 79 80 vn := Cap{} 81 err := msgp.Decode(&buf, &vn) 82 if err != nil { 83 t.Error(err) 84 } 85 86 buf.Reset() 87 msgp.Encode(&buf, &v) 88 err = msgp.NewReader(&buf).Skip() 89 if err != nil { 90 t.Error(err) 91 } 92 } 93 94 func BenchmarkEncodeCap(b *testing.B) { 95 v := Cap{} 96 var buf bytes.Buffer 97 msgp.Encode(&buf, &v) 98 b.SetBytes(int64(buf.Len())) 99 en := msgp.NewWriter(msgp.Nowhere) 100 b.ReportAllocs() 101 b.ResetTimer() 102 for i := 0; i < b.N; i++ { 103 v.EncodeMsg(en) 104 } 105 en.Flush() 106 } 107 108 func BenchmarkDecodeCap(b *testing.B) { 109 v := Cap{} 110 var buf bytes.Buffer 111 msgp.Encode(&buf, &v) 112 b.SetBytes(int64(buf.Len())) 113 rd := msgp.NewEndlessReader(buf.Bytes(), b) 114 dc := msgp.NewReader(rd) 115 b.ReportAllocs() 116 b.ResetTimer() 117 for i := 0; i < b.N; i++ { 118 err := v.DecodeMsg(dc) 119 if err != nil { 120 b.Fatal(err) 121 } 122 } 123 } 124 125 func TestMarshalUnmarshalCapsByNameAndVersion(t *testing.T) { 126 v := CapsByNameAndVersion{} 127 bts, err := v.MarshalMsg(nil) 128 if err != nil { 129 t.Fatal(err) 130 } 131 left, err := v.UnmarshalMsg(bts) 132 if err != nil { 133 t.Fatal(err) 134 } 135 if len(left) > 0 { 136 t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left) 137 } 138 139 left, err = msgp.Skip(bts) 140 if err != nil { 141 t.Fatal(err) 142 } 143 if len(left) > 0 { 144 t.Errorf("%d bytes left over after Skip(): %q", len(left), left) 145 } 146 } 147 148 func BenchmarkMarshalMsgCapsByNameAndVersion(b *testing.B) { 149 v := CapsByNameAndVersion{} 150 b.ReportAllocs() 151 b.ResetTimer() 152 for i := 0; i < b.N; i++ { 153 v.MarshalMsg(nil) 154 } 155 } 156 157 func BenchmarkAppendMsgCapsByNameAndVersion(b *testing.B) { 158 v := CapsByNameAndVersion{} 159 bts := make([]byte, 0, v.Msgsize()) 160 bts, _ = v.MarshalMsg(bts[0:0]) 161 b.SetBytes(int64(len(bts))) 162 b.ReportAllocs() 163 b.ResetTimer() 164 for i := 0; i < b.N; i++ { 165 bts, _ = v.MarshalMsg(bts[0:0]) 166 } 167 } 168 169 func BenchmarkUnmarshalCapsByNameAndVersion(b *testing.B) { 170 v := CapsByNameAndVersion{} 171 bts, _ := v.MarshalMsg(nil) 172 b.ReportAllocs() 173 b.SetBytes(int64(len(bts))) 174 b.ResetTimer() 175 for i := 0; i < b.N; i++ { 176 _, err := v.UnmarshalMsg(bts) 177 if err != nil { 178 b.Fatal(err) 179 } 180 } 181 } 182 183 func TestEncodeDecodeCapsByNameAndVersion(t *testing.T) { 184 v := CapsByNameAndVersion{} 185 var buf bytes.Buffer 186 msgp.Encode(&buf, &v) 187 188 m := v.Msgsize() 189 if buf.Len() > m { 190 t.Logf("WARNING: Msgsize() for %v is inaccurate", v) 191 } 192 193 vn := CapsByNameAndVersion{} 194 err := msgp.Decode(&buf, &vn) 195 if err != nil { 196 t.Error(err) 197 } 198 199 buf.Reset() 200 msgp.Encode(&buf, &v) 201 err = msgp.NewReader(&buf).Skip() 202 if err != nil { 203 t.Error(err) 204 } 205 } 206 207 func BenchmarkEncodeCapsByNameAndVersion(b *testing.B) { 208 v := CapsByNameAndVersion{} 209 var buf bytes.Buffer 210 msgp.Encode(&buf, &v) 211 b.SetBytes(int64(buf.Len())) 212 en := msgp.NewWriter(msgp.Nowhere) 213 b.ReportAllocs() 214 b.ResetTimer() 215 for i := 0; i < b.N; i++ { 216 v.EncodeMsg(en) 217 } 218 en.Flush() 219 } 220 221 func BenchmarkDecodeCapsByNameAndVersion(b *testing.B) { 222 v := CapsByNameAndVersion{} 223 var buf bytes.Buffer 224 msgp.Encode(&buf, &v) 225 b.SetBytes(int64(buf.Len())) 226 rd := msgp.NewEndlessReader(buf.Bytes(), b) 227 dc := msgp.NewReader(rd) 228 b.ReportAllocs() 229 b.ResetTimer() 230 for i := 0; i < b.N; i++ { 231 err := v.DecodeMsg(dc) 232 if err != nil { 233 b.Fatal(err) 234 } 235 } 236 } 237 238 func TestMarshalUnmarshalProtoHandshake(t *testing.T) { 239 v := ProtoHandshake{} 240 bts, err := v.MarshalMsg(nil) 241 if err != nil { 242 t.Fatal(err) 243 } 244 left, err := v.UnmarshalMsg(bts) 245 if err != nil { 246 t.Fatal(err) 247 } 248 if len(left) > 0 { 249 t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left) 250 } 251 252 left, err = msgp.Skip(bts) 253 if err != nil { 254 t.Fatal(err) 255 } 256 if len(left) > 0 { 257 t.Errorf("%d bytes left over after Skip(): %q", len(left), left) 258 } 259 } 260 261 func BenchmarkMarshalMsgProtoHandshake(b *testing.B) { 262 v := ProtoHandshake{} 263 b.ReportAllocs() 264 b.ResetTimer() 265 for i := 0; i < b.N; i++ { 266 v.MarshalMsg(nil) 267 } 268 } 269 270 func BenchmarkAppendMsgProtoHandshake(b *testing.B) { 271 v := ProtoHandshake{} 272 bts := make([]byte, 0, v.Msgsize()) 273 bts, _ = v.MarshalMsg(bts[0:0]) 274 b.SetBytes(int64(len(bts))) 275 b.ReportAllocs() 276 b.ResetTimer() 277 for i := 0; i < b.N; i++ { 278 bts, _ = v.MarshalMsg(bts[0:0]) 279 } 280 } 281 282 func BenchmarkUnmarshalProtoHandshake(b *testing.B) { 283 v := ProtoHandshake{} 284 bts, _ := v.MarshalMsg(nil) 285 b.ReportAllocs() 286 b.SetBytes(int64(len(bts))) 287 b.ResetTimer() 288 for i := 0; i < b.N; i++ { 289 _, err := v.UnmarshalMsg(bts) 290 if err != nil { 291 b.Fatal(err) 292 } 293 } 294 } 295 296 func TestEncodeDecodeProtoHandshake(t *testing.T) { 297 v := ProtoHandshake{} 298 var buf bytes.Buffer 299 msgp.Encode(&buf, &v) 300 301 m := v.Msgsize() 302 if buf.Len() > m { 303 t.Logf("WARNING: Msgsize() for %v is inaccurate", v) 304 } 305 306 vn := ProtoHandshake{} 307 err := msgp.Decode(&buf, &vn) 308 if err != nil { 309 t.Error(err) 310 } 311 312 buf.Reset() 313 msgp.Encode(&buf, &v) 314 err = msgp.NewReader(&buf).Skip() 315 if err != nil { 316 t.Error(err) 317 } 318 } 319 320 func BenchmarkEncodeProtoHandshake(b *testing.B) { 321 v := ProtoHandshake{} 322 var buf bytes.Buffer 323 msgp.Encode(&buf, &v) 324 b.SetBytes(int64(buf.Len())) 325 en := msgp.NewWriter(msgp.Nowhere) 326 b.ReportAllocs() 327 b.ResetTimer() 328 for i := 0; i < b.N; i++ { 329 v.EncodeMsg(en) 330 } 331 en.Flush() 332 } 333 334 func BenchmarkDecodeProtoHandshake(b *testing.B) { 335 v := ProtoHandshake{} 336 var buf bytes.Buffer 337 msgp.Encode(&buf, &v) 338 b.SetBytes(int64(buf.Len())) 339 rd := msgp.NewEndlessReader(buf.Bytes(), b) 340 dc := msgp.NewReader(rd) 341 b.ReportAllocs() 342 b.ResetTimer() 343 for i := 0; i < b.N; i++ { 344 err := v.DecodeMsg(dc) 345 if err != nil { 346 b.Fatal(err) 347 } 348 } 349 } 350 351 func TestMarshalUnmarshalProtocol(t *testing.T) { 352 v := Protocol{} 353 bts, err := v.MarshalMsg(nil) 354 if err != nil { 355 t.Fatal(err) 356 } 357 left, err := v.UnmarshalMsg(bts) 358 if err != nil { 359 t.Fatal(err) 360 } 361 if len(left) > 0 { 362 t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left) 363 } 364 365 left, err = msgp.Skip(bts) 366 if err != nil { 367 t.Fatal(err) 368 } 369 if len(left) > 0 { 370 t.Errorf("%d bytes left over after Skip(): %q", len(left), left) 371 } 372 } 373 374 func BenchmarkMarshalMsgProtocol(b *testing.B) { 375 v := Protocol{} 376 b.ReportAllocs() 377 b.ResetTimer() 378 for i := 0; i < b.N; i++ { 379 v.MarshalMsg(nil) 380 } 381 } 382 383 func BenchmarkAppendMsgProtocol(b *testing.B) { 384 v := Protocol{} 385 bts := make([]byte, 0, v.Msgsize()) 386 bts, _ = v.MarshalMsg(bts[0:0]) 387 b.SetBytes(int64(len(bts))) 388 b.ReportAllocs() 389 b.ResetTimer() 390 for i := 0; i < b.N; i++ { 391 bts, _ = v.MarshalMsg(bts[0:0]) 392 } 393 } 394 395 func BenchmarkUnmarshalProtocol(b *testing.B) { 396 v := Protocol{} 397 bts, _ := v.MarshalMsg(nil) 398 b.ReportAllocs() 399 b.SetBytes(int64(len(bts))) 400 b.ResetTimer() 401 for i := 0; i < b.N; i++ { 402 _, err := v.UnmarshalMsg(bts) 403 if err != nil { 404 b.Fatal(err) 405 } 406 } 407 } 408 409 func TestEncodeDecodeProtocol(t *testing.T) { 410 v := Protocol{} 411 var buf bytes.Buffer 412 msgp.Encode(&buf, &v) 413 414 m := v.Msgsize() 415 if buf.Len() > m { 416 t.Logf("WARNING: Msgsize() for %v is inaccurate", v) 417 } 418 419 vn := Protocol{} 420 err := msgp.Decode(&buf, &vn) 421 if err != nil { 422 t.Error(err) 423 } 424 425 buf.Reset() 426 msgp.Encode(&buf, &v) 427 err = msgp.NewReader(&buf).Skip() 428 if err != nil { 429 t.Error(err) 430 } 431 } 432 433 func BenchmarkEncodeProtocol(b *testing.B) { 434 v := Protocol{} 435 var buf bytes.Buffer 436 msgp.Encode(&buf, &v) 437 b.SetBytes(int64(buf.Len())) 438 en := msgp.NewWriter(msgp.Nowhere) 439 b.ReportAllocs() 440 b.ResetTimer() 441 for i := 0; i < b.N; i++ { 442 v.EncodeMsg(en) 443 } 444 en.Flush() 445 } 446 447 func BenchmarkDecodeProtocol(b *testing.B) { 448 v := Protocol{} 449 var buf bytes.Buffer 450 msgp.Encode(&buf, &v) 451 b.SetBytes(int64(buf.Len())) 452 rd := msgp.NewEndlessReader(buf.Bytes(), b) 453 dc := msgp.NewReader(rd) 454 b.ReportAllocs() 455 b.ResetTimer() 456 for i := 0; i < b.N; i++ { 457 err := v.DecodeMsg(dc) 458 if err != nil { 459 b.Fatal(err) 460 } 461 } 462 }