keys_test.go raw
1 package indexes
2
3 import (
4 "bytes"
5 "io"
6 "testing"
7
8 "next.orly.dev/pkg/lol/chk"
9 "next.orly.dev/pkg/database/indexes/types"
10 "next.orly.dev/pkg/utils"
11 )
12
13 // TestNewPrefix tests the NewPrefix function with and without arguments
14 func TestNewPrefix(t *testing.T) {
15 // Test with no arguments (default prefix)
16 defaultPrefix := NewPrefix()
17 if len(defaultPrefix.Bytes()) != 3 {
18 t.Errorf(
19 "Default prefix should be 3 bytes, got %d",
20 len(defaultPrefix.Bytes()),
21 )
22 }
23
24 // Test with a valid prefix index
25 validPrefix := NewPrefix(Event)
26 if string(validPrefix.Bytes()) != string(EventPrefix) {
27 t.Errorf("Expected prefix %q, got %q", EventPrefix, validPrefix.Bytes())
28 }
29
30 // Test with an invalid prefix index (should panic)
31 defer func() {
32 if r := recover(); r == nil {
33 t.Errorf("NewPrefix should panic with invalid prefix index")
34 }
35 }()
36 _ = NewPrefix(-1) // This should panic
37 }
38
39 // TestPrefixMethods tests the methods of the P struct
40 func TestPrefixMethods(t *testing.T) {
41 // Create a prefix
42 prefix := NewPrefix(Event)
43
44 // Test Bytes method
45 if !utils.FastEqual(prefix.Bytes(), []byte(EventPrefix)) {
46 t.Errorf(
47 "Bytes method returned %v, expected %v", prefix.Bytes(),
48 []byte(EventPrefix),
49 )
50 }
51
52 // Test MarshalWrite method
53 buf := new(bytes.Buffer)
54 err := prefix.MarshalWrite(buf)
55 if chk.E(err) {
56 t.Fatalf("MarshalWrite failed: %v", err)
57 }
58 if !utils.FastEqual(buf.Bytes(), []byte(EventPrefix)) {
59 t.Errorf(
60 "MarshalWrite wrote %v, expected %v", buf.Bytes(),
61 []byte(EventPrefix),
62 )
63 }
64
65 // Test UnmarshalRead method
66 newPrefix := &P{}
67 err = newPrefix.UnmarshalRead(bytes.NewBuffer(buf.Bytes()))
68 if chk.E(err) {
69 t.Fatalf("UnmarshalRead failed: %v", err)
70 }
71 if !utils.FastEqual(newPrefix.Bytes(), []byte(EventPrefix)) {
72 t.Errorf(
73 "UnmarshalRead read %v, expected %v", newPrefix.Bytes(),
74 []byte(EventPrefix),
75 )
76 }
77 }
78
79 // TestPrefixFunction tests the Prefix function
80 func TestPrefixFunction(t *testing.T) {
81 testCases := []struct {
82 name string
83 index int
84 expected I
85 }{
86 {"Event", Event, EventPrefix},
87 {"ID", Id, IdPrefix},
88 {"FullIdPubkey", FullIdPubkey, FullIdPubkeyPrefix},
89 {"Pubkey", Pubkey, PubkeyPrefix},
90 {"CreatedAt", CreatedAt, CreatedAtPrefix},
91 {"TagPubkey", TagPubkey, TagPubkeyPrefix},
92 {"Tag", Tag, TagPrefix},
93 {"Kind", Kind, KindPrefix},
94 {"KindPubkey", KindPubkey, KindPubkeyPrefix},
95 {"TagKind", TagKind, TagKindPrefix},
96 {
97 "TagKindPubkey", TagKindPubkey,
98 TagKindPubkeyPrefix,
99 },
100 {"Invalid", -1, ""},
101 }
102
103 for _, tc := range testCases {
104 t.Run(
105 tc.name, func(t *testing.T) {
106 result := Prefix(tc.index)
107 if result != tc.expected {
108 t.Errorf(
109 "Prefix(%d) = %q, expected %q", tc.index, result,
110 tc.expected,
111 )
112 }
113 },
114 )
115 }
116 }
117
118 // TestIdentify tests the Identify function
119 func TestIdentify(t *testing.T) {
120 testCases := []struct {
121 name string
122 prefix I
123 expected int
124 }{
125 {"Event", EventPrefix, Event},
126 {"ID", IdPrefix, Id},
127 {"FullIdPubkey", FullIdPubkeyPrefix, FullIdPubkey},
128 {"Pubkey", PubkeyPrefix, Pubkey},
129 {"CreatedAt", CreatedAtPrefix, CreatedAt},
130 {"TagPubkey", TagPubkeyPrefix, TagPubkey},
131 {"Tag", TagPrefix, Tag},
132 {"Kind", KindPrefix, Kind},
133 {"KindPubkey", KindPubkeyPrefix, KindPubkey},
134 {"TagKind", TagKindPrefix, TagKind},
135 {
136 "TagKindPubkey", TagKindPubkeyPrefix,
137 TagKindPubkey,
138 },
139 }
140
141 for _, tc := range testCases {
142 t.Run(
143 tc.name, func(t *testing.T) {
144 result, err := Identify(bytes.NewReader([]byte(tc.prefix)))
145 if chk.E(err) {
146 t.Fatalf("Identify failed: %v", err)
147 }
148 if result != tc.expected {
149 t.Errorf(
150 "Identify(%q) = %d, expected %d", tc.prefix, result,
151 tc.expected,
152 )
153 }
154 },
155 )
156 }
157
158 // Test with invalid data
159 t.Run(
160 "Invalid", func(t *testing.T) {
161 result, err := Identify(bytes.NewReader([]byte("xyz")))
162 if chk.E(err) {
163 t.Fatalf("Identify failed: %v", err)
164 }
165 if result != 0 {
166 t.Errorf(
167 "Identify with invalid prefix should return 0, got %d",
168 result,
169 )
170 }
171 },
172 )
173
174 // Test with error from reader
175 t.Run(
176 "ReaderError", func(t *testing.T) {
177 errReader := &errorReader{}
178 result, err := Identify(errReader)
179 if err == nil {
180 t.Errorf("Identify should return error with failing reader")
181 }
182 if result != -1 {
183 t.Errorf(
184 "Identify with reader error should return -1, got %d",
185 result,
186 )
187 }
188 },
189 )
190 }
191
192 // errorReader is a mock reader that always returns an error
193 type errorReader struct{}
194
195 func (e *errorReader) Read(p []byte) (n int, err error) {
196 return 0, io.ErrUnexpectedEOF
197 }
198
199 // TestTStruct tests the T struct and its methods
200 func TestTStruct(t *testing.T) {
201 // Create some test encoders
202 prefix := NewPrefix(Event)
203 ser := new(types.Uint40)
204 ser.Set(12345)
205
206 // Test New function
207 enc := New(prefix, ser)
208 if len(enc.Encs) != 2 {
209 t.Errorf("New should create T with 2 encoders, got %d", len(enc.Encs))
210 }
211
212 // Test MarshalWrite
213 buf := new(bytes.Buffer)
214 err := enc.MarshalWrite(buf)
215 if chk.E(err) {
216 t.Fatalf("MarshalWrite failed: %v", err)
217 }
218
219 // Test UnmarshalRead
220 dec := New(NewPrefix(), new(types.Uint40))
221 err = dec.UnmarshalRead(bytes.NewBuffer(buf.Bytes()))
222 if chk.E(err) {
223 t.Fatalf("UnmarshalRead failed: %v", err)
224 }
225
226 // Verify the decoded values
227 decodedPrefix := dec.Encs[0].(*P)
228 decodedSer := dec.Encs[1].(*types.Uint40)
229 if !utils.FastEqual(decodedPrefix.Bytes(), prefix.Bytes()) {
230 t.Errorf(
231 "Decoded prefix %v, expected %v", decodedPrefix.Bytes(),
232 prefix.Bytes(),
233 )
234 }
235 if decodedSer.Get() != ser.Get() {
236 t.Errorf("Decoded serial %d, expected %d", decodedSer.Get(), ser.Get())
237 }
238
239 // Test with nil encoder
240 encWithNil := New(prefix, nil, ser)
241 buf.Reset()
242 err = encWithNil.MarshalWrite(buf)
243 if chk.E(err) {
244 t.Fatalf("MarshalWrite with nil encoder failed: %v", err)
245 }
246 }
247
248 // TestEventFunctions tests the Event-related functions
249 func TestEventFunctions(t *testing.T) {
250 // Test EventVars
251 ser := EventVars()
252 if ser == nil {
253 t.Fatalf("EventVars should return non-nil *types.Uint40")
254 }
255
256 // Set a value
257 ser.Set(12345)
258
259 // Test EventEnc
260 enc := EventEnc(ser)
261 if len(enc.Encs) != 2 {
262 t.Errorf(
263 "EventEnc should create T with 2 encoders, got %d", len(enc.Encs),
264 )
265 }
266
267 // Test EventDec
268 dec := EventDec(ser)
269 if len(dec.Encs) != 2 {
270 t.Errorf(
271 "EventDec should create T with 2 encoders, got %d", len(dec.Encs),
272 )
273 }
274
275 // Test marshaling and unmarshaling
276 buf := new(bytes.Buffer)
277 err := enc.MarshalWrite(buf)
278 if chk.E(err) {
279 t.Fatalf("MarshalWrite failed: %v", err)
280 }
281
282 // Create new variables for decoding
283 newSer := new(types.Uint40)
284 newDec := EventDec(newSer)
285
286 err = newDec.UnmarshalRead(bytes.NewBuffer(buf.Bytes()))
287 if chk.E(err) {
288 t.Fatalf("UnmarshalRead failed: %v", err)
289 }
290
291 // Verify the decoded value
292 if newSer.Get() != ser.Get() {
293 t.Errorf("Decoded serial %d, expected %d", newSer.Get(), ser.Get())
294 }
295 }
296
297 // TestIdFunctions tests the Id-related functions
298 func TestIdFunctions(t *testing.T) {
299 // Test IdVars
300 id, ser := IdVars()
301 if id == nil || ser == nil {
302 t.Fatalf("IdVars should return non-nil *types.IdHash and *types.Uint40")
303 }
304
305 // Set values
306 id.Set([]byte{1, 2, 3, 4, 5, 6, 7, 8})
307 ser.Set(12345)
308
309 // Test IdEnc
310 enc := IdEnc(id, ser)
311 if len(enc.Encs) != 3 {
312 t.Errorf("IdEnc should create T with 3 encoders, got %d", len(enc.Encs))
313 }
314
315 // Test IdDec
316 dec := IdDec(id, ser)
317 if len(dec.Encs) != 3 {
318 t.Errorf("IdDec should create T with 3 encoders, got %d", len(dec.Encs))
319 }
320
321 // Test marshaling and unmarshaling
322 buf := new(bytes.Buffer)
323 err := enc.MarshalWrite(buf)
324 if chk.E(err) {
325 t.Fatalf("MarshalWrite failed: %v", err)
326 }
327
328 // Create new variables for decoding
329 newId, newSer := IdVars()
330 newDec := IdDec(newId, newSer)
331
332 err = newDec.UnmarshalRead(bytes.NewBuffer(buf.Bytes()))
333 if chk.E(err) {
334 t.Fatalf("UnmarshalRead failed: %v", err)
335 }
336
337 // Verify the decoded values
338 if !utils.FastEqual(newId.Bytes(), id.Bytes()) {
339 t.Errorf("Decoded id %v, expected %v", newId.Bytes(), id.Bytes())
340 }
341 if newSer.Get() != ser.Get() {
342 t.Errorf("Decoded serial %d, expected %d", newSer.Get(), ser.Get())
343 }
344 }
345
346 // TestIdPubkeyFunctions tests the FullIdPubkey-related functions
347 func TestIdPubkeyFunctions(t *testing.T) {
348 // Test FullIdPubkeyVars
349 ser, fid, p, ca := FullIdPubkeyVars()
350 if ser == nil || fid == nil || p == nil || ca == nil {
351 t.Fatalf("FullIdPubkeyVars should return non-nil values")
352 }
353
354 // Set values
355 ser.Set(12345)
356 err := fid.FromId(
357 []byte{
358 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
359 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
360 },
361 )
362 if chk.E(err) {
363 t.Fatalf("FromId failed: %v", err)
364 }
365 err = p.FromPubkey(
366 []byte{
367 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
368 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
369 },
370 )
371 if chk.E(err) {
372 t.Fatalf("FromPubkey failed: %v", err)
373 }
374 ca.Set(98765)
375
376 // Test FullIdPubkeyEnc
377 enc := FullIdPubkeyEnc(ser, fid, p, ca)
378 if len(enc.Encs) != 5 {
379 t.Errorf(
380 "FullIdPubkeyEnc should create T with 5 encoders, got %d",
381 len(enc.Encs),
382 )
383 }
384
385 // Test FullIdPubkeyDec
386 dec := FullIdPubkeyDec(ser, fid, p, ca)
387 if len(dec.Encs) != 5 {
388 t.Errorf(
389 "FullIdPubkeyDec should create T with 5 encoders, got %d",
390 len(dec.Encs),
391 )
392 }
393
394 // Test marshaling and unmarshaling
395 buf := new(bytes.Buffer)
396 err = enc.MarshalWrite(buf)
397 if chk.E(err) {
398 t.Fatalf("MarshalWrite failed: %v", err)
399 }
400
401 // Create new variables for decoding
402 newSer, newFid, newP, newCa := FullIdPubkeyVars()
403 newDec := FullIdPubkeyDec(newSer, newFid, newP, newCa)
404
405 err = newDec.UnmarshalRead(bytes.NewBuffer(buf.Bytes()))
406 if chk.E(err) {
407 t.Fatalf("UnmarshalRead failed: %v", err)
408 }
409
410 // Verify the decoded values
411 if newSer.Get() != ser.Get() {
412 t.Errorf("Decoded serial %d, expected %d", newSer.Get(), ser.Get())
413 }
414 if !utils.FastEqual(newFid.Bytes(), fid.Bytes()) {
415 t.Errorf("Decoded id %v, expected %v", newFid.Bytes(), fid.Bytes())
416 }
417 if !utils.FastEqual(newP.Bytes(), p.Bytes()) {
418 t.Errorf("Decoded pubkey hash %v, expected %v", newP.Bytes(), p.Bytes())
419 }
420 if newCa.Get() != ca.Get() {
421 t.Errorf("Decoded created at %d, expected %d", newCa.Get(), ca.Get())
422 }
423 }
424
425 // TestCreatedAtFunctions tests the CreatedAt-related functions
426 func TestCreatedAtFunctions(t *testing.T) {
427 // Test CreatedAtVars
428 ca, ser := CreatedAtVars()
429 if ca == nil || ser == nil {
430 t.Fatalf("CreatedAtVars should return non-nil values")
431 }
432
433 // Set values
434 ca.Set(98765)
435 ser.Set(12345)
436
437 // Test CreatedAtEnc
438 enc := CreatedAtEnc(ca, ser)
439 if len(enc.Encs) != 3 {
440 t.Errorf(
441 "CreatedAtEnc should create T with 3 encoders, got %d",
442 len(enc.Encs),
443 )
444 }
445
446 // Test CreatedAtDec
447 dec := CreatedAtDec(ca, ser)
448 if len(dec.Encs) != 3 {
449 t.Errorf(
450 "CreatedAtDec should create T with 3 encoders, got %d",
451 len(dec.Encs),
452 )
453 }
454
455 // Test marshaling and unmarshaling
456 buf := new(bytes.Buffer)
457 err := enc.MarshalWrite(buf)
458 if chk.E(err) {
459 t.Fatalf("MarshalWrite failed: %v", err)
460 }
461
462 // Create new variables for decoding
463 newCa, newSer := CreatedAtVars()
464 newDec := CreatedAtDec(newCa, newSer)
465
466 err = newDec.UnmarshalRead(bytes.NewBuffer(buf.Bytes()))
467 if chk.E(err) {
468 t.Fatalf("UnmarshalRead failed: %v", err)
469 }
470
471 // Verify the decoded values
472 if newCa.Get() != ca.Get() {
473 t.Errorf("Decoded created at %d, expected %d", newCa.Get(), ca.Get())
474 }
475 if newSer.Get() != ser.Get() {
476 t.Errorf("Decoded serial %d, expected %d", newSer.Get(), ser.Get())
477 }
478 }
479
480 // TestPubkeyFunctions tests the Pubkey-related functions
481 func TestPubkeyFunctions(t *testing.T) {
482 // Test PubkeyVars
483 p, ca, ser := PubkeyVars()
484 if p == nil || ca == nil || ser == nil {
485 t.Fatalf("PubkeyVars should return non-nil values")
486 }
487
488 // Set values
489 err := p.FromPubkey(
490 []byte{
491 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
492 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
493 },
494 )
495 if chk.E(err) {
496 t.Fatalf("FromPubkey failed: %v", err)
497 }
498 ca.Set(98765)
499 ser.Set(12345)
500
501 // Test PubkeyEnc
502 enc := PubkeyEnc(p, ca, ser)
503 if len(enc.Encs) != 4 {
504 t.Errorf(
505 "PubkeyEnc should create T with 4 encoders, got %d",
506 len(enc.Encs),
507 )
508 }
509
510 // Test PubkeyDec
511 dec := PubkeyDec(p, ca, ser)
512 if len(dec.Encs) != 4 {
513 t.Errorf(
514 "PubkeyDec should create T with 4 encoders, got %d",
515 len(dec.Encs),
516 )
517 }
518
519 // Test marshaling and unmarshaling
520 buf := new(bytes.Buffer)
521 err = enc.MarshalWrite(buf)
522 if chk.E(err) {
523 t.Fatalf("MarshalWrite failed: %v", err)
524 }
525
526 // Create new variables for decoding
527 newP, newCa, newSer := PubkeyVars()
528 newDec := PubkeyDec(newP, newCa, newSer)
529
530 err = newDec.UnmarshalRead(bytes.NewBuffer(buf.Bytes()))
531 if chk.E(err) {
532 t.Fatalf("UnmarshalRead failed: %v", err)
533 }
534
535 // Verify the decoded values
536 if !utils.FastEqual(newP.Bytes(), p.Bytes()) {
537 t.Errorf("Decoded pubkey hash %v, expected %v", newP.Bytes(), p.Bytes())
538 }
539 if newCa.Get() != ca.Get() {
540 t.Errorf("Decoded created at %d, expected %d", newCa.Get(), ca.Get())
541 }
542 if newSer.Get() != ser.Get() {
543 t.Errorf("Decoded serial %d, expected %d", newSer.Get(), ser.Get())
544 }
545 }
546
547 // TestPubkeyTagFunctions tests the TagPubkey-related functions
548 func TestPubkeyTagFunctions(t *testing.T) {
549 // Test TagPubkeyVars
550 k, v, p, ca, ser := TagPubkeyVars()
551 if p == nil || k == nil || v == nil || ca == nil || ser == nil {
552 t.Fatalf("TagPubkeyVars should return non-nil values")
553 }
554
555 // Set values
556 err := p.FromPubkey(
557 []byte{
558 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
559 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
560 },
561 )
562 if chk.E(err) {
563 t.Fatalf("FromPubkey failed: %v", err)
564 }
565 k.Set('e')
566 v.FromIdent([]byte("test-value"))
567 if chk.E(err) {
568 t.Fatalf("FromIdent failed: %v", err)
569 }
570 ca.Set(98765)
571 ser.Set(12345)
572
573 // Test TagPubkeyEnc
574 enc := TagPubkeyEnc(k, v, p, ca, ser)
575 if len(enc.Encs) != 6 {
576 t.Errorf(
577 "TagPubkeyEnc should create T with 6 encoders, got %d",
578 len(enc.Encs),
579 )
580 }
581
582 // Test TagPubkeyDec
583 dec := TagPubkeyDec(k, v, p, ca, ser)
584 if len(dec.Encs) != 6 {
585 t.Errorf(
586 "TagPubkeyDec should create T with 6 encoders, got %d",
587 len(dec.Encs),
588 )
589 }
590
591 // Test marshaling and unmarshaling
592 buf := new(bytes.Buffer)
593 err = enc.MarshalWrite(buf)
594 if chk.E(err) {
595 t.Fatalf("MarshalWrite failed: %v", err)
596 }
597
598 // Create new variables for decoding
599 newK, newV, newP, newCa, newSer := TagPubkeyVars()
600 newDec := TagPubkeyDec(newK, newV, newP, newCa, newSer)
601
602 err = newDec.UnmarshalRead(bytes.NewBuffer(buf.Bytes()))
603 if chk.E(err) {
604 t.Fatalf("UnmarshalRead failed: %v", err)
605 }
606
607 // Verify the decoded values
608 if !utils.FastEqual(newP.Bytes(), p.Bytes()) {
609 t.Errorf("Decoded pubkey hash %v, expected %v", newP.Bytes(), p.Bytes())
610 }
611 if newK.Letter() != k.Letter() {
612 t.Errorf(
613 "Decoded key letter %c, expected %c", newK.Letter(), k.Letter(),
614 )
615 }
616 if !utils.FastEqual(newV.Bytes(), v.Bytes()) {
617 t.Errorf("Decoded value hash %v, expected %v", newV.Bytes(), v.Bytes())
618 }
619 if newCa.Get() != ca.Get() {
620 t.Errorf("Decoded created at %d, expected %d", newCa.Get(), ca.Get())
621 }
622 if newSer.Get() != ser.Get() {
623 t.Errorf("Decoded serial %d, expected %d", newSer.Get(), ser.Get())
624 }
625 }
626
627 // TestTagFunctions tests the Tag-related functions
628 func TestTagFunctions(t *testing.T) {
629 var err error
630 // Test TagVars
631 k, v, ca, ser := TagVars()
632 if k == nil || v == nil || ca == nil || ser == nil {
633 t.Fatalf("TagVars should return non-nil values")
634 }
635
636 // Set values
637 k.Set('e')
638 v.FromIdent([]byte("test-value"))
639 if chk.E(err) {
640 t.Fatalf("FromIdent failed: %v", err)
641 }
642 ca.Set(98765)
643 ser.Set(12345)
644
645 // Test TagEnc
646 enc := TagEnc(k, v, ca, ser)
647 if len(enc.Encs) != 5 {
648 t.Errorf(
649 "TagEnc should create T with 5 encoders, got %d",
650 len(enc.Encs),
651 )
652 }
653
654 // Test TagDec
655 dec := TagDec(k, v, ca, ser)
656 if len(dec.Encs) != 5 {
657 t.Errorf(
658 "TagDec should create T with 5 encoders, got %d",
659 len(dec.Encs),
660 )
661 }
662
663 // Test marshaling and unmarshaling
664 buf := new(bytes.Buffer)
665 err = enc.MarshalWrite(buf)
666 if chk.E(err) {
667 t.Fatalf("MarshalWrite failed: %v", err)
668 }
669
670 // Create new variables for decoding
671 newK, newV, newCa, newSer := TagVars()
672 newDec := TagDec(newK, newV, newCa, newSer)
673
674 err = newDec.UnmarshalRead(bytes.NewBuffer(buf.Bytes()))
675 if chk.E(err) {
676 t.Fatalf("UnmarshalRead failed: %v", err)
677 }
678
679 // Verify the decoded values
680 if newK.Letter() != k.Letter() {
681 t.Errorf(
682 "Decoded key letter %c, expected %c", newK.Letter(), k.Letter(),
683 )
684 }
685 if !utils.FastEqual(newV.Bytes(), v.Bytes()) {
686 t.Errorf("Decoded value hash %v, expected %v", newV.Bytes(), v.Bytes())
687 }
688 if newCa.Get() != ca.Get() {
689 t.Errorf("Decoded created at %d, expected %d", newCa.Get(), ca.Get())
690 }
691 if newSer.Get() != ser.Get() {
692 t.Errorf("Decoded serial %d, expected %d", newSer.Get(), ser.Get())
693 }
694 }
695
696 // TestKindFunctions tests the Kind-related functions
697 func TestKindFunctions(t *testing.T) {
698 // Test KindVars
699 ki, ca, ser := KindVars()
700 if ki == nil || ca == nil || ser == nil {
701 t.Fatalf("KindVars should return non-nil values")
702 }
703
704 // Set values
705 ki.Set(1234)
706 ca.Set(98765)
707 ser.Set(12345)
708
709 // Test KindEnc
710 enc := KindEnc(ki, ca, ser)
711 if len(enc.Encs) != 4 {
712 t.Errorf(
713 "KindEnc should create T with 4 encoders, got %d",
714 len(enc.Encs),
715 )
716 }
717
718 // Test KindDec
719 dec := KindDec(ki, ca, ser)
720 if len(dec.Encs) != 4 {
721 t.Errorf(
722 "KindDec should create T with 4 encoders, got %d",
723 len(dec.Encs),
724 )
725 }
726
727 // Test marshaling and unmarshaling
728 buf := new(bytes.Buffer)
729 err := enc.MarshalWrite(buf)
730 if chk.E(err) {
731 t.Fatalf("MarshalWrite failed: %v", err)
732 }
733
734 // Create new variables for decoding
735 newKi, newCa, newSer := KindVars()
736 newDec := KindDec(newKi, newCa, newSer)
737
738 err = newDec.UnmarshalRead(bytes.NewBuffer(buf.Bytes()))
739 if chk.E(err) {
740 t.Fatalf("UnmarshalRead failed: %v", err)
741 }
742
743 // Verify the decoded values
744 if newKi.Get() != ki.Get() {
745 t.Errorf("Decoded kind %d, expected %d", newKi.Get(), ki.Get())
746 }
747 if newCa.Get() != ca.Get() {
748 t.Errorf("Decoded created at %d, expected %d", newCa.Get(), ca.Get())
749 }
750 if newSer.Get() != ser.Get() {
751 t.Errorf("Decoded serial %d, expected %d", newSer.Get(), ser.Get())
752 }
753 }
754
755 // TestKindTagFunctions tests the TagKind-related functions
756 func TestKindTagFunctions(t *testing.T) {
757 var err error
758 // Test TagKindVars
759 k, v, ki, ca, ser := TagKindVars()
760 if ki == nil || k == nil || v == nil || ca == nil || ser == nil {
761 t.Fatalf("TagKindVars should return non-nil values")
762 }
763
764 // Set values
765 ki.Set(1234)
766 k.Set('e')
767 v.FromIdent([]byte("test-value"))
768 if chk.E(err) {
769 t.Fatalf("FromIdent failed: %v", err)
770 }
771 ca.Set(98765)
772 ser.Set(12345)
773
774 // Test TagKindEnc
775 enc := TagKindEnc(k, v, ki, ca, ser)
776 if len(enc.Encs) != 6 {
777 t.Errorf(
778 "TagKindEnc should create T with 6 encoders, got %d",
779 len(enc.Encs),
780 )
781 }
782
783 // Test TagKindDec
784 dec := TagKindDec(k, v, ki, ca, ser)
785 if len(dec.Encs) != 6 {
786 t.Errorf(
787 "TagKindDec should create T with 6 encoders, got %d",
788 len(dec.Encs),
789 )
790 }
791
792 // Test marshaling and unmarshaling
793 buf := new(bytes.Buffer)
794 err = enc.MarshalWrite(buf)
795 if chk.E(err) {
796 t.Fatalf("MarshalWrite failed: %v", err)
797 }
798
799 // Create new variables for decoding
800 newK, newV, newKi, newCa, newSer := TagKindVars()
801 newDec := TagKindDec(newK, newV, newKi, newCa, newSer)
802
803 err = newDec.UnmarshalRead(bytes.NewBuffer(buf.Bytes()))
804 if chk.E(err) {
805 t.Fatalf("UnmarshalRead failed: %v", err)
806 }
807
808 // Verify the decoded values
809 if newKi.Get() != ki.Get() {
810 t.Errorf("Decoded kind %d, expected %d", newKi.Get(), ki.Get())
811 }
812 if newK.Letter() != k.Letter() {
813 t.Errorf(
814 "Decoded key letter %c, expected %c", newK.Letter(), k.Letter(),
815 )
816 }
817 if !utils.FastEqual(newV.Bytes(), v.Bytes()) {
818 t.Errorf("Decoded value hash %v, expected %v", newV.Bytes(), v.Bytes())
819 }
820 if newCa.Get() != ca.Get() {
821 t.Errorf("Decoded created at %d, expected %d", newCa.Get(), ca.Get())
822 }
823 if newSer.Get() != ser.Get() {
824 t.Errorf("Decoded serial %d, expected %d", newSer.Get(), ser.Get())
825 }
826 }
827
828 // TestKindPubkeyFunctions tests the KindPubkey-related functions
829 func TestKindPubkeyFunctions(t *testing.T) {
830 // Test KindPubkeyVars
831 ki, p, ca, ser := KindPubkeyVars()
832 if ki == nil || p == nil || ca == nil || ser == nil {
833 t.Fatalf("KindPubkeyVars should return non-nil values")
834 }
835
836 // Set values
837 ki.Set(1234)
838 err := p.FromPubkey(
839 []byte{
840 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
841 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
842 },
843 )
844 if chk.E(err) {
845 t.Fatalf("FromPubkey failed: %v", err)
846 }
847 ca.Set(98765)
848 ser.Set(12345)
849
850 // Test KindPubkeyEnc
851 enc := KindPubkeyEnc(ki, p, ca, ser)
852 if len(enc.Encs) != 5 {
853 t.Errorf(
854 "KindPubkeyEnc should create T with 5 encoders, got %d",
855 len(enc.Encs),
856 )
857 }
858
859 // Test KindPubkeyDec
860 dec := KindPubkeyDec(ki, p, ca, ser)
861 if len(dec.Encs) != 5 {
862 t.Errorf(
863 "KindPubkeyDec should create T with 5 encoders, got %d",
864 len(dec.Encs),
865 )
866 }
867
868 // Test marshaling and unmarshaling
869 buf := new(bytes.Buffer)
870 err = enc.MarshalWrite(buf)
871 if chk.E(err) {
872 t.Fatalf("MarshalWrite failed: %v", err)
873 }
874
875 // Create new variables for decoding
876 newKi, newP, newCa, newSer := KindPubkeyVars()
877 newDec := KindPubkeyDec(newKi, newP, newCa, newSer)
878
879 err = newDec.UnmarshalRead(bytes.NewBuffer(buf.Bytes()))
880 if chk.E(err) {
881 t.Fatalf("UnmarshalRead failed: %v", err)
882 }
883
884 // Verify the decoded values
885 if newKi.Get() != ki.Get() {
886 t.Errorf("Decoded kind %d, expected %d", newKi.Get(), ki.Get())
887 }
888 if !utils.FastEqual(newP.Bytes(), p.Bytes()) {
889 t.Errorf("Decoded pubkey hash %v, expected %v", newP.Bytes(), p.Bytes())
890 }
891 if newCa.Get() != ca.Get() {
892 t.Errorf("Decoded created at %d, expected %d", newCa.Get(), ca.Get())
893 }
894 if newSer.Get() != ser.Get() {
895 t.Errorf("Decoded serial %d, expected %d", newSer.Get(), ser.Get())
896 }
897 }
898
899 // TestKindPubkeyTagFunctions tests the TagKindPubkey-related functions
900 func TestKindPubkeyTagFunctions(t *testing.T) {
901 // Test TagKindPubkeyVars
902 k, v, ki, p, ca, ser := TagKindPubkeyVars()
903 if ki == nil || p == nil || k == nil || v == nil || ca == nil || ser == nil {
904 t.Fatalf("TagKindPubkeyVars should return non-nil values")
905 }
906
907 // Set values
908 ki.Set(1234)
909 err := p.FromPubkey(
910 []byte{
911 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
912 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
913 },
914 )
915 if chk.E(err) {
916 t.Fatalf("FromPubkey failed: %v", err)
917 }
918 k.Set('e')
919 v.FromIdent([]byte("test-value"))
920 if chk.E(err) {
921 t.Fatalf("FromIdent failed: %v", err)
922 }
923 ca.Set(98765)
924 ser.Set(12345)
925
926 // Test TagKindPubkeyEnc
927 enc := TagKindPubkeyEnc(k, v, ki, p, ca, ser)
928 if len(enc.Encs) != 7 {
929 t.Errorf(
930 "TagKindPubkeyEnc should create T with 7 encoders, got %d",
931 len(enc.Encs),
932 )
933 }
934
935 // Test TagKindPubkeyDec
936 dec := TagKindPubkeyDec(k, v, ki, p, ca, ser)
937 if len(dec.Encs) != 7 {
938 t.Errorf(
939 "TagKindPubkeyDec should create T with 7 encoders, got %d",
940 len(dec.Encs),
941 )
942 }
943
944 // Test marshaling and unmarshaling
945 buf := new(bytes.Buffer)
946 err = enc.MarshalWrite(buf)
947 if chk.E(err) {
948 t.Fatalf("MarshalWrite failed: %v", err)
949 }
950
951 // Create new variables for decoding
952 newK, newV, newKi, newP, newCa, newSer := TagKindPubkeyVars()
953 newDec := TagKindPubkeyDec(newK, newV, newKi, newP, newCa, newSer)
954
955 err = newDec.UnmarshalRead(bytes.NewBuffer(buf.Bytes()))
956 if chk.E(err) {
957 t.Fatalf("UnmarshalRead failed: %v", err)
958 }
959
960 // Verify the decoded values
961 if newKi.Get() != ki.Get() {
962 t.Errorf("Decoded kind %d, expected %d", newKi.Get(), ki.Get())
963 }
964 if !utils.FastEqual(newP.Bytes(), p.Bytes()) {
965 t.Errorf("Decoded pubkey hash %v, expected %v", newP.Bytes(), p.Bytes())
966 }
967 if newK.Letter() != k.Letter() {
968 t.Errorf(
969 "Decoded key letter %c, expected %c", newK.Letter(), k.Letter(),
970 )
971 }
972 if !utils.FastEqual(newV.Bytes(), v.Bytes()) {
973 t.Errorf("Decoded value hash %v, expected %v", newV.Bytes(), v.Bytes())
974 }
975 if newCa.Get() != ca.Get() {
976 t.Errorf("Decoded created at %d, expected %d", newCa.Get(), ca.Get())
977 }
978 if newSer.Get() != ser.Get() {
979 t.Errorf("Decoded serial %d, expected %d", newSer.Get(), ser.Get())
980 }
981 }
982