github.com/decred/dcrlnd@v0.7.6/tlv/stream_test.go (about)

     1  package tlv_test
     2  
     3  import (
     4  	"bytes"
     5  	"reflect"
     6  	"testing"
     7  
     8  	"github.com/decred/dcrlnd/tlv"
     9  )
    10  
    11  type parsedTypeTest struct {
    12  	name           string
    13  	encode         []tlv.Type
    14  	decode         []tlv.Type
    15  	expParsedTypes tlv.TypeMap
    16  }
    17  
    18  // TestParsedTypes asserts that a Stream will properly return the set of types
    19  // that it encounters when the type is known-and-decoded or unknown-and-ignored.
    20  func TestParsedTypes(t *testing.T) {
    21  	const (
    22  		knownType       = 1
    23  		unknownType     = 3
    24  		secondKnownType = 4
    25  	)
    26  
    27  	tests := []parsedTypeTest{
    28  		{
    29  			name:   "known and unknown",
    30  			encode: []tlv.Type{knownType, unknownType},
    31  			decode: []tlv.Type{knownType},
    32  			expParsedTypes: tlv.TypeMap{
    33  				unknownType: []byte{0, 0, 0, 0, 0, 0, 0, 0},
    34  				knownType:   nil,
    35  			},
    36  		},
    37  		{
    38  			name:   "known and missing known",
    39  			encode: []tlv.Type{knownType},
    40  			decode: []tlv.Type{knownType, secondKnownType},
    41  			expParsedTypes: tlv.TypeMap{
    42  				knownType: nil,
    43  			},
    44  		},
    45  	}
    46  
    47  	for _, test := range tests {
    48  		test := test
    49  		t.Run(test.name, func(t *testing.T) {
    50  			testParsedTypes(t, test)
    51  		})
    52  	}
    53  }
    54  
    55  func testParsedTypes(t *testing.T, test parsedTypeTest) {
    56  	encRecords := make([]tlv.Record, 0, len(test.encode))
    57  	for _, typ := range test.encode {
    58  		encRecords = append(
    59  			encRecords, tlv.MakePrimitiveRecord(typ, new(uint64)),
    60  		)
    61  	}
    62  
    63  	decRecords := make([]tlv.Record, 0, len(test.decode))
    64  	for _, typ := range test.decode {
    65  		decRecords = append(
    66  			decRecords, tlv.MakePrimitiveRecord(typ, new(uint64)),
    67  		)
    68  	}
    69  
    70  	// Construct a stream that will encode the test's set of types.
    71  	encStream := tlv.MustNewStream(encRecords...)
    72  
    73  	var b bytes.Buffer
    74  	if err := encStream.Encode(&b); err != nil {
    75  		t.Fatalf("unable to encode stream: %v", err)
    76  	}
    77  
    78  	// Create a stream that will parse a subset of the test's types.
    79  	decStream := tlv.MustNewStream(decRecords...)
    80  
    81  	parsedTypes, err := decStream.DecodeWithParsedTypes(
    82  		bytes.NewReader(b.Bytes()),
    83  	)
    84  	if err != nil {
    85  		t.Fatalf("error decoding: %v", err)
    86  	}
    87  	if !reflect.DeepEqual(parsedTypes, test.expParsedTypes) {
    88  		t.Fatalf("error mismatch on parsed types")
    89  	}
    90  }