github.com/aavshr/aws-sdk-go@v1.41.3/private/protocol/eventstream/header_value_test.go (about)

     1  package eventstream
     2  
     3  import (
     4  	"bytes"
     5  	"encoding/binary"
     6  	"io"
     7  	"reflect"
     8  	"testing"
     9  	"time"
    10  )
    11  
    12  func binWrite(v interface{}) []byte {
    13  	var w bytes.Buffer
    14  	binary.Write(&w, binary.BigEndian, v)
    15  	return w.Bytes()
    16  }
    17  
    18  var testValueEncodingCases = []struct {
    19  	Val    Value
    20  	Expect []byte
    21  	Decode func(io.Reader) (Value, error)
    22  }{
    23  	{
    24  		BoolValue(true),
    25  		[]byte{byte(trueValueType)},
    26  		nil,
    27  	},
    28  	{
    29  		BoolValue(false),
    30  		[]byte{byte(falseValueType)},
    31  		nil,
    32  	},
    33  	{
    34  		Int8Value(0x0f),
    35  		[]byte{byte(int8ValueType), 0x0f},
    36  		func(r io.Reader) (Value, error) {
    37  			var v Int8Value
    38  			err := v.decode(r)
    39  			return v, err
    40  		},
    41  	},
    42  	{
    43  		Int16Value(0x0f),
    44  		append([]byte{byte(int16ValueType)}, binWrite(int16(0x0f))...),
    45  		func(r io.Reader) (Value, error) {
    46  			var v Int16Value
    47  			err := v.decode(r)
    48  			return v, err
    49  		},
    50  	},
    51  	{
    52  		Int32Value(0x0f),
    53  		append([]byte{byte(int32ValueType)}, binWrite(int32(0x0f))...),
    54  		func(r io.Reader) (Value, error) {
    55  			var v Int32Value
    56  			err := v.decode(r)
    57  			return v, err
    58  		},
    59  	},
    60  	{
    61  		Int64Value(0x0f),
    62  		append([]byte{byte(int64ValueType)}, binWrite(int64(0x0f))...),
    63  		func(r io.Reader) (Value, error) {
    64  			var v Int64Value
    65  			err := v.decode(r)
    66  			return v, err
    67  		},
    68  	},
    69  	{
    70  		BytesValue([]byte{0, 1, 2, 3}),
    71  		[]byte{byte(bytesValueType), 0x00, 0x04, 0, 1, 2, 3},
    72  		func(r io.Reader) (Value, error) {
    73  			var v BytesValue
    74  			err := v.decode(r)
    75  			return v, err
    76  		},
    77  	},
    78  	{
    79  		StringValue("abc123"),
    80  		append([]byte{byte(stringValueType), 0, 6}, []byte("abc123")...),
    81  		func(r io.Reader) (Value, error) {
    82  			var v StringValue
    83  			err := v.decode(r)
    84  			return v, err
    85  		},
    86  	},
    87  	{
    88  		TimestampValue(
    89  			time.Date(2014, 04, 04, 0, 1, 0, 0, time.FixedZone("PDT", -7)),
    90  		),
    91  		append([]byte{byte(timestampValueType)}, binWrite(int64(1396569667000))...),
    92  		func(r io.Reader) (Value, error) {
    93  			var v TimestampValue
    94  			err := v.decode(r)
    95  			return v, err
    96  		},
    97  	},
    98  	{
    99  		UUIDValue(
   100  			[16]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf},
   101  		),
   102  		[]byte{byte(uuidValueType), 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf},
   103  		func(r io.Reader) (Value, error) {
   104  			var v UUIDValue
   105  			err := v.decode(r)
   106  			return v, err
   107  		},
   108  	},
   109  }
   110  
   111  func TestValue_MarshalValue(t *testing.T) {
   112  	for i, c := range testValueEncodingCases {
   113  		var w bytes.Buffer
   114  
   115  		if err := c.Val.encode(&w); err != nil {
   116  			t.Fatalf("%d, expect no error, got %v", i, err)
   117  		}
   118  
   119  		if e, a := c.Expect, w.Bytes(); !reflect.DeepEqual(e, a) {
   120  			t.Errorf("%d, expect %v, got %v", i, e, a)
   121  		}
   122  	}
   123  }
   124  
   125  func TestHeader_DecodeValues(t *testing.T) {
   126  	for i, c := range testValueEncodingCases {
   127  		r := bytes.NewBuffer(c.Expect)
   128  		v, err := decodeHeaderValue(r)
   129  		if err != nil {
   130  			t.Fatalf("%d, expect no error, got %v", i, err)
   131  		}
   132  
   133  		switch tv := v.(type) {
   134  		case TimestampValue:
   135  			exp := time.Time(c.Val.(TimestampValue))
   136  			if e, a := exp, time.Time(tv); !e.Equal(a) {
   137  				t.Errorf("%d, expect %v, got %v", i, e, a)
   138  			}
   139  		default:
   140  			if e, a := c.Val, v; !reflect.DeepEqual(e, a) {
   141  				t.Errorf("%d, expect %v, got %v", i, e, a)
   142  			}
   143  		}
   144  	}
   145  }
   146  
   147  func TestValue_Decode(t *testing.T) {
   148  	for i, c := range testValueEncodingCases {
   149  		if c.Decode == nil {
   150  			continue
   151  		}
   152  
   153  		r := bytes.NewBuffer(c.Expect)
   154  		r.ReadByte() // strip off Type field
   155  
   156  		v, err := c.Decode(r)
   157  		if err != nil {
   158  			t.Fatalf("%d, expect no error, got %v", i, err)
   159  		}
   160  
   161  		switch tv := v.(type) {
   162  		case TimestampValue:
   163  			exp := time.Time(c.Val.(TimestampValue))
   164  			if e, a := exp, time.Time(tv); !e.Equal(a) {
   165  				t.Errorf("%d, expect %v, got %v", i, e, a)
   166  			}
   167  		default:
   168  			if e, a := c.Val, v; !reflect.DeepEqual(e, a) {
   169  				t.Errorf("%d, expect %v, got %v", i, e, a)
   170  			}
   171  		}
   172  	}
   173  }
   174  
   175  func TestValue_String(t *testing.T) {
   176  	cases := []struct {
   177  		Val    Value
   178  		Expect string
   179  	}{
   180  		{BoolValue(true), "true"},
   181  		{BoolValue(false), "false"},
   182  		{Int8Value(0x0f), "0x0f"},
   183  		{Int16Value(0x0f), "0x000f"},
   184  		{Int32Value(0x0f), "0x0000000f"},
   185  		{Int64Value(0x0f), "0x000000000000000f"},
   186  		{BytesValue([]byte{0, 1, 2, 3}), "AAECAw=="},
   187  		{StringValue("abc123"), "abc123"},
   188  		{TimestampValue(
   189  			time.Date(2014, 04, 04, 0, 1, 0, 0, time.FixedZone("PDT", -7)),
   190  		),
   191  			"1396569667000",
   192  		},
   193  		{UUIDValue([16]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf}),
   194  			"00010203-0405-0607-0809-0A0B0C0D0E0F",
   195  		},
   196  	}
   197  
   198  	for i, c := range cases {
   199  		if e, a := c.Expect, c.Val.String(); e != a {
   200  			t.Errorf("%d, expect %v, got %v", i, e, a)
   201  		}
   202  	}
   203  }