this repo has no description
lex: update interop tests
+1149
-125
+822
-13
lex/util/cbor_gen_test.go
+822
-13
lex/util/cbor_gen_test.go
···
25
25
}
26
26
27
27
cw := cbg.NewCborWriter(w)
28
+
fieldCount := 8
29
+
30
+
if t.Absent == nil {
31
+
fieldCount--
32
+
}
33
+
34
+
if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
35
+
return err
36
+
}
37
+
38
+
// t.Bool (bool) (bool)
39
+
if len("bool") > cbg.MaxLength {
40
+
return xerrors.Errorf("Value in field \"bool\" was too long")
41
+
}
42
+
43
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("bool"))); err != nil {
44
+
return err
45
+
}
46
+
if _, err := io.WriteString(w, string("bool")); err != nil {
47
+
return err
48
+
}
49
+
50
+
if err := cbg.WriteBool(w, t.Bool); err != nil {
51
+
return err
52
+
}
53
+
54
+
// t.Null (string) (string)
55
+
if len("null") > cbg.MaxLength {
56
+
return xerrors.Errorf("Value in field \"null\" was too long")
57
+
}
58
+
59
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("null"))); err != nil {
60
+
return err
61
+
}
62
+
if _, err := io.WriteString(w, string("null")); err != nil {
63
+
return err
64
+
}
65
+
66
+
if t.Null == nil {
67
+
if _, err := cw.Write(cbg.CborNull); err != nil {
68
+
return err
69
+
}
70
+
} else {
71
+
if len(*t.Null) > cbg.MaxLength {
72
+
return xerrors.Errorf("Value in field t.Null was too long")
73
+
}
74
+
75
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Null))); err != nil {
76
+
return err
77
+
}
78
+
if _, err := io.WriteString(w, string(*t.Null)); err != nil {
79
+
return err
80
+
}
81
+
}
82
+
83
+
// t.Array ([]string) (slice)
84
+
if len("array") > cbg.MaxLength {
85
+
return xerrors.Errorf("Value in field \"array\" was too long")
86
+
}
87
+
88
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("array"))); err != nil {
89
+
return err
90
+
}
91
+
if _, err := io.WriteString(w, string("array")); err != nil {
92
+
return err
93
+
}
94
+
95
+
if len(t.Array) > cbg.MaxLength {
96
+
return xerrors.Errorf("Slice value in field t.Array was too long")
97
+
}
98
+
99
+
if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Array))); err != nil {
100
+
return err
101
+
}
102
+
for _, v := range t.Array {
103
+
if len(v) > cbg.MaxLength {
104
+
return xerrors.Errorf("Value in field v was too long")
105
+
}
106
+
107
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
108
+
return err
109
+
}
110
+
if _, err := io.WriteString(w, string(v)); err != nil {
111
+
return err
112
+
}
113
+
}
114
+
115
+
// t.Absent (string) (string)
116
+
if t.Absent != nil {
117
+
118
+
if len("absent") > cbg.MaxLength {
119
+
return xerrors.Errorf("Value in field \"absent\" was too long")
120
+
}
121
+
122
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("absent"))); err != nil {
123
+
return err
124
+
}
125
+
if _, err := io.WriteString(w, string("absent")); err != nil {
126
+
return err
127
+
}
128
+
129
+
if t.Absent == nil {
130
+
if _, err := cw.Write(cbg.CborNull); err != nil {
131
+
return err
132
+
}
133
+
} else {
134
+
if len(*t.Absent) > cbg.MaxLength {
135
+
return xerrors.Errorf("Value in field t.Absent was too long")
136
+
}
137
+
138
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Absent))); err != nil {
139
+
return err
140
+
}
141
+
if _, err := io.WriteString(w, string(*t.Absent)); err != nil {
142
+
return err
143
+
}
144
+
}
145
+
}
146
+
147
+
// t.Object (util.basicSchemaInner) (struct)
148
+
if len("object") > cbg.MaxLength {
149
+
return xerrors.Errorf("Value in field \"object\" was too long")
150
+
}
151
+
152
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("object"))); err != nil {
153
+
return err
154
+
}
155
+
if _, err := io.WriteString(w, string("object")); err != nil {
156
+
return err
157
+
}
158
+
159
+
if err := t.Object.MarshalCBOR(cw); err != nil {
160
+
return err
161
+
}
162
+
163
+
// t.String (string) (string)
164
+
if len("string") > cbg.MaxLength {
165
+
return xerrors.Errorf("Value in field \"string\" was too long")
166
+
}
167
+
168
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("string"))); err != nil {
169
+
return err
170
+
}
171
+
if _, err := io.WriteString(w, string("string")); err != nil {
172
+
return err
173
+
}
174
+
175
+
if len(t.String) > cbg.MaxLength {
176
+
return xerrors.Errorf("Value in field t.String was too long")
177
+
}
178
+
179
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.String))); err != nil {
180
+
return err
181
+
}
182
+
if _, err := io.WriteString(w, string(t.String)); err != nil {
183
+
return err
184
+
}
185
+
186
+
// t.Integer (int64) (int64)
187
+
if len("integer") > cbg.MaxLength {
188
+
return xerrors.Errorf("Value in field \"integer\" was too long")
189
+
}
190
+
191
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("integer"))); err != nil {
192
+
return err
193
+
}
194
+
if _, err := io.WriteString(w, string("integer")); err != nil {
195
+
return err
196
+
}
197
+
198
+
if t.Integer >= 0 {
199
+
if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Integer)); err != nil {
200
+
return err
201
+
}
202
+
} else {
203
+
if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Integer-1)); err != nil {
204
+
return err
205
+
}
206
+
}
207
+
208
+
// t.Unicode (string) (string)
209
+
if len("unicode") > cbg.MaxLength {
210
+
return xerrors.Errorf("Value in field \"unicode\" was too long")
211
+
}
212
+
213
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("unicode"))); err != nil {
214
+
return err
215
+
}
216
+
if _, err := io.WriteString(w, string("unicode")); err != nil {
217
+
return err
218
+
}
219
+
220
+
if len(t.Unicode) > cbg.MaxLength {
221
+
return xerrors.Errorf("Value in field t.Unicode was too long")
222
+
}
223
+
224
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Unicode))); err != nil {
225
+
return err
226
+
}
227
+
if _, err := io.WriteString(w, string(t.Unicode)); err != nil {
228
+
return err
229
+
}
230
+
return nil
231
+
}
232
+
233
+
func (t *basicSchema) UnmarshalCBOR(r io.Reader) (err error) {
234
+
*t = basicSchema{}
235
+
236
+
cr := cbg.NewCborReader(r)
237
+
238
+
maj, extra, err := cr.ReadHeader()
239
+
if err != nil {
240
+
return err
241
+
}
242
+
defer func() {
243
+
if err == io.EOF {
244
+
err = io.ErrUnexpectedEOF
245
+
}
246
+
}()
247
+
248
+
if maj != cbg.MajMap {
249
+
return fmt.Errorf("cbor input should be of type map")
250
+
}
251
+
252
+
if extra > cbg.MaxLength {
253
+
return fmt.Errorf("basicSchema: map struct too large (%d)", extra)
254
+
}
255
+
256
+
var name string
257
+
n := extra
258
+
259
+
for i := uint64(0); i < n; i++ {
260
+
261
+
{
262
+
sval, err := cbg.ReadString(cr)
263
+
if err != nil {
264
+
return err
265
+
}
266
+
267
+
name = string(sval)
268
+
}
269
+
270
+
switch name {
271
+
// t.Bool (bool) (bool)
272
+
case "bool":
273
+
274
+
maj, extra, err = cr.ReadHeader()
275
+
if err != nil {
276
+
return err
277
+
}
278
+
if maj != cbg.MajOther {
279
+
return fmt.Errorf("booleans must be major type 7")
280
+
}
281
+
switch extra {
282
+
case 20:
283
+
t.Bool = false
284
+
case 21:
285
+
t.Bool = true
286
+
default:
287
+
return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
288
+
}
289
+
// t.Null (string) (string)
290
+
case "null":
291
+
292
+
{
293
+
b, err := cr.ReadByte()
294
+
if err != nil {
295
+
return err
296
+
}
297
+
if b != cbg.CborNull[0] {
298
+
if err := cr.UnreadByte(); err != nil {
299
+
return err
300
+
}
301
+
302
+
sval, err := cbg.ReadString(cr)
303
+
if err != nil {
304
+
return err
305
+
}
306
+
307
+
t.Null = (*string)(&sval)
308
+
}
309
+
}
310
+
// t.Array ([]string) (slice)
311
+
case "array":
312
+
313
+
maj, extra, err = cr.ReadHeader()
314
+
if err != nil {
315
+
return err
316
+
}
317
+
318
+
if extra > cbg.MaxLength {
319
+
return fmt.Errorf("t.Array: array too large (%d)", extra)
320
+
}
321
+
322
+
if maj != cbg.MajArray {
323
+
return fmt.Errorf("expected cbor array")
324
+
}
325
+
326
+
if extra > 0 {
327
+
t.Array = make([]string, extra)
328
+
}
329
+
330
+
for i := 0; i < int(extra); i++ {
331
+
332
+
{
333
+
sval, err := cbg.ReadString(cr)
334
+
if err != nil {
335
+
return err
336
+
}
337
+
338
+
t.Array[i] = string(sval)
339
+
}
340
+
}
341
+
342
+
// t.Absent (string) (string)
343
+
case "absent":
344
+
345
+
{
346
+
b, err := cr.ReadByte()
347
+
if err != nil {
348
+
return err
349
+
}
350
+
if b != cbg.CborNull[0] {
351
+
if err := cr.UnreadByte(); err != nil {
352
+
return err
353
+
}
354
+
355
+
sval, err := cbg.ReadString(cr)
356
+
if err != nil {
357
+
return err
358
+
}
359
+
360
+
t.Absent = (*string)(&sval)
361
+
}
362
+
}
363
+
// t.Object (util.basicSchemaInner) (struct)
364
+
case "object":
365
+
366
+
{
367
+
368
+
if err := t.Object.UnmarshalCBOR(cr); err != nil {
369
+
return xerrors.Errorf("unmarshaling t.Object: %w", err)
370
+
}
371
+
372
+
}
373
+
// t.String (string) (string)
374
+
case "string":
375
+
376
+
{
377
+
sval, err := cbg.ReadString(cr)
378
+
if err != nil {
379
+
return err
380
+
}
381
+
382
+
t.String = string(sval)
383
+
}
384
+
// t.Integer (int64) (int64)
385
+
case "integer":
386
+
{
387
+
maj, extra, err := cr.ReadHeader()
388
+
var extraI int64
389
+
if err != nil {
390
+
return err
391
+
}
392
+
switch maj {
393
+
case cbg.MajUnsignedInt:
394
+
extraI = int64(extra)
395
+
if extraI < 0 {
396
+
return fmt.Errorf("int64 positive overflow")
397
+
}
398
+
case cbg.MajNegativeInt:
399
+
extraI = int64(extra)
400
+
if extraI < 0 {
401
+
return fmt.Errorf("int64 negative overflow")
402
+
}
403
+
extraI = -1 - extraI
404
+
default:
405
+
return fmt.Errorf("wrong type for int64 field: %d", maj)
406
+
}
407
+
408
+
t.Integer = int64(extraI)
409
+
}
410
+
// t.Unicode (string) (string)
411
+
case "unicode":
412
+
413
+
{
414
+
sval, err := cbg.ReadString(cr)
415
+
if err != nil {
416
+
return err
417
+
}
418
+
419
+
t.Unicode = string(sval)
420
+
}
421
+
422
+
default:
423
+
// Field doesn't exist on this type, so ignore it
424
+
cbg.ScanForLinks(r, func(cid.Cid) {})
425
+
}
426
+
}
427
+
428
+
return nil
429
+
}
430
+
func (t *basicSchemaInner) MarshalCBOR(w io.Writer) error {
431
+
if t == nil {
432
+
_, err := w.Write(cbg.CborNull)
433
+
return err
434
+
}
435
+
436
+
cw := cbg.NewCborWriter(w)
437
+
438
+
if _, err := cw.Write([]byte{164}); err != nil {
439
+
return err
440
+
}
441
+
442
+
// t.Arr ([]string) (slice)
443
+
if len("arr") > cbg.MaxLength {
444
+
return xerrors.Errorf("Value in field \"arr\" was too long")
445
+
}
446
+
447
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("arr"))); err != nil {
448
+
return err
449
+
}
450
+
if _, err := io.WriteString(w, string("arr")); err != nil {
451
+
return err
452
+
}
453
+
454
+
if len(t.Arr) > cbg.MaxLength {
455
+
return xerrors.Errorf("Slice value in field t.Arr was too long")
456
+
}
457
+
458
+
if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Arr))); err != nil {
459
+
return err
460
+
}
461
+
for _, v := range t.Arr {
462
+
if len(v) > cbg.MaxLength {
463
+
return xerrors.Errorf("Value in field v was too long")
464
+
}
465
+
466
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
467
+
return err
468
+
}
469
+
if _, err := io.WriteString(w, string(v)); err != nil {
470
+
return err
471
+
}
472
+
}
473
+
474
+
// t.Bool (bool) (bool)
475
+
if len("bool") > cbg.MaxLength {
476
+
return xerrors.Errorf("Value in field \"bool\" was too long")
477
+
}
478
+
479
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("bool"))); err != nil {
480
+
return err
481
+
}
482
+
if _, err := io.WriteString(w, string("bool")); err != nil {
483
+
return err
484
+
}
485
+
486
+
if err := cbg.WriteBool(w, t.Bool); err != nil {
487
+
return err
488
+
}
489
+
490
+
// t.Number (int64) (int64)
491
+
if len("number") > cbg.MaxLength {
492
+
return xerrors.Errorf("Value in field \"number\" was too long")
493
+
}
494
+
495
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("number"))); err != nil {
496
+
return err
497
+
}
498
+
if _, err := io.WriteString(w, string("number")); err != nil {
499
+
return err
500
+
}
501
+
502
+
if t.Number >= 0 {
503
+
if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Number)); err != nil {
504
+
return err
505
+
}
506
+
} else {
507
+
if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Number-1)); err != nil {
508
+
return err
509
+
}
510
+
}
511
+
512
+
// t.String (string) (string)
513
+
if len("string") > cbg.MaxLength {
514
+
return xerrors.Errorf("Value in field \"string\" was too long")
515
+
}
516
+
517
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("string"))); err != nil {
518
+
return err
519
+
}
520
+
if _, err := io.WriteString(w, string("string")); err != nil {
521
+
return err
522
+
}
523
+
524
+
if len(t.String) > cbg.MaxLength {
525
+
return xerrors.Errorf("Value in field t.String was too long")
526
+
}
527
+
528
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.String))); err != nil {
529
+
return err
530
+
}
531
+
if _, err := io.WriteString(w, string(t.String)); err != nil {
532
+
return err
533
+
}
534
+
return nil
535
+
}
536
+
537
+
func (t *basicSchemaInner) UnmarshalCBOR(r io.Reader) (err error) {
538
+
*t = basicSchemaInner{}
539
+
540
+
cr := cbg.NewCborReader(r)
541
+
542
+
maj, extra, err := cr.ReadHeader()
543
+
if err != nil {
544
+
return err
545
+
}
546
+
defer func() {
547
+
if err == io.EOF {
548
+
err = io.ErrUnexpectedEOF
549
+
}
550
+
}()
551
+
552
+
if maj != cbg.MajMap {
553
+
return fmt.Errorf("cbor input should be of type map")
554
+
}
555
+
556
+
if extra > cbg.MaxLength {
557
+
return fmt.Errorf("basicSchemaInner: map struct too large (%d)", extra)
558
+
}
559
+
560
+
var name string
561
+
n := extra
562
+
563
+
for i := uint64(0); i < n; i++ {
564
+
565
+
{
566
+
sval, err := cbg.ReadString(cr)
567
+
if err != nil {
568
+
return err
569
+
}
570
+
571
+
name = string(sval)
572
+
}
573
+
574
+
switch name {
575
+
// t.Arr ([]string) (slice)
576
+
case "arr":
577
+
578
+
maj, extra, err = cr.ReadHeader()
579
+
if err != nil {
580
+
return err
581
+
}
582
+
583
+
if extra > cbg.MaxLength {
584
+
return fmt.Errorf("t.Arr: array too large (%d)", extra)
585
+
}
586
+
587
+
if maj != cbg.MajArray {
588
+
return fmt.Errorf("expected cbor array")
589
+
}
590
+
591
+
if extra > 0 {
592
+
t.Arr = make([]string, extra)
593
+
}
594
+
595
+
for i := 0; i < int(extra); i++ {
596
+
597
+
{
598
+
sval, err := cbg.ReadString(cr)
599
+
if err != nil {
600
+
return err
601
+
}
602
+
603
+
t.Arr[i] = string(sval)
604
+
}
605
+
}
606
+
607
+
// t.Bool (bool) (bool)
608
+
case "bool":
609
+
610
+
maj, extra, err = cr.ReadHeader()
611
+
if err != nil {
612
+
return err
613
+
}
614
+
if maj != cbg.MajOther {
615
+
return fmt.Errorf("booleans must be major type 7")
616
+
}
617
+
switch extra {
618
+
case 20:
619
+
t.Bool = false
620
+
case 21:
621
+
t.Bool = true
622
+
default:
623
+
return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
624
+
}
625
+
// t.Number (int64) (int64)
626
+
case "number":
627
+
{
628
+
maj, extra, err := cr.ReadHeader()
629
+
var extraI int64
630
+
if err != nil {
631
+
return err
632
+
}
633
+
switch maj {
634
+
case cbg.MajUnsignedInt:
635
+
extraI = int64(extra)
636
+
if extraI < 0 {
637
+
return fmt.Errorf("int64 positive overflow")
638
+
}
639
+
case cbg.MajNegativeInt:
640
+
extraI = int64(extra)
641
+
if extraI < 0 {
642
+
return fmt.Errorf("int64 negative overflow")
643
+
}
644
+
extraI = -1 - extraI
645
+
default:
646
+
return fmt.Errorf("wrong type for int64 field: %d", maj)
647
+
}
648
+
649
+
t.Number = int64(extraI)
650
+
}
651
+
// t.String (string) (string)
652
+
case "string":
653
+
654
+
{
655
+
sval, err := cbg.ReadString(cr)
656
+
if err != nil {
657
+
return err
658
+
}
659
+
660
+
t.String = string(sval)
661
+
}
662
+
663
+
default:
664
+
// Field doesn't exist on this type, so ignore it
665
+
cbg.ScanForLinks(r, func(cid.Cid) {})
666
+
}
667
+
}
668
+
669
+
return nil
670
+
}
671
+
func (t *ipldSchema) MarshalCBOR(w io.Writer) error {
672
+
if t == nil {
673
+
_, err := w.Write(cbg.CborNull)
674
+
return err
675
+
}
676
+
677
+
cw := cbg.NewCborWriter(w)
678
+
679
+
if _, err := cw.Write([]byte{163}); err != nil {
680
+
return err
681
+
}
682
+
683
+
// t.A (util.LexLink) (struct)
684
+
if len("a") > cbg.MaxLength {
685
+
return xerrors.Errorf("Value in field \"a\" was too long")
686
+
}
687
+
688
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("a"))); err != nil {
689
+
return err
690
+
}
691
+
if _, err := io.WriteString(w, string("a")); err != nil {
692
+
return err
693
+
}
694
+
695
+
if err := t.A.MarshalCBOR(cw); err != nil {
696
+
return err
697
+
}
698
+
699
+
// t.B (util.LexBytes) (slice)
700
+
if len("b") > cbg.MaxLength {
701
+
return xerrors.Errorf("Value in field \"b\" was too long")
702
+
}
703
+
704
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("b"))); err != nil {
705
+
return err
706
+
}
707
+
if _, err := io.WriteString(w, string("b")); err != nil {
708
+
return err
709
+
}
710
+
711
+
if len(t.B) > cbg.ByteArrayMaxLen {
712
+
return xerrors.Errorf("Byte array in field t.B was too long")
713
+
}
714
+
715
+
if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.B))); err != nil {
716
+
return err
717
+
}
718
+
719
+
if _, err := cw.Write(t.B[:]); err != nil {
720
+
return err
721
+
}
722
+
723
+
// t.C (util.LexBlob) (struct)
724
+
if len("c") > cbg.MaxLength {
725
+
return xerrors.Errorf("Value in field \"c\" was too long")
726
+
}
727
+
728
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("c"))); err != nil {
729
+
return err
730
+
}
731
+
if _, err := io.WriteString(w, string("c")); err != nil {
732
+
return err
733
+
}
734
+
735
+
if err := t.C.MarshalCBOR(cw); err != nil {
736
+
return err
737
+
}
738
+
return nil
739
+
}
740
+
741
+
func (t *ipldSchema) UnmarshalCBOR(r io.Reader) (err error) {
742
+
*t = ipldSchema{}
743
+
744
+
cr := cbg.NewCborReader(r)
745
+
746
+
maj, extra, err := cr.ReadHeader()
747
+
if err != nil {
748
+
return err
749
+
}
750
+
defer func() {
751
+
if err == io.EOF {
752
+
err = io.ErrUnexpectedEOF
753
+
}
754
+
}()
755
+
756
+
if maj != cbg.MajMap {
757
+
return fmt.Errorf("cbor input should be of type map")
758
+
}
759
+
760
+
if extra > cbg.MaxLength {
761
+
return fmt.Errorf("ipldSchema: map struct too large (%d)", extra)
762
+
}
763
+
764
+
var name string
765
+
n := extra
766
+
767
+
for i := uint64(0); i < n; i++ {
768
+
769
+
{
770
+
sval, err := cbg.ReadString(cr)
771
+
if err != nil {
772
+
return err
773
+
}
774
+
775
+
name = string(sval)
776
+
}
777
+
778
+
switch name {
779
+
// t.A (util.LexLink) (struct)
780
+
case "a":
781
+
782
+
{
783
+
784
+
if err := t.A.UnmarshalCBOR(cr); err != nil {
785
+
return xerrors.Errorf("unmarshaling t.A: %w", err)
786
+
}
787
+
788
+
}
789
+
// t.B (util.LexBytes) (slice)
790
+
case "b":
791
+
792
+
maj, extra, err = cr.ReadHeader()
793
+
if err != nil {
794
+
return err
795
+
}
796
+
797
+
if extra > cbg.ByteArrayMaxLen {
798
+
return fmt.Errorf("t.B: byte array too large (%d)", extra)
799
+
}
800
+
if maj != cbg.MajByteString {
801
+
return fmt.Errorf("expected byte array")
802
+
}
803
+
804
+
if extra > 0 {
805
+
t.B = make([]uint8, extra)
806
+
}
807
+
808
+
if _, err := io.ReadFull(cr, t.B[:]); err != nil {
809
+
return err
810
+
}
811
+
// t.C (util.LexBlob) (struct)
812
+
case "c":
813
+
814
+
{
815
+
816
+
if err := t.C.UnmarshalCBOR(cr); err != nil {
817
+
return xerrors.Errorf("unmarshaling t.C: %w", err)
818
+
}
819
+
820
+
}
821
+
822
+
default:
823
+
// Field doesn't exist on this type, so ignore it
824
+
cbg.ScanForLinks(r, func(cid.Cid) {})
825
+
}
826
+
}
827
+
828
+
return nil
829
+
}
830
+
func (t *basicOldSchema) MarshalCBOR(w io.Writer) error {
831
+
if t == nil {
832
+
_, err := w.Write(cbg.CborNull)
833
+
return err
834
+
}
835
+
836
+
cw := cbg.NewCborWriter(w)
28
837
fieldCount := 7
29
838
30
839
if t.D == nil {
···
189
998
}
190
999
}
191
1000
192
-
// t.G (util.basicSchemaInner) (struct)
1001
+
// t.G (util.basicOldSchemaInner) (struct)
193
1002
if len("g") > cbg.MaxLength {
194
1003
return xerrors.Errorf("Value in field \"g\" was too long")
195
1004
}
···
207
1016
return nil
208
1017
}
209
1018
210
-
func (t *basicSchema) UnmarshalCBOR(r io.Reader) (err error) {
211
-
*t = basicSchema{}
1019
+
func (t *basicOldSchema) UnmarshalCBOR(r io.Reader) (err error) {
1020
+
*t = basicOldSchema{}
212
1021
213
1022
cr := cbg.NewCborReader(r)
214
1023
···
227
1036
}
228
1037
229
1038
if extra > cbg.MaxLength {
230
-
return fmt.Errorf("basicSchema: map struct too large (%d)", extra)
1039
+
return fmt.Errorf("basicOldSchema: map struct too large (%d)", extra)
231
1040
}
232
1041
233
1042
var name string
···
374
1183
}
375
1184
}
376
1185
377
-
// t.G (util.basicSchemaInner) (struct)
1186
+
// t.G (util.basicOldSchemaInner) (struct)
378
1187
case "g":
379
1188
380
1189
{
···
393
1202
394
1203
return nil
395
1204
}
396
-
func (t *basicSchemaInner) MarshalCBOR(w io.Writer) error {
1205
+
func (t *basicOldSchemaInner) MarshalCBOR(w io.Writer) error {
397
1206
if t == nil {
398
1207
_, err := w.Write(cbg.CborNull)
399
1208
return err
···
500
1309
return nil
501
1310
}
502
1311
503
-
func (t *basicSchemaInner) UnmarshalCBOR(r io.Reader) (err error) {
504
-
*t = basicSchemaInner{}
1312
+
func (t *basicOldSchemaInner) UnmarshalCBOR(r io.Reader) (err error) {
1313
+
*t = basicOldSchemaInner{}
505
1314
506
1315
cr := cbg.NewCborReader(r)
507
1316
···
520
1329
}
521
1330
522
1331
if extra > cbg.MaxLength {
523
-
return fmt.Errorf("basicSchemaInner: map struct too large (%d)", extra)
1332
+
return fmt.Errorf("basicOldSchemaInner: map struct too large (%d)", extra)
524
1333
}
525
1334
526
1335
var name string
···
633
1442
634
1443
return nil
635
1444
}
636
-
func (t *ipldSchema) MarshalCBOR(w io.Writer) error {
1445
+
func (t *ipldOldSchema) MarshalCBOR(w io.Writer) error {
637
1446
if t == nil {
638
1447
_, err := w.Write(cbg.CborNull)
639
1448
return err
···
687
1496
return nil
688
1497
}
689
1498
690
-
func (t *ipldSchema) UnmarshalCBOR(r io.Reader) (err error) {
691
-
*t = ipldSchema{}
1499
+
func (t *ipldOldSchema) UnmarshalCBOR(r io.Reader) (err error) {
1500
+
*t = ipldOldSchema{}
692
1501
693
1502
cr := cbg.NewCborReader(r)
694
1503
···
707
1516
}
708
1517
709
1518
if extra > cbg.MaxLength {
710
-
return fmt.Errorf("ipldSchema: map struct too large (%d)", extra)
1519
+
return fmt.Errorf("ipldOldSchema: map struct too large (%d)", extra)
711
1520
}
712
1521
713
1522
var name string
+172
lex/util/lex_interop_old_test.go
+172
lex/util/lex_interop_old_test.go
···
1
+
// This file has "old" versions of the interop tests. Might as well keep these
2
+
// around!
3
+
4
+
package util
5
+
6
+
import (
7
+
"bytes"
8
+
"encoding/json"
9
+
"testing"
10
+
11
+
"github.com/ipfs/go-cid"
12
+
"github.com/stretchr/testify/assert"
13
+
)
14
+
15
+
type basicOldSchema struct {
16
+
A string `json:"a" cborgen:"a"`
17
+
B int64 `json:"b" cborgen:"b"`
18
+
C bool `json:"c" cborgen:"c"`
19
+
D *string `json:"d,omitempty" cborgen:"d,omitempty"`
20
+
E *string `json:"e" cborgen:"e"`
21
+
F []string `json:"f" cborgen:"f"`
22
+
G basicOldSchemaInner `json:"g" cborgen:"g"`
23
+
}
24
+
25
+
type basicOldSchemaInner struct {
26
+
H string `json:"h" cborgen:"h"`
27
+
I int64 `json:"i" cborgen:"i"`
28
+
J bool `json:"j" cborgen:"j"`
29
+
K []string `json:"k" cborgen:"k"`
30
+
}
31
+
32
+
type ipldOldSchema struct {
33
+
A LexLink `json:"a" cborgen:"a"`
34
+
B LexBytes `json:"b" cborgen:"b"`
35
+
}
36
+
37
+
func TestInteropBasicOldSchema(t *testing.T) {
38
+
assert := assert.New(t)
39
+
jsonStr := `{
40
+
"a": "abc",
41
+
"b": 123,
42
+
"c": true,
43
+
"e": null,
44
+
"f": ["abc", "def", "ghi"],
45
+
"g": {
46
+
"h": "abc",
47
+
"i": 123,
48
+
"j": true,
49
+
"k": ["abc", "def", "ghi"]
50
+
}
51
+
}`
52
+
goObj := basicOldSchema{
53
+
A: "abc",
54
+
B: 123,
55
+
C: true,
56
+
D: nil,
57
+
E: nil,
58
+
F: []string{"abc", "def", "ghi"},
59
+
G: basicOldSchemaInner{
60
+
H: "abc",
61
+
I: 123,
62
+
J: true,
63
+
K: []string{"abc", "def", "ghi"},
64
+
},
65
+
}
66
+
cborBytes := []byte{166, 97, 97, 99, 97, 98, 99, 97, 98, 24, 123, 97, 99, 245, 97, 101, 246,
67
+
97, 102, 131, 99, 97, 98, 99, 99, 100, 101, 102, 99, 103, 104, 105, 97,
68
+
103, 164, 97, 104, 99, 97, 98, 99, 97, 105, 24, 123, 97, 106, 245, 97,
69
+
107, 131, 99, 97, 98, 99, 99, 100, 101, 102, 99, 103, 104, 105}
70
+
cidStr := "bafyreiaioukcatdbdltzqznmyqmwgpgmoex62tkwqtdmganxgv3v5bn2o4"
71
+
72
+
// easier commenting out of code during development
73
+
_ = assert
74
+
_ = jsonStr
75
+
_ = goObj
76
+
_ = cidStr
77
+
_ = bytes.NewReader(cborBytes)
78
+
79
+
// basic parsing
80
+
jsonObj := basicOldSchema{}
81
+
assert.NoError(json.Unmarshal([]byte(jsonStr), &jsonObj))
82
+
cborObj := basicOldSchema{}
83
+
assert.NoError(cborObj.UnmarshalCBOR(bytes.NewReader(cborBytes)))
84
+
85
+
// compare parsed against known object
86
+
assert.Equal(goObj, jsonObj)
87
+
assert.Equal(goObj, cborObj)
88
+
89
+
// reproduce CBOR serialization
90
+
goCborBytes := new(bytes.Buffer)
91
+
assert.NoError(goObj.MarshalCBOR(goCborBytes))
92
+
assert.Equal(cborBytes, goCborBytes.Bytes())
93
+
// 0x71 = dag-cbor, 0x12 = sha2-256, 0 = default length
94
+
cidBuilder := cid.V1Builder{0x71, 0x12, 0}
95
+
goCborCid, err := cidBuilder.Sum(goCborBytes.Bytes())
96
+
assert.NoError(err)
97
+
assert.Equal(cidStr, goCborCid.String())
98
+
99
+
// reproduce JSON serialization
100
+
var jsonAll interface{}
101
+
assert.NoError(json.Unmarshal([]byte(jsonStr), &jsonAll))
102
+
goJsonBytes, err := json.Marshal(goObj)
103
+
assert.NoError(err)
104
+
var goJsonAll interface{}
105
+
assert.NoError(json.Unmarshal(goJsonBytes, &goJsonAll))
106
+
assert.Equal(jsonAll, goJsonAll)
107
+
}
108
+
109
+
func TestInteropIpldOldSchema(t *testing.T) {
110
+
assert := assert.New(t)
111
+
112
+
jsonStr := `{
113
+
"a": {
114
+
"$link": "bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a"
115
+
},
116
+
"b": {
117
+
"$bytes": "nFERjvLLiw9qm45JrqH9QTzyC2Lu1Xb4ne6+sBrCzI0"
118
+
}
119
+
}`
120
+
cidOne, err := cid.Decode("bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a")
121
+
assert.NoError(err)
122
+
goObj := ipldOldSchema{
123
+
A: LexLink(cidOne),
124
+
B: LexBytes([]byte{
125
+
156, 81, 17, 142, 242, 203, 139, 15, 106, 155, 142, 73, 174, 161, 253,
126
+
65, 60, 242, 11, 98, 238, 213, 118, 248, 157, 238, 190, 176, 26, 194,
127
+
204, 141,
128
+
}),
129
+
}
130
+
cborBytes := []byte{162, 97, 97, 216, 42, 88, 37, 0, 1, 113, 18, 32, 101, 6, 42, 90, 90, 0,
131
+
252, 22, 215, 60, 105, 68, 35, 124, 203, 193, 91, 28, 74, 114, 52, 72,
132
+
147, 54, 137, 29, 9, 23, 65, 162, 57, 208, 97, 98, 88, 32, 156, 81, 17,
133
+
142, 242, 203, 139, 15, 106, 155, 142, 73, 174, 161, 253, 65, 60, 242, 11,
134
+
98, 238, 213, 118, 248, 157, 238, 190, 176, 26, 194, 204, 141}
135
+
cidStr := "bafyreif37nlcsyb4ckm2i7y3w2ctnebzkib7ekzmv3tvl3mo5og2gxot5y"
136
+
137
+
// easier commenting out of code during development
138
+
_ = assert
139
+
_ = jsonStr
140
+
_ = goObj
141
+
_ = cidStr
142
+
_ = bytes.NewReader(cborBytes)
143
+
144
+
// basic parsing
145
+
jsonObj := ipldOldSchema{}
146
+
assert.NoError(json.Unmarshal([]byte(jsonStr), &jsonObj))
147
+
cborObj := ipldOldSchema{}
148
+
assert.NoError(cborObj.UnmarshalCBOR(bytes.NewReader(cborBytes)))
149
+
150
+
// compare parsed against known object
151
+
assert.Equal(goObj, jsonObj)
152
+
assert.Equal(goObj, cborObj)
153
+
154
+
// reproduce CBOR serialization
155
+
goCborBytes := new(bytes.Buffer)
156
+
assert.NoError(goObj.MarshalCBOR(goCborBytes))
157
+
assert.Equal(cborBytes, goCborBytes.Bytes())
158
+
// 0x71 = dag-cbor, 0x12 = sha2-256, 0 = default length
159
+
cidBuilder := cid.V1Builder{0x71, 0x12, 0}
160
+
goCborCid, err := cidBuilder.Sum(goCborBytes.Bytes())
161
+
assert.NoError(err)
162
+
assert.Equal(cidStr, goCborCid.String())
163
+
164
+
// reproduce JSON serialization
165
+
var jsonAll interface{}
166
+
assert.NoError(json.Unmarshal([]byte(jsonStr), &jsonAll))
167
+
goJsonBytes, err := json.Marshal(goObj)
168
+
assert.NoError(err)
169
+
var goJsonAll interface{}
170
+
assert.NoError(json.Unmarshal(goJsonBytes, &goJsonAll))
171
+
assert.Equal(jsonAll, goJsonAll)
172
+
}
+75
-112
lex/util/lex_test.go
lex/util/lex_interop_test.go
+75
-112
lex/util/lex_test.go
lex/util/lex_interop_test.go
···
11
11
)
12
12
13
13
type basicSchema struct {
14
-
A string `json:"a" cborgen:"a"`
15
-
B int64 `json:"b" cborgen:"b"`
16
-
C bool `json:"c" cborgen:"c"`
17
-
D *string `json:"d,omitempty" cborgen:"d,omitempty"`
18
-
E *string `json:"e" cborgen:"e"`
19
-
F []string `json:"f" cborgen:"f"`
20
-
G basicSchemaInner `json:"g" cborgen:"g"`
14
+
String string `json:"string" cborgen:"string"`
15
+
Unicode string `json:"unicode" cborgen:"unicode"`
16
+
Integer int64 `json:"integer" cborgen:"integer"`
17
+
Bool bool `json:"bool" cborgen:"bool"`
18
+
Null *string `json:"null" cborgen:"null"`
19
+
Absent *string `json:"absent,omitempty" cborgen:"absent,omitempty"`
20
+
Array []string `json:"array" cborgen:"array"`
21
+
Object basicSchemaInner `json:"object" cborgen:"object"`
21
22
}
22
23
23
24
type basicSchemaInner struct {
24
-
H string `json:"h" cborgen:"h"`
25
-
I int64 `json:"i" cborgen:"i"`
26
-
J bool `json:"j" cborgen:"j"`
27
-
K []string `json:"k" cborgen:"k"`
25
+
String string `json:"string" cborgen:"string"`
26
+
Number int64 `json:"number" cborgen:"number"`
27
+
Bool bool `json:"bool" cborgen:"bool"`
28
+
Arr []string `json:"arr" cborgen:"arr"`
28
29
}
29
30
30
31
type ipldSchema struct {
31
32
A LexLink `json:"a" cborgen:"a"`
32
33
B LexBytes `json:"b" cborgen:"b"`
34
+
C LexBlob `json:"c" cborgen:"c"`
33
35
}
34
36
35
37
type ipldNestedSchema struct {
···
47
49
}
48
50
49
51
func TestCborGen(t *testing.T) {
50
-
if err := cbg.WriteMapEncodersToFile("cbor_gen_test.go", "util", basicSchema{}, basicSchemaInner{}, ipldSchema{}); err != nil {
52
+
if err := cbg.WriteMapEncodersToFile("cbor_gen_test.go", "util", basicSchema{}, basicSchemaInner{}, ipldSchema{}, basicOldSchema{}, basicOldSchemaInner{}, ipldOldSchema{}); err != nil {
51
53
t.Fatal(err)
52
54
}
53
55
}
···
55
57
func TestInteropBasicSchema(t *testing.T) {
56
58
assert := assert.New(t)
57
59
jsonStr := `{
58
-
"a": "abc",
59
-
"b": 123,
60
-
"c": true,
61
-
"e": null,
62
-
"f": ["abc", "def", "ghi"],
63
-
"g": {
64
-
"h": "abc",
65
-
"i": 123,
66
-
"j": true,
67
-
"k": ["abc", "def", "ghi"]
60
+
"string": "abc",
61
+
"unicode": "a~öñ©⽘☎𓋓😀👨👩👧👧",
62
+
"integer": 123,
63
+
"bool": true,
64
+
"null": null,
65
+
"array": ["abc", "def", "ghi"],
66
+
"object": {
67
+
"string": "abc",
68
+
"number": 123,
69
+
"bool": true,
70
+
"arr": ["abc", "def", "ghi"]
68
71
}
69
72
}`
70
73
goObj := basicSchema{
71
-
A: "abc",
72
-
B: 123,
73
-
C: true,
74
-
D: nil,
75
-
E: nil,
76
-
F: []string{"abc", "def", "ghi"},
77
-
G: basicSchemaInner{
78
-
H: "abc",
79
-
I: 123,
80
-
J: true,
81
-
K: []string{"abc", "def", "ghi"},
74
+
String: "abc",
75
+
Unicode: "a~öñ©⽘☎𓋓😀👨👩👧👧",
76
+
Integer: 123,
77
+
Bool: true,
78
+
Null: nil,
79
+
Absent: nil,
80
+
Array: []string{"abc", "def", "ghi"},
81
+
Object: basicSchemaInner{
82
+
String: "abc",
83
+
Number: 123,
84
+
Bool: true,
85
+
Arr: []string{"abc", "def", "ghi"},
82
86
},
83
87
}
84
-
cborBytes := []byte{166, 97, 97, 99, 97, 98, 99, 97, 98, 24, 123, 97, 99, 245, 97, 101, 246,
85
-
97, 102, 131, 99, 97, 98, 99, 99, 100, 101, 102, 99, 103, 104, 105, 97,
86
-
103, 164, 97, 104, 99, 97, 98, 99, 97, 105, 24, 123, 97, 106, 245, 97,
87
-
107, 131, 99, 97, 98, 99, 99, 100, 101, 102, 99, 103, 104, 105}
88
-
cidStr := "bafyreiaioukcatdbdltzqznmyqmwgpgmoex62tkwqtdmganxgv3v5bn2o4"
88
+
cborBytes := []byte{
89
+
167, 100, 98, 111, 111, 108, 245, 100, 110, 117, 108, 108, 246, 101, 97,
90
+
114, 114, 97, 121, 131, 99, 97, 98, 99, 99, 100, 101, 102, 99, 103, 104,
91
+
105, 102, 111, 98, 106, 101, 99, 116, 164, 99, 97, 114, 114, 131, 99, 97,
92
+
98, 99, 99, 100, 101, 102, 99, 103, 104, 105, 100, 98, 111, 111, 108, 245,
93
+
102, 110, 117, 109, 98, 101, 114, 24, 123, 102, 115, 116, 114, 105, 110,
94
+
103, 99, 97, 98, 99, 102, 115, 116, 114, 105, 110, 103, 99, 97, 98, 99,
95
+
103, 105, 110, 116, 101, 103, 101, 114, 24, 123, 103, 117, 110, 105, 99,
96
+
111, 100, 101, 120, 47, 97, 126, 195, 182, 195, 177, 194, 169, 226, 189,
97
+
152, 226, 152, 142, 240, 147, 139, 147, 240, 159, 152, 128, 240, 159, 145,
98
+
168, 226, 128, 141, 240, 159, 145, 169, 226, 128, 141, 240, 159, 145, 167,
99
+
226, 128, 141, 240, 159, 145, 167,
100
+
}
101
+
cidStr := "bafyreiclp443lavogvhj3d2ob2cxbfuscni2k5jk7bebjzg7khl3esabwq"
89
102
90
103
// easier commenting out of code during development
91
104
_ = assert
···
133
146
},
134
147
"b": {
135
148
"$bytes": "nFERjvLLiw9qm45JrqH9QTzyC2Lu1Xb4ne6+sBrCzI0"
149
+
},
150
+
"c": {
151
+
"$type": "blob",
152
+
"ref": {
153
+
"$link": "bafkreiccldh766hwcnuxnf2wh6jgzepf2nlu2lvcllt63eww5p6chi4ity"
154
+
},
155
+
"mimeType": "image/jpeg",
156
+
"size": 10000
136
157
}
137
158
}`
138
159
cidOne, err := cid.Decode("bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a")
139
160
assert.NoError(err)
161
+
cidTwo, err := cid.Decode("bafkreiccldh766hwcnuxnf2wh6jgzepf2nlu2lvcllt63eww5p6chi4ity")
162
+
assert.NoError(err)
140
163
goObj := ipldSchema{
141
164
A: LexLink(cidOne),
142
165
B: LexBytes([]byte{
···
144
167
65, 60, 242, 11, 98, 238, 213, 118, 248, 157, 238, 190, 176, 26, 194,
145
168
204, 141,
146
169
}),
170
+
C: LexBlob{
171
+
Ref: LexLink(cidTwo),
172
+
MimeType: "image/jpeg",
173
+
Size: 10000,
174
+
},
147
175
}
148
-
cborBytes := []byte{162, 97, 97, 216, 42, 88, 37, 0, 1, 113, 18, 32, 101, 6, 42, 90, 90, 0,
176
+
cborBytes := []byte{163, 97, 97, 216, 42, 88, 37, 0, 1, 113, 18, 32, 101, 6, 42, 90, 90, 0,
149
177
252, 22, 215, 60, 105, 68, 35, 124, 203, 193, 91, 28, 74, 114, 52, 72,
150
178
147, 54, 137, 29, 9, 23, 65, 162, 57, 208, 97, 98, 88, 32, 156, 81, 17,
151
179
142, 242, 203, 139, 15, 106, 155, 142, 73, 174, 161, 253, 65, 60, 242, 11,
152
-
98, 238, 213, 118, 248, 157, 238, 190, 176, 26, 194, 204, 141}
153
-
cidStr := "bafyreif37nlcsyb4ckm2i7y3w2ctnebzkib7ekzmv3tvl3mo5og2gxot5y"
180
+
98, 238, 213, 118, 248, 157, 238, 190, 176, 26, 194, 204, 141, 97, 99,
181
+
164, 99, 114, 101, 102, 216, 42, 88, 37, 0, 1, 85, 18, 32, 66, 88, 207,
182
+
255, 120, 246, 19, 105, 118, 151, 86, 63, 146, 108, 145, 229, 211, 87, 77,
183
+
46, 162, 90, 231, 237, 146, 214, 235, 252, 35, 163, 136, 158, 100, 115,
184
+
105, 122, 101, 25, 39, 16, 101, 36, 116, 121, 112, 101, 100, 98, 108, 111,
185
+
98, 104, 109, 105, 109, 101, 84, 121, 112, 101, 106, 105, 109, 97, 103,
186
+
101, 47, 106, 112, 101, 103}
187
+
cidStr := "bafyreihldkhcwijkde7gx4rpkkuw7pl6lbyu5gieunyc7ihactn5bkd2nm"
154
188
155
189
// easier commenting out of code during development
156
190
_ = assert
···
286
320
assert.Equal(cidStr, goCborCid.String())
287
321
*/
288
322
}
289
-
290
-
type blobSchema struct {
291
-
A string `json:"a" cborgen:"a"`
292
-
B LexBlob `json:"b" cborgen:"b"`
293
-
}
294
-
295
-
func TestBlobParse(t *testing.T) {
296
-
assert := assert.New(t)
297
-
jsonStr := `{
298
-
"a": "abc",
299
-
"b": {
300
-
"$type": "blob",
301
-
"ref": {
302
-
"$link": "bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a"
303
-
},
304
-
"mimeType": "image/png",
305
-
"size": 12345
306
-
}
307
-
}`
308
-
cidOne, err := cid.Decode("bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a")
309
-
goObj := blobSchema{
310
-
A: "abc",
311
-
B: LexBlob{
312
-
Ref: LexLink(cidOne),
313
-
MimeType: "image/png",
314
-
Size: 12345,
315
-
},
316
-
}
317
-
jsonStrLegacy := `{
318
-
"a": "abc",
319
-
"b": {
320
-
"cid": "bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a",
321
-
"mimeType": "image/png"
322
-
}
323
-
}`
324
-
goObjLegacy := blobSchema{
325
-
A: "abc",
326
-
B: LexBlob{
327
-
Ref: LexLink(cidOne),
328
-
MimeType: "image/png",
329
-
Size: -1,
330
-
},
331
-
}
332
-
333
-
// basic parsing
334
-
jsonObj := blobSchema{}
335
-
assert.NoError(json.Unmarshal([]byte(jsonStr), &jsonObj))
336
-
jsonObjLegacy := blobSchema{}
337
-
assert.NoError(json.Unmarshal([]byte(jsonStrLegacy), &jsonObjLegacy))
338
-
339
-
// compare parsed against known object
340
-
assert.Equal(goObj, jsonObj)
341
-
assert.Equal(goObjLegacy, jsonObjLegacy)
342
-
343
-
// reproduce JSON serialization
344
-
var jsonAll interface{}
345
-
assert.NoError(json.Unmarshal([]byte(jsonStr), &jsonAll))
346
-
goJsonBytes, err := json.Marshal(goObj)
347
-
assert.NoError(err)
348
-
var goJsonAll interface{}
349
-
assert.NoError(json.Unmarshal(goJsonBytes, &goJsonAll))
350
-
assert.Equal(jsonAll, goJsonAll)
351
-
352
-
var jsonAllLegacy interface{}
353
-
assert.NoError(json.Unmarshal([]byte(jsonStrLegacy), &jsonAllLegacy))
354
-
goJsonBytesLegacy, err := json.Marshal(goObjLegacy)
355
-
assert.NoError(err)
356
-
var goJsonAllLegacy interface{}
357
-
assert.NoError(json.Unmarshal(goJsonBytesLegacy, &goJsonAllLegacy))
358
-
assert.Equal(jsonAllLegacy, goJsonAllLegacy)
359
-
}
+80
lex/util/lex_types_test.go
+80
lex/util/lex_types_test.go
···
1
+
package util
2
+
3
+
import (
4
+
"encoding/json"
5
+
"testing"
6
+
7
+
"github.com/ipfs/go-cid"
8
+
"github.com/stretchr/testify/assert"
9
+
)
10
+
11
+
type blobSchema struct {
12
+
A string `json:"a" cborgen:"a"`
13
+
B LexBlob `json:"b" cborgen:"b"`
14
+
}
15
+
16
+
func TestBlobParse(t *testing.T) {
17
+
assert := assert.New(t)
18
+
jsonStr := `{
19
+
"a": "abc",
20
+
"b": {
21
+
"$type": "blob",
22
+
"ref": {
23
+
"$link": "bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a"
24
+
},
25
+
"mimeType": "image/png",
26
+
"size": 12345
27
+
}
28
+
}`
29
+
cidOne, err := cid.Decode("bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a")
30
+
goObj := blobSchema{
31
+
A: "abc",
32
+
B: LexBlob{
33
+
Ref: LexLink(cidOne),
34
+
MimeType: "image/png",
35
+
Size: 12345,
36
+
},
37
+
}
38
+
jsonStrLegacy := `{
39
+
"a": "abc",
40
+
"b": {
41
+
"cid": "bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a",
42
+
"mimeType": "image/png"
43
+
}
44
+
}`
45
+
goObjLegacy := blobSchema{
46
+
A: "abc",
47
+
B: LexBlob{
48
+
Ref: LexLink(cidOne),
49
+
MimeType: "image/png",
50
+
Size: -1,
51
+
},
52
+
}
53
+
54
+
// basic parsing
55
+
jsonObj := blobSchema{}
56
+
assert.NoError(json.Unmarshal([]byte(jsonStr), &jsonObj))
57
+
jsonObjLegacy := blobSchema{}
58
+
assert.NoError(json.Unmarshal([]byte(jsonStrLegacy), &jsonObjLegacy))
59
+
60
+
// compare parsed against known object
61
+
assert.Equal(goObj, jsonObj)
62
+
assert.Equal(goObjLegacy, jsonObjLegacy)
63
+
64
+
// reproduce JSON serialization
65
+
var jsonAll interface{}
66
+
assert.NoError(json.Unmarshal([]byte(jsonStr), &jsonAll))
67
+
goJsonBytes, err := json.Marshal(goObj)
68
+
assert.NoError(err)
69
+
var goJsonAll interface{}
70
+
assert.NoError(json.Unmarshal(goJsonBytes, &goJsonAll))
71
+
assert.Equal(jsonAll, goJsonAll)
72
+
73
+
var jsonAllLegacy interface{}
74
+
assert.NoError(json.Unmarshal([]byte(jsonStrLegacy), &jsonAllLegacy))
75
+
goJsonBytesLegacy, err := json.Marshal(goObjLegacy)
76
+
assert.NoError(err)
77
+
var goJsonAllLegacy interface{}
78
+
assert.NoError(json.Unmarshal(goJsonBytesLegacy, &goJsonAllLegacy))
79
+
assert.Equal(jsonAllLegacy, goJsonAllLegacy)
80
+
}