| // Copyright 2015 The Vanadium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| package vom |
| |
| import ( |
| "bytes" |
| "fmt" |
| "testing" |
| |
| "v.io/v23/vdl" |
| "v.io/v23/vom/testdata/types" |
| ) |
| |
| func TestInterleavedMessageReader(t *testing.T) { |
| type chunkHeader struct { |
| msgID int64 |
| finalChunk bool |
| } |
| |
| tests := []struct { |
| name string |
| hex string |
| typeMap map[typeId]*vdl.Type |
| expectedChunks []chunkHeader |
| }{ |
| // Type message split into chunks. |
| { |
| name: "type chunks", |
| hex: "81" + |
| crHex(WireCtrlTypeFirstChunk) + "5103060029" + |
| crHex(WireCtrlTypeChunk) + "06762e696f2f76" + |
| crHex(WireCtrlTypeLastChunk) + "2e32332f766f6d2f74657374646174612f7465737474797065732e537472756374416e7901010003416e79010fe1e1" + |
| "52012a08000000010000e1e1", |
| typeMap: map[typeId]*vdl.Type{ |
| 41: vdl.TypeOf(types.StructAny{}), |
| }, |
| expectedChunks: []chunkHeader{ |
| { |
| msgID: -41, |
| }, |
| {}, |
| { |
| finalChunk: true, |
| }, |
| { |
| msgID: 41, |
| finalChunk: true, |
| }, |
| }, |
| }, |
| // Value message with types interleaved. |
| { |
| name: "interleaved chunks", |
| hex: "81" + |
| "5137060029762e696f2f7632332f766f6d2f74657374646174612f7465737474797065732e537472756374416e7901010003416e79010fe1e1" + |
| crHex(WireCtrlValueFirstChunk) + "520000" + |
| "5337060029762e696f2f7632332f766f6d2f74657374646174612f7465737474797065732e537472756374416e7901010003416e79010fe1e1" + |
| crHex(WireCtrlValueChunk) + "012a0400000001" + |
| crHex(WireCtrlTypeFirstChunk) + "5503060029" + |
| crHex(WireCtrlTypeChunk) + "06762e696f2f76" + |
| crHex(WireCtrlTypeLastChunk) + "2e32332f766f6d2f74657374646174612f7465737474797065732e537472756374416e7901010003416e79010fe1e1" + |
| crHex(WireCtrlValueLastChunk) + "00040000e1e1", |
| typeMap: map[typeId]*vdl.Type{ |
| 41: vdl.TypeOf(types.StructAny{}), |
| }, |
| expectedChunks: []chunkHeader{ |
| { |
| msgID: -41, |
| finalChunk: true, |
| }, |
| { |
| msgID: 41, |
| }, |
| { |
| msgID: -42, |
| finalChunk: true, |
| }, |
| {}, |
| { |
| msgID: -43, |
| }, |
| {}, |
| { |
| finalChunk: true, |
| }, |
| { |
| finalChunk: true, |
| }, |
| }, |
| }, |
| } |
| |
| for _, test := range tests { |
| // Helpers to iterate over expected chunks. |
| var expectedChunkIndex int |
| chunkRead := func() bool { |
| expectedChunkIndex++ |
| return expectedChunkIndex < len(test.expectedChunks) |
| } |
| expectedChunk := func() *chunkHeader { |
| if expectedChunkIndex >= len(test.expectedChunks) { |
| t.Fatalf("%s: chunk index %d out of bounds of slice of length %d", test.name, expectedChunkIndex, test.expectedChunks) |
| } |
| return &test.expectedChunks[expectedChunkIndex] |
| } |
| |
| bin := hex2Bin(t, test.hex) |
| mr := newMessageReader(newDecbufFromBytes(bin)) |
| |
| // Fake type decoding by looking up types from a predefined map. |
| lookupType := func(tid typeId) (*vdl.Type, error) { |
| t := test.typeMap[tid] |
| if t == nil { |
| return nil, fmt.Errorf("type not found") |
| } |
| return t, nil |
| } |
| |
| // Callback to read a type in the middle of a value read. |
| readSingleType := func() error { |
| if expectedChunk().msgID >= 0 { |
| t.Errorf("%s: expected new type, but got %#v", test.name, expectedChunk()) |
| return nil |
| } |
| tid, err := mr.StartTypeMessage() |
| if err != nil { |
| t.Fatalf("%s: error in StartTypeMessage: %v", test.name, err) |
| } |
| for { |
| if expectedChunk().msgID != -int64(tid) { |
| t.Errorf("%s: got chunk %v but expected %v", test.name, -int64(tid), expectedChunk().msgID) |
| break |
| } |
| if expectedChunk().finalChunk != mr.finalChunk { |
| t.Errorf("%s: final chunk was %v, but expected %v", test.name, mr.finalChunk, expectedChunk().finalChunk) |
| } |
| if err := mr.Skip(mr.buf.lim); err != nil { |
| t.Fatalf("%s: error in Skip(): %v", test.name, err) |
| } |
| if expectedChunk().finalChunk { |
| break |
| } |
| if !chunkRead() { |
| break |
| } |
| |
| consumed, err := mr.startChunk() |
| if err != nil { |
| t.Fatalf("%s: error in startChunk: %v", test.name, err) |
| } |
| if consumed { |
| t.Fatalf("%s: chunk unexpectedly consumed while reading types", test.name) |
| } |
| if mr.curMsgKind != typeMessage { |
| t.Fatalf("%s: got value message when expected type message at index %d", test.name, expectedChunkIndex) |
| } |
| tid = 0 |
| } |
| if err := mr.EndMessage(); err != nil { |
| t.Fatalf("%s: error in end message: %v", test.name, err) |
| } |
| chunkRead() // expectedChunk() now refers to the message after the type message |
| return nil |
| } |
| |
| mr.SetCallbacks(lookupType, readSingleType) |
| |
| // Read the value messages until the end of the expected chunk list is reached. |
| for expectedChunkIndex < len(test.expectedChunks) { |
| tid, err := mr.StartValueMessage() |
| if err != nil { |
| t.Fatalf("%s: error in StartValueMessage: %v", test.name, err) |
| } |
| mid := int64(tid) |
| for { |
| if expectedChunk().msgID != mid { |
| t.Errorf("%s: got chunk mid %v but expected %v", test.name, mid, expectedChunk().msgID) |
| break |
| } |
| if err := mr.Skip(mr.buf.lim); err != nil { |
| t.Fatalf("%s: error in Skip(): %v", test.name, err) |
| } |
| if expectedChunk().finalChunk { |
| break |
| } |
| if !chunkRead() { |
| break |
| } |
| err := mr.nextChunk() |
| if err != nil { |
| t.Fatalf("%s: error in nextChunk: %v", test.name, err) |
| } |
| mid = 0 |
| } |
| if err := mr.EndMessage(); err != nil { |
| t.Fatalf("%s: error in end message: %v", test.name, err) |
| } |
| chunkRead() // Point to the next message |
| } |
| |
| if mr.buf.beg != len(bin) { |
| // NOTE: This check is invalid if the length of the test bytes exceeds the buffer length and will |
| // need to be updated if this is ever changed. |
| t.Errorf("%s: input hex was not fully read. read length was: %d, but full length was %d", test.name, mr.buf.beg, len(bin)) |
| } |
| } |
| } |
| |
| func TestTypeMessageReader(t *testing.T) { |
| lookupType := func(tid typeId) (*vdl.Type, error) { |
| switch tid { |
| case 1: |
| return vdl.BoolType, nil |
| case 41: |
| return vdl.TypeOf(types.NBool(true)), nil |
| default: |
| return nil, fmt.Errorf("invalid type id: %d", tid) |
| } |
| } |
| |
| successMr := newMessageReader(newDecbufFromBytes(hex2Bin(t, "81"+ |
| crHex(WireCtrlTypeFirstChunk)+"5120000025762e696f2f7632332f766f6d2f74657374646174612f74657374747970"+ |
| crHex(WireCtrlTypeLastChunk)+"0b65732e4e426f6f6c0101e1"))) |
| successMr.SetCallbacks(lookupType, nil) |
| mid, err := successMr.StartTypeMessage() |
| if err != nil { |
| t.Fatalf("error starting type message: %v", err) |
| } |
| if mid != 41 { |
| t.Errorf("got invalid type id: %v, expected %v", mid, 41) |
| } |
| if err := successMr.Skip(43); err != nil { |
| t.Fatalf("error skipping bytes: %v", err) |
| } |
| if err := successMr.EndMessage(); err != nil { |
| t.Fatalf("error ending message: %v", err) |
| } |
| |
| failingMr := newMessageReader(newDecbufFromBytes(hex2Bin(t, "810201"))) |
| failingMr.SetCallbacks(lookupType, nil) |
| if _, err := failingMr.StartTypeMessage(); err == nil { |
| t.Fatalf("expected error when reading value message on type stream") |
| } |
| } |
| |
| func TestValueMessageReader(t *testing.T) { |
| lookupType := func(tid typeId) (*vdl.Type, error) { |
| switch tid { |
| case 1: |
| return vdl.BoolType, nil |
| case 41: |
| return vdl.TypeOf(types.NStruct{}), nil |
| default: |
| return nil, fmt.Errorf("invalid type id: %d", tid) |
| } |
| } |
| |
| successMr := newMessageReader(newDecbufFromBytes(hex2Bin(t, "81"+ |
| crHex(WireCtrlValueFirstChunk)+"520400010103"+ |
| crHex(WireCtrlValueLastChunk)+"0761626302fff6e1"))) |
| successMr.SetCallbacks(lookupType, nil) |
| mid, err := successMr.StartValueMessage() |
| if err != nil { |
| t.Fatalf("error starting value message: %v", err) |
| } |
| if mid != 41 { |
| t.Errorf("got invalid message id: %v, expected %v", mid, 41) |
| } |
| if err := successMr.Skip(11); err != nil { |
| t.Fatalf("error skipping bytes: %v", err) |
| } |
| if err := successMr.EndMessage(); err != nil { |
| t.Fatalf("error ending message: %v", err) |
| } |
| |
| failingMr := newMessageReader(newDecbufFromBytes(hex2Bin(t, "81513f060027762e696f2f7632332f766f6d2f74657374646174612f7465737474797065732e4e53747275637401030001410101e10001420103e10001430109e1e1"))) |
| failingMr.SetCallbacks(lookupType, nil) |
| if _, err := failingMr.StartValueMessage(); err == nil { |
| t.Fatalf("expected error when reading type message on value stream") |
| } |
| } |
| |
| func TestReadAllValueBytes(t *testing.T) { |
| type testCase struct { |
| Name string |
| InputTypeHex string |
| InputValueHex string |
| ExpectedHex string |
| NumMessages int |
| } |
| |
| // NOTE: More types are tested in raw_value_test.go -- this just tests broad classes. |
| tests := []testCase{ |
| { |
| Name: "Bool", |
| InputValueHex: "0201", |
| ExpectedHex: "01", |
| NumMessages: 1, |
| }, |
| { |
| Name: "uint16(65534)", |
| InputValueHex: "08fefffe", |
| ExpectedHex: "fefffe", |
| NumMessages: 1, |
| }, |
| { |
| Name: "\"abc\"", |
| InputValueHex: "0603616263", |
| ExpectedHex: "03616263", |
| NumMessages: 1, |
| }, |
| { |
| Name: "[]byte(\"abc\")", |
| InputValueHex: "4e03616263", |
| ExpectedHex: "03616263", |
| NumMessages: 1, |
| }, |
| { |
| Name: "typeobject(bool)", |
| InputValueHex: "1c010100", |
| ExpectedHex: "00", |
| NumMessages: 1, |
| }, |
| { |
| Name: "testtypes.NStruct{A: true, B: \"abc\", C: 123}", |
| InputTypeHex: "513f060027762e696f2f7632332f766f6d2f74657374646174612f7465737474797065732e4e53747275637401030001410101e10001420103e10001430109e1e1", |
| InputValueHex: "520b0001010361626302fff6e1", |
| ExpectedHex: "0001010361626302fff6e1", |
| NumMessages: 1, |
| }, |
| { |
| Name: "testtypes.StructAny{Any: false}", |
| InputTypeHex: "5137060029762e696f2f7632332f766f6d2f74657374646174612f7465737474797065732e537472756374416e7901010003416e79010fe1e1", |
| InputValueHex: "52010104000000e1", |
| ExpectedHex: "000000e1", |
| NumMessages: 1, |
| }, |
| { |
| Name: "chunked testtypes.NStruct{A: true, B: \"abc\", C: 123}", |
| InputTypeHex: crHex(WireCtrlTypeFirstChunk) + "513b060027762e696f2f7632332f766f6d2f74657374646174612f7465737474797065732e4e53747275637401030001410101e10001420103e1000143" + |
| crHex(WireCtrlTypeLastChunk) + "040109e1e1", |
| InputValueHex: crHex(WireCtrlValueFirstChunk) + "52050001010361" + |
| crHex(WireCtrlValueLastChunk) + "06626302fff6e1", |
| ExpectedHex: "0001010361626302fff6e1", |
| NumMessages: 1, |
| }, |
| { |
| Name: "chunked testtypes.StructAny{Any: false}", |
| InputTypeHex: "5137060029762e696f2f7632332f766f6d2f74657374646174612f7465737474797065732e537472756374416e7901010003416e79010fe1e1", |
| InputValueHex: crHex(WireCtrlValueFirstChunk) + "5201000100" + |
| crHex(WireCtrlValueLastChunk) + "0101030000e1", |
| ExpectedHex: "000000e1", |
| NumMessages: 1, |
| }, |
| { |
| Name: "two messages testtypes.NStruct{A: true, B: \"abc\", C: 123}", |
| InputTypeHex: "513f060027762e696f2f7632332f766f6d2f74657374646174612f7465737474797065732e4e53747275637401030001410101e10001420103e10001430109e1e1", |
| InputValueHex: "520b0001010361626302fff6e1" + // first message |
| "520b0001010361626302fff6e1", // second message |
| ExpectedHex: "0001010361626302fff6e1", |
| NumMessages: 2, |
| }, |
| } |
| |
| nextTest: |
| for _, test := range tests { |
| // Interleaved |
| mr := newMessageReader(newDecbufFromBytes(hex2Bin(t, "81"+test.InputTypeHex+test.InputValueHex))) |
| typeDec := newTypeDecoderInternal(mr) |
| mr.SetCallbacks(typeDec.lookupType, typeDec.readSingleType) |
| |
| for i := 0; i < test.NumMessages; i++ { |
| _, err := mr.StartValueMessage() |
| if err != nil { |
| t.Errorf("%s (interleaved): error in start value message: %v", test.Name, err) |
| continue nextTest |
| } |
| b, err := mr.ReadAllValueBytes() |
| if err != nil { |
| t.Errorf("%s (interleaved): error in ReadAllBytes(): %v", test.Name, err) |
| continue nextTest |
| } |
| if !bytes.Equal(b, hex2Bin(t, test.ExpectedHex)) { |
| t.Errorf("%s (interleaved): expected: %s but got %x", test.Name, test.ExpectedHex, b) |
| continue nextTest |
| } |
| if err := mr.EndMessage(); err != nil { |
| t.Errorf("%s (interleaved): error ending message: %v", test.Name, err) |
| continue nextTest |
| } |
| } |
| |
| // Split type and value streams |
| typeMr := newMessageReader(newDecbufFromBytes(hex2Bin(t, "81"+test.InputTypeHex))) |
| valueMr := newMessageReader(newDecbufFromBytes(hex2Bin(t, "81"+test.InputValueHex))) |
| typeDec = newTypeDecoderInternal(typeMr) |
| typeMr.SetCallbacks(typeDec.lookupType, nil) |
| valueMr.SetCallbacks(typeDec.lookupType, nil) |
| typeDec.Start() |
| defer typeDec.Stop() |
| |
| for i := 0; i < test.NumMessages; i++ { |
| _, err := valueMr.StartValueMessage() |
| if err != nil { |
| t.Errorf("%s (split): error in start value message: %v", test.Name, err) |
| continue nextTest |
| } |
| b, err := valueMr.ReadAllValueBytes() |
| if err != nil { |
| t.Errorf("%s (split): error in ReadAllBytes(): %v", test.Name, err) |
| continue nextTest |
| } |
| if !bytes.Equal(b, hex2Bin(t, test.ExpectedHex)) { |
| t.Errorf("%s (split): expected: %s but got %x", test.Name, test.ExpectedHex, b) |
| continue nextTest |
| } |
| if err := valueMr.EndMessage(); err != nil { |
| t.Errorf("%s (split): error ending message: %v", test.Name, err) |
| continue nextTest |
| } |
| } |
| } |
| } |
| |
| func crHex(b byte) string { |
| return fmt.Sprintf("%x", b) |
| } |
