package tlv_test import ( "bytes" "fmt" "testing" "github.com/lightningnetwork/lnd/tlv" ) var tuint16Tests = []struct { value uint16 size uint64 bytes []byte }{ { value: 0x0000, size: 0, bytes: []byte{}, }, { value: 0x0001, size: 1, bytes: []byte{0x01}, }, { value: 0x00ff, size: 1, bytes: []byte{0xff}, }, { value: 0x0100, size: 2, bytes: []byte{0x01, 0x00}, }, { value: 0xffff, size: 2, bytes: []byte{0xff, 0xff}, }, } // TestSizeTUint16 asserts that SizeTUint16 computes the proper truncated size // along boundary conditions of the input space. func TestSizeTUint16(t *testing.T) { for _, test := range tuint16Tests { name := fmt.Sprintf("0x%x", test.value) t.Run(name, func(t *testing.T) { size := tlv.SizeTUint16(test.value) if test.size != size { t.Fatalf("size mismatch, expected: %d got: %d", test.size, size) } }) } } // TestTUint16 asserts that ETUint16 outputs the proper encoding of a truncated // uint16, and that DTUint16 is able to parse the output. func TestTUint16(t *testing.T) { var buf [8]byte for _, test := range tuint16Tests { if len(test.bytes) != int(test.size) { t.Fatalf("invalid test case, "+ "len(bytes)[%d] != size[%d]", len(test.bytes), test.size) } name := fmt.Sprintf("0x%x", test.value) t.Run(name, func(t *testing.T) { var b bytes.Buffer err := tlv.ETUint16(&b, &test.value, &buf) if err != nil { t.Fatalf("unable to encode tuint16: %v", err) } if bytes.Compare(b.Bytes(), test.bytes) != 0 { t.Fatalf("encoding mismatch, "+ "expected: %x, got: %x", test.bytes, b.Bytes()) } var value uint16 r := bytes.NewReader(b.Bytes()) err = tlv.DTUint16(r, &value, &buf, test.size) if err != nil { t.Fatalf("unable to decode tuint16: %v", err) } if value != test.value { t.Fatalf("decoded value mismatch, "+ "expected: %d, got: %d", test.value, value) } }) } } var tuint32Tests = []struct { value uint32 size uint64 bytes []byte }{ { value: 0x00000000, size: 0, bytes: []byte{}, }, { value: 0x00000001, size: 1, bytes: []byte{0x01}, }, { value: 0x000000ff, size: 1, bytes: []byte{0xff}, }, { value: 0x00000100, size: 2, bytes: []byte{0x01, 0x00}, }, { value: 0x0000ffff, size: 2, bytes: []byte{0xff, 0xff}, }, { value: 0x00010000, size: 3, bytes: []byte{0x01, 0x00, 0x00}, }, { value: 0x00ffffff, size: 3, bytes: []byte{0xff, 0xff, 0xff}, }, { value: 0x01000000, size: 4, bytes: []byte{0x01, 0x00, 0x00, 0x00}, }, { value: 0xffffffff, size: 4, bytes: []byte{0xff, 0xff, 0xff, 0xff}, }, } // TestSizeTUint32 asserts that SizeTUint32 computes the proper truncated size // along boundary conditions of the input space. func TestSizeTUint32(t *testing.T) { for _, test := range tuint32Tests { name := fmt.Sprintf("0x%x", test.value) t.Run(name, func(t *testing.T) { size := tlv.SizeTUint32(test.value) if test.size != size { t.Fatalf("size mismatch, expected: %d got: %d", test.size, size) } }) } } // TestTUint32 asserts that ETUint32 outputs the proper encoding of a truncated // uint32, and that DTUint32 is able to parse the output. func TestTUint32(t *testing.T) { var buf [8]byte for _, test := range tuint32Tests { if len(test.bytes) != int(test.size) { t.Fatalf("invalid test case, "+ "len(bytes)[%d] != size[%d]", len(test.bytes), test.size) } name := fmt.Sprintf("0x%x", test.value) t.Run(name, func(t *testing.T) { var b bytes.Buffer err := tlv.ETUint32(&b, &test.value, &buf) if err != nil { t.Fatalf("unable to encode tuint32: %v", err) } if bytes.Compare(b.Bytes(), test.bytes) != 0 { t.Fatalf("encoding mismatch, "+ "expected: %x, got: %x", test.bytes, b.Bytes()) } var value uint32 r := bytes.NewReader(b.Bytes()) err = tlv.DTUint32(r, &value, &buf, test.size) if err != nil { t.Fatalf("unable to decode tuint32: %v", err) } if value != test.value { t.Fatalf("decoded value mismatch, "+ "expected: %d, got: %d", test.value, value) } }) } } var tuint64Tests = []struct { value uint64 size uint64 bytes []byte }{ { value: 0x0000000000000000, size: 0, bytes: []byte{}, }, { value: 0x0000000000000001, size: 1, bytes: []byte{0x01}, }, { value: 0x00000000000000ff, size: 1, bytes: []byte{0xff}, }, { value: 0x0000000000000100, size: 2, bytes: []byte{0x01, 0x00}, }, { value: 0x000000000000ffff, size: 2, bytes: []byte{0xff, 0xff}, }, { value: 0x0000000000010000, size: 3, bytes: []byte{0x01, 0x00, 0x00}, }, { value: 0x0000000000ffffff, size: 3, bytes: []byte{0xff, 0xff, 0xff}, }, { value: 0x0000000001000000, size: 4, bytes: []byte{0x01, 0x00, 0x00, 0x00}, }, { value: 0x00000000ffffffff, size: 4, bytes: []byte{0xff, 0xff, 0xff, 0xff}, }, { value: 0x0000000100000000, size: 5, bytes: []byte{0x01, 0x00, 0x00, 0x00, 0x00}, }, { value: 0x000000ffffffffff, size: 5, bytes: []byte{0xff, 0xff, 0xff, 0xff, 0xff}, }, { value: 0x0000010000000000, size: 6, bytes: []byte{0x01, 0x00, 0x00, 0x00, 0x00, 0x00}, }, { value: 0x0000ffffffffffff, size: 6, bytes: []byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff}, }, { value: 0x0001000000000000, size: 7, bytes: []byte{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, }, { value: 0x00ffffffffffffff, size: 7, bytes: []byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}, }, { value: 0x0100000000000000, size: 8, bytes: []byte{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, }, { value: 0xffffffffffffffff, size: 8, bytes: []byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}, }, } // TestSizeTUint64 asserts that SizeTUint64 computes the proper truncated size // along boundary conditions of the input space. func TestSizeTUint64(t *testing.T) { for _, test := range tuint64Tests { if len(test.bytes) != int(test.size) { t.Fatalf("invalid test case, "+ "len(bytes)[%d] != size[%d]", len(test.bytes), test.size) } name := fmt.Sprintf("0x%x", test.value) t.Run(name, func(t *testing.T) { size := tlv.SizeTUint64(test.value) if test.size != size { t.Fatalf("size mismatch, expected: %d got: %d", test.size, size) } }) } } // TestTUint64 asserts that ETUint64 outputs the proper encoding of a truncated // uint64, and that DTUint64 is able to parse the output. func TestTUint64(t *testing.T) { var buf [8]byte for _, test := range tuint64Tests { if len(test.bytes) != int(test.size) { t.Fatalf("invalid test case, "+ "len(bytes)[%d] != size[%d]", len(test.bytes), test.size) } name := fmt.Sprintf("0x%x", test.value) t.Run(name, func(t *testing.T) { var b bytes.Buffer err := tlv.ETUint64(&b, &test.value, &buf) if err != nil { t.Fatalf("unable to encode tuint64: %v", err) } if bytes.Compare(b.Bytes(), test.bytes) != 0 { t.Fatalf("encoding mismatch, "+ "expected: %x, got: %x", test.bytes, b.Bytes()) } var value uint64 r := bytes.NewReader(b.Bytes()) err = tlv.DTUint64(r, &value, &buf, test.size) if err != nil { t.Fatalf("unable to decode tuint64: %v", err) } if value != test.value { t.Fatalf("decoded value mismatch, "+ "expected: %d, got: %d", test.value, value) } }) } }