| // Copyright 2018 The Fuchsia 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 fidl_test |
| |
| import ( |
| "bytes" |
| "fmt" |
| "reflect" |
| "strings" |
| "syscall/zx" |
| "syscall/zx/fidl" |
| "syscall/zx/fidl/internal/bindingstest" |
| "testing" |
| ) |
| |
| var testCtx fidl.MarshalerContext |
| |
| func TestMarshalMessageHeader(t *testing.T) { |
| data := []byte{ |
| 0x12, 0x34, 0x56, 0x78, // txid |
| 0xAB, 0xCD, 0xEF, // flags |
| 0x01, // magic number |
| 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // method ordinal |
| } |
| var header fidl.MessageHeader |
| hnb, _, err := fidl.Unmarshal(data, nil, &header) |
| if err != nil { |
| t.Fatalf("unmarshal failed: %s", err) |
| } |
| if hnb != 16 { |
| t.Fatalf("expected 16 bytes read, was %d", hnb) |
| } |
| if header.Magic != 0x01 { |
| t.Fatalf("expected header txid of 0x01, was %x", header.Magic) |
| } |
| } |
| |
| // TODO(https://fxbug.dev/7832): do we purposefully provide buffers too big in |
| // conformance tests to ensure the returned size is properly calculated? If |
| // not, we should keep this sort of testing, or augment the conformance tests. |
| func TestCheckUnmarshalReadSize(t *testing.T) { |
| examples := [][]byte{ |
| { |
| 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
| }, |
| |
| { |
| 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
| 0x00, 0x00, // these will go unread |
| }, |
| } |
| for _, data := range examples { |
| var message bindingstest.EmptyStruct |
| hnb, _, err := fidl.Unmarshal(data, nil, &message) |
| if err != nil { |
| t.Fatalf("unmarshal failed: %s", err) |
| } |
| if hnb != 8 { |
| t.Fatalf("expected 8 bytes read, was %d", hnb) |
| } |
| } |
| } |
| |
| // TODO(https://fxbug.dev/7832): We are lacking in negative tests in the conformance suite. |
| func TestEnvelopeByteCountTooLarge(t *testing.T) { |
| input := []byte{ |
| 0x21, 0xEB, 0x7E, 0x76, 0x00, 0x00, 0x00, 0x00, // ordinal + padding |
| 0xaa, 0xaa, 0xaa, 0xaa, 0x00, 0x00, 0x00, 0x00, // byte + handle count |
| 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // envelope present |
| 0xef, 0xbe, 0xad, 0xde, 0x11, 0xba, 0x5e, 0xba, // data |
| } |
| |
| var message bindingstest.XUnion1Struct |
| _, _, err := fidl.Unmarshal(input, nil, &message) |
| want := fidl.ErrPayloadTooSmall |
| switch err := err.(type) { |
| case fidl.ValidationError: |
| if err.Code() == want { |
| return |
| } |
| } |
| t.Fatalf("got fidl.Unmarshal(...) = (_, _, %v), want %s", err, want) |
| } |
| |
| // TODO(https://fxbug.dev/7832): We are lacking in negative tests in the conformance suite. |
| func TestEnvelopeHandleCountTooLarge(t *testing.T) { |
| input := []byte{ |
| 0x21, 0xEB, 0x7E, 0x76, 0x00, 0x00, 0x00, 0x00, // ordinal + padding |
| 0x08, 0x00, 0x00, 0x00, 0xaa, 0xaa, 0xaa, 0xaa, // byte + invalid handle count |
| 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // envelope present |
| 0xef, 0xbe, 0xad, 0xde, 0x11, 0xba, 0x5e, 0xba, // data |
| } |
| |
| var message bindingstest.XUnion1Struct |
| _, _, err := fidl.Unmarshal(input, nil, &message) |
| want := fidl.ErrTooManyHandles |
| switch err := err.(type) { |
| case fidl.ValidationError: |
| if err.Code() == want { |
| return |
| } |
| } |
| t.Fatalf("got fidl.Unmarshal(...) = (_, _, %v), want %s", err, want) |
| } |
| |
| // TODO(https://fxbug.dev/7832): We are lacking in negative tests in the conformance suite. |
| func TestEnvelopeInvalidPresence(t *testing.T) { |
| input := []byte{ |
| 0x21, 0xEB, 0x7E, 0x76, 0x00, 0x00, 0x00, 0x00, // ordinal + padding |
| 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // byte + handle count |
| 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, // invalid envelope presence |
| 0xef, 0xbe, 0xad, 0xde, 0x11, 0xba, 0x5e, 0xba, // data |
| } |
| |
| var message bindingstest.XUnion1Struct |
| _, _, err := fidl.Unmarshal(input, nil, &message) |
| want := fidl.ErrBadRefEncoding |
| switch err := err.(type) { |
| case fidl.ValidationError: |
| if err.Code() == want { |
| return |
| } |
| } |
| t.Fatalf("got fidl.Unmarshal(...) = (_, _, %v), want %s", err, want) |
| } |
| |
| type example struct { |
| name string |
| input fidl.Message |
| expectSize int |
| } |
| |
| // general provides test cases used to verify correctness, and |
| // benchmark against. |
| // |
| // Keep these as a slice to preserve consistent ordering when running. |
| func general() []example { |
| vmo, err := zx.NewVMO(10, 0) |
| if err != nil { |
| panic(fmt.Sprintf("failed to create vmo: %s", err)) |
| } |
| defer func() { |
| if err := vmo.Close(); err != nil { |
| panic(fmt.Sprintf("failed to close vmo: %s", err)) |
| } |
| }() |
| |
| h0, h1, err := zx.NewChannel(0) |
| if err != nil { |
| panic(fmt.Sprintf("failed to create channel: %s", err)) |
| } |
| defer func() { |
| if err := h0.Close(); err != nil { |
| panic(fmt.Sprintf("failed to close channel: %s", err)) |
| } |
| if err := h1.Close(); err != nil { |
| panic(fmt.Sprintf("failed to close channel: %s", err)) |
| } |
| }() |
| |
| st1 := bindingstest.SimpleTable{} |
| st1.SetX(42) |
| st1.SetY(67) |
| |
| return []example{ |
| // TODO(https://fxbug.dev/7832): We lack coverage of floats in the conformance test suite. |
| {"float1", &bindingstest.TestFloat1{A: -36.0}, 8}, |
| {"float2", &bindingstest.TestFloat2{A: -1254918271.0}, 8}, |
| {"float3", &bindingstest.TestFloat3{A: 1241.1, B: 0.2141, C: 20, D: 0.0}, 32}, |
| |
| // TODO(https://fxbug.dev/7832): We just recently added handles in conformance suite. Are these covered? |
| {"handle1", &bindingstest.TestHandle1{ |
| A: zx.Handle(22), |
| B: zx.HandleInvalid, |
| C: vmo, |
| D: zx.VMO(zx.HandleInvalid), |
| }, 16}, |
| {"handle2", &bindingstest.TestHandle2{ |
| A: []zx.Handle{zx.Handle(vmo)}, |
| B: []zx.VMO{zx.VMO(zx.HandleInvalid)}, |
| }, 48}, |
| |
| // TODO(https://fxbug.dev/7832): Here we're checking the special logic adapting channels to |
| // `request<P>` or `P` representations. This is not supported by GIDL yet. |
| {"interface1", &bindingstest.TestInterface1{ |
| A: bindingstest.Test1WithCtxInterface(fidl.ChannelProxy{Channel: h0}), |
| B: bindingstest.Test1WithCtxInterface(fidl.ChannelProxy{Channel: zx.Channel(zx.HandleInvalid)}), |
| C: bindingstest.Test1WithCtxInterfaceRequest(fidl.InterfaceRequest{Channel: h1}), |
| D: bindingstest.Test1WithCtxInterfaceRequest(fidl.InterfaceRequest{ |
| Channel: zx.Channel(zx.HandleInvalid), |
| }), |
| }, 16}, |
| |
| {"recursive-struct", &bindingstest.TestRecursiveStruct{ |
| S: &bindingstest.TestRecursiveStruct{ |
| S: &bindingstest.TestRecursiveStruct{}, |
| }, |
| }, 24}, |
| } |
| } |
| |
| func check(t *testing.T, input fidl.Message, expectSize int) { |
| t.Helper() |
| var respb [zx.ChannelMaxMessageBytes]byte |
| var resphd [zx.ChannelMaxMessageHandles]zx.HandleDisposition |
| nb, nh, err := fidl.MarshalWithContext(testCtx, input, respb[:], resphd[:]) |
| if err != nil { |
| t.Fatalf("marshal: failed: %s", err) |
| } |
| if nb != expectSize { |
| t.Fatalf("marshal: expected size %d but got %d: %s", expectSize, nb, respb[:nb]) |
| } |
| var resphi [zx.ChannelMaxMessageHandles]zx.HandleInfo |
| for i := 0; i < nh; i++ { |
| resphi[i] = zx.HandleInfo{ |
| Handle: resphd[i].Handle, |
| Type: resphd[i].Type, |
| Rights: resphd[i].Rights, |
| } |
| } |
| output := makeDefault(reflect.TypeOf(input)) |
| nbActual, nhActual, err := fidl.UnmarshalWithContext2(testCtx, respb[:nb], resphi[:nh], output) |
| if err != nil { |
| t.Fatalf("unmarshal: failed: %s", err) |
| } |
| if !reflect.DeepEqual(input, output) { |
| t.Fatalf("unmarshal: expected: %#v, got: %#v", input, output) |
| } |
| if nb != nbActual { |
| t.Fatalf("unmarshal: num bytes, expected: %d, got: %d", nb, nbActual) |
| } |
| if nh != nhActual { |
| t.Fatalf("unmarshal: num handles, expected: %d, got: %d", nh, nhActual) |
| } |
| } |
| |
| func TestCorrectness(t *testing.T) { |
| for _, ex := range general() { |
| t.Run(ex.name, func(t *testing.T) { |
| check(t, ex.input, ex.expectSize) |
| }) |
| } |
| } |
| |
| type errorCaseUnmarshal struct { |
| name string |
| message fidl.Message |
| input []byte |
| errorCode fidl.ErrorCode |
| } |
| |
| // TODO(https://fxbug.dev/7832): We are lacking in negative tests in the conformance suite. |
| var baseErrorCasesUnmarshal = []errorCaseUnmarshal{ |
| {"empty-array-bindingstest.TestSimple", &bindingstest.TestSimple{}, []byte{}, fidl.ErrPayloadTooSmall}, |
| {"nil-array-bindingstest.TestSimple", &bindingstest.TestSimple{}, nil, fidl.ErrPayloadTooSmall}, |
| {"small-array-bindingstest.TestSimple", &bindingstest.TestSimple{}, []byte{0x00, 0x0}, fidl.ErrPayloadTooSmall}, |
| {"empty-array-bindingstest.TestSimpleBool", &bindingstest.TestSimpleBool{}, []byte{}, fidl.ErrPayloadTooSmall}, |
| {"nil-array-bindingstest.TestSimpleBool", &bindingstest.TestSimpleBool{}, nil, fidl.ErrPayloadTooSmall}, |
| {"empty-array-bindingstest.TestAlignment1", &bindingstest.TestAlignment1{}, []byte{}, fidl.ErrPayloadTooSmall}, |
| {"nil-array-bindingstest.TestAlignment1", &bindingstest.TestAlignment1{}, nil, fidl.ErrPayloadTooSmall}, |
| {"small-array-bindingstest.TestAlignment1", &bindingstest.TestAlignment1{}, []byte{0x00, 0x0}, fidl.ErrPayloadTooSmall}, |
| {"empty-array-bindingstest.TestAlignment2", &bindingstest.TestAlignment2{}, []byte{}, fidl.ErrPayloadTooSmall}, |
| {"nil-array-bindingstest.TestAlignment2", &bindingstest.TestAlignment2{}, nil, fidl.ErrPayloadTooSmall}, |
| {"small-array-bindingstest.TestAlignment2", &bindingstest.TestAlignment2{}, []byte{0x00, 0x0}, fidl.ErrPayloadTooSmall}, |
| {"small-array-bindingstest.TestAlignment2-2", &bindingstest.TestAlignment2{}, make([]byte, 10), fidl.ErrPayloadTooSmall}, |
| {"empty-array-bindingstest.TestFloat1", &bindingstest.TestFloat1{}, []byte{}, fidl.ErrPayloadTooSmall}, |
| {"nil-array-bindingstest.TestFloat1", &bindingstest.TestFloat1{}, nil, fidl.ErrPayloadTooSmall}, |
| {"small-array-bindingstest.TestFloat1", &bindingstest.TestFloat1{}, []byte{0x00, 0x0}, fidl.ErrPayloadTooSmall}, |
| {"empty-array-bindingstest.TestFloat2", &bindingstest.TestFloat2{}, []byte{}, fidl.ErrPayloadTooSmall}, |
| {"nil-array-bindingstest.TestFloat2", &bindingstest.TestFloat2{}, nil, fidl.ErrPayloadTooSmall}, |
| {"small-array-bindingstest.TestFloat2", &bindingstest.TestFloat2{}, []byte{0x00, 0x0}, fidl.ErrPayloadTooSmall}, |
| {"empty-array-bindingstest.TestFloat3", &bindingstest.TestFloat3{}, []byte{}, fidl.ErrPayloadTooSmall}, |
| {"nil-array-bindingstest.TestFloat3", &bindingstest.TestFloat3{}, nil, fidl.ErrPayloadTooSmall}, |
| {"small-array-bindingstest.TestFloat3", &bindingstest.TestFloat3{}, []byte{0x00, 0x0}, fidl.ErrPayloadTooSmall}, |
| {"small-array-bindingstest.TestFloat3-2", &bindingstest.TestFloat3{}, make([]byte, 6), fidl.ErrPayloadTooSmall}, |
| {"nil-array-bindingstest.TestArray1", &bindingstest.TestArray1{}, nil, fidl.ErrPayloadTooSmall}, |
| {"empty-array-bindingstest.TestArray1", &bindingstest.TestArray1{}, []byte{}, fidl.ErrPayloadTooSmall}, |
| {"two-bytes-array-bindingstest.TestArray1", &bindingstest.TestArray1{}, []byte{0x00, 0x0}, fidl.ErrPayloadTooSmall}, |
| {"nil-array-bindingstest.TestArray2", &bindingstest.TestArray2{}, nil, fidl.ErrPayloadTooSmall}, |
| {"empty-array-bindingstest.TestArray2", &bindingstest.TestArray2{}, []byte{}, fidl.ErrPayloadTooSmall}, |
| {"two-bytes-array-bindingstest.TestArray2", &bindingstest.TestArray2{}, []byte{0x00, 0x0}, fidl.ErrPayloadTooSmall}, |
| {"six-bytes-array-bindingstest.TestArray2", &bindingstest.TestArray2{}, make([]byte, 6), fidl.ErrPayloadTooSmall}, |
| {"nil-array-bindingstest.TestArray3", &bindingstest.TestArray3{}, nil, fidl.ErrPayloadTooSmall}, |
| {"empty-array-bindingstest.TestArray3", &bindingstest.TestArray3{}, []byte{}, fidl.ErrPayloadTooSmall}, |
| {"two-bytes-array-bindingstest.TestArray3", &bindingstest.TestArray3{}, []byte{0x00, 0x0}, fidl.ErrPayloadTooSmall}, |
| {"six-bytes-array-bindingstest.TestArray3", &bindingstest.TestArray3{}, make([]byte, 6), fidl.ErrPayloadTooSmall}, |
| {"thirteen-bytes-array-bindingstest.TestArray3", &bindingstest.TestArray3{}, make([]byte, 13), fidl.ErrPayloadTooSmall}, |
| {"nil-array-bindingstest.TestArray4", &bindingstest.TestArray4{}, nil, fidl.ErrPayloadTooSmall}, |
| {"empty-array-bindingstest.TestArray4", &bindingstest.TestArray4{}, []byte{}, fidl.ErrPayloadTooSmall}, |
| {"two-bytes-array-bindingstest.TestArray4", &bindingstest.TestArray4{}, []byte{0x00, 0x0}, fidl.ErrPayloadTooSmall}, |
| {"nil-array-bindingstest.TestString1", &bindingstest.TestString1{}, nil, fidl.ErrPayloadTooSmall}, |
| {"empty-array-bindingstest.TestString1", &bindingstest.TestString1{}, []byte{}, fidl.ErrPayloadTooSmall}, |
| {"two-bytes-array-bindingstest.TestString1", &bindingstest.TestString1{}, []byte{0x00, 0x0}, fidl.ErrPayloadTooSmall}, |
| {"nil-array-bindingstest.TestString2", &bindingstest.TestString2{}, nil, fidl.ErrPayloadTooSmall}, |
| {"empty-array-bindingstest.TestString2", &bindingstest.TestString2{}, []byte{}, fidl.ErrPayloadTooSmall}, |
| {"two-bytes-array-bindingstest.TestString2", &bindingstest.TestString2{}, []byte{0x00, 0x0}, fidl.ErrPayloadTooSmall}, |
| {"nil-array-TestStruct2", &bindingstest.TestStruct2{}, nil, fidl.ErrPayloadTooSmall}, |
| {"empty-array-TestStruct2", &bindingstest.TestStruct2{}, []byte{}, fidl.ErrPayloadTooSmall}, |
| {"two-bytes-array-TestStruct2", &bindingstest.TestStruct2{}, []byte{0x00, 0x0}, fidl.ErrPayloadTooSmall}, |
| {"six-bytes-array-TestStruct2", &bindingstest.TestStruct2{}, make([]byte, 6), fidl.ErrPayloadTooSmall}, |
| {"thirteen-bytes-array-TestStruct2", &bindingstest.TestStruct2{}, make([]byte, 13), fidl.ErrPayloadTooSmall}, |
| {"empty-struct-non-zero", &bindingstest.EmptyStruct{}, emptyStructWithOneInsteadOfZero, fidl.ErrInvalidEmptyStruct}, |
| } |
| |
| // TODO(https://fxbug.dev/7832): We are lacking in negative tests in the conformance suite. |
| var allErrorCasesUnmarshal = append(baseErrorCasesUnmarshal, []errorCaseUnmarshal{ |
| {"string-wrong-ptr-no-alloc", &bindingstest.TestStringWithBound{}, []byte{ |
| 3, 0, 0, 0, 0, 0, 0, 0, // length |
| 0, 0, 0, 0, 0, 0, 0, 0, // ptr (no alloc) |
| // no data, unmarshal should fail before |
| }, fidl.ErrUnexpectedNullRef}, |
| {"string-wrong-ptr-incorrect", &bindingstest.TestStringWithBound{}, []byte{ |
| 3, 0, 0, 0, 0, 0, 0, 0, // length |
| 0, 0, 0, 0, 0, 0, 0, 1, // ptr (no alloc) |
| // no data, unmarshal should fail before |
| }, fidl.ErrBadRefEncoding}, |
| {"string-too-long", &bindingstest.TestStringWithBound{}, []byte{ |
| 9, 0, 0, 0, 0, 0, 0, 0, // length (too long) |
| 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ptr |
| // no data, unmarshal should fail before |
| }, fidl.ErrStringTooLong}, |
| {"string-has-truncated-data", &bindingstest.TestStringWithBound{}, []byte{ |
| 8, 0, 0, 0, 0, 0, 0, 0, // length |
| 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ptr |
| 0x41, 0x72, 0x67, 0x68, 0x68, 0x68, 0x68, // only 7 bytes |
| }, fidl.ErrPayloadTooSmall}, |
| |
| {"opt-string-wrong-ptr-incorrect", &bindingstest.TestOptStringWithBound{}, []byte{ |
| 3, 0, 0, 0, 0, 0, 0, 0, // length |
| 0, 0, 0, 0, 0, 0, 0, 1, // ptr (no alloc) |
| // no data, unmarshal should fail before |
| }, fidl.ErrBadRefEncoding}, |
| {"opt-string-too-long", &bindingstest.TestOptStringWithBound{}, []byte{ |
| 9, 0, 0, 0, 0, 0, 0, 0, // length (too long) |
| 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // ptr |
| // no data, unmarshal should fail before |
| }, fidl.ErrStringTooLong}, |
| }...) |
| |
| var emptyStructWithOneInsteadOfZero = []byte{ |
| 1, // empty struct with invalid value of 1 (instead of zero) |
| 0, 0, 0, 0, 0, 0, 0, // 7 bytes of padding after empty struct, to align to 64 bits |
| } |
| |
| // TODO(https://fxbug.dev/7832): These should move into the conformance suite too as they captured |
| // actual regressions that occurred, which none of the other tests captured. |
| func TestAllManualSuccessCases(t *testing.T) { |
| // TODO(FIDL-635): Complete conversion. |
| var ipAddressConfig bindingstest.IpAddressConfig |
| ipAddressConfig.SetDhcp(true) |
| successCase{ |
| name: "add-ethernet-device-request", |
| context: testCtx, |
| input: &bindingstest.TestAddEthernetDeviceRequest{ |
| TopologicalPath: "@/dev/sys/pci/00:03.0/e1000/ethernet", |
| Config: bindingstest.InterfaceConfig{ |
| Name: "ethp0003", |
| IpAddressConfig: ipAddressConfig, |
| }, |
| Device: bindingstest.EthernetDeviceWithCtxInterface{Channel: zx.Channel(0xdeadbeef)}, |
| }, |
| bytes: []byte{ |
| 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // topological_path |
| 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // topological_path |
| 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // name |
| 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // name |
| 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // subnet (dhcp variant) |
| 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // subnet envelope (num bytes/handles) |
| 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // subnet envelope (PRESENT) |
| 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, // device (handle present) |
| 0x40, 0x2f, 0x64, 0x65, 0x76, 0x2f, 0x73, 0x79, // @/dev/sy |
| 0x73, 0x2f, 0x70, 0x63, 0x69, 0x2f, 0x30, 0x30, // s/pci/00 |
| 0x3a, 0x30, 0x33, 0x2e, 0x30, 0x2f, 0x65, 0x31, // :03.0/e1 |
| 0x30, 0x30, 0x30, 0x2f, 0x65, 0x74, 0x68, 0x65, // 000/ethe |
| 0x72, 0x6e, 0x65, 0x74, 0x00, 0x00, 0x00, 0x00, // rnet |
| 0x65, 0x74, 0x68, 0x70, 0x30, 0x30, 0x30, 0x33, // ethp0003 |
| 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // subnet (dhcp data) |
| }, |
| handleInfos: []zx.HandleInfo{ |
| { |
| Handle: zx.Handle(0xdeadbeef), |
| Rights: fidl.ProtocolRights, |
| Type: zx.ObjectTypeChannel, |
| }, |
| }, |
| checkRights: true, |
| }.check(t) |
| |
| successCase{ |
| name: "package-resolver-resolve-request", |
| context: testCtx, |
| input: &bindingstest.TestPackageResolverResolveRequest{ |
| PackageUrl: "a", |
| Selectors: []string{"a"}, |
| UpdatePolicy: bindingstest.UpdatePolicy{ |
| FetchIfAbsent: true, |
| AllowOldVersions: true, |
| }, |
| Dir: bindingstest.EthernetDeviceWithCtxInterfaceRequest{Channel: zx.Channel(0xdeadbeef)}, |
| }, |
| bytes: []byte{ |
| 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // package url size |
| 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // package url ptr |
| 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // selectors size |
| 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // selectors ptr |
| 0x01, 0x01, 0x00, 0x00, // policy struct + padding |
| 0xFF, 0xFF, 0xFF, 0xFF, // request handle |
| // out of line data |
| 0x61, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
| 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
| 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, |
| 0x61, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
| }, |
| handleInfos: []zx.HandleInfo{ |
| { |
| Handle: zx.Handle(0xdeadbeef), |
| Rights: fidl.ProtocolRights, |
| Type: zx.ObjectTypeChannel, |
| }, |
| }, |
| checkRights: true, |
| }.check(t) |
| } |
| |
| // Handle rights is not in conformance testing. |
| func TestHandleRightsMarshalUnmarshal(t *testing.T) { |
| data := make([]byte, 1024) |
| handleDispositions := make([]zx.HandleDisposition, 1) |
| input := &bindingstest.HandleRightsSubtypeTestStruct{H: []zx.VMO{5}} |
| _, nh, err := fidl.Marshal(input, data, handleDispositions) |
| if err != nil { |
| t.Fatal(err) |
| } |
| if nh != 1 { |
| t.Fatalf("unexpected number of handles: want %d, got %d", 1, nh) |
| } |
| if handleDispositions[0].Handle != *input.H[0].Handle() { |
| t.Fatalf("expected handle to match: want %d, got %d", input.H, handleDispositions[0].Handle) |
| } |
| if want := zx.RightDuplicate | zx.RightTransfer; handleDispositions[0].Rights != want { |
| t.Fatalf("incorrect rights: want %d, got %d", want, handleDispositions[0].Rights) |
| } |
| if want := zx.ObjectTypeVmo; handleDispositions[0].Type != want { |
| t.Fatalf("incorrect subtype: want %d, got %d", want, handleDispositions[0].Type) |
| } |
| |
| // normal unmarshaling |
| { |
| handleInfos := []zx.HandleInfo{ |
| { |
| Handle: handleDispositions[0].Handle, |
| Rights: handleDispositions[0].Rights, |
| Type: handleDispositions[0].Type, |
| }, |
| } |
| output := &bindingstest.HandleRightsSubtypeTestStruct{} |
| if _, _, err := fidl.Unmarshal(data, handleInfos, output); err != nil { |
| t.Fatal(err) |
| } |
| if output.H[0] != input.H[0] { |
| t.Fatalf("incorrect handle: want %d, got %d", input.H, output.H) |
| } |
| } |
| |
| // missing required rights |
| { |
| handleInfos := []zx.HandleInfo{ |
| { |
| Handle: handleDispositions[0].Handle, |
| Rights: 0x1, |
| Type: handleDispositions[0].Type, |
| }, |
| } |
| output := &bindingstest.HandleRightsSubtypeTestStruct{} |
| func() { |
| _, _, err := fidl.Unmarshal(data, handleInfos, output) |
| want := fidl.ErrMissingRequiredHandleRights |
| switch err := err.(type) { |
| case fidl.ValidationError: |
| if err.Code() == want { |
| return |
| } |
| } |
| t.Fatalf("got fidl.Unmarshal(...) = (_, _, %v), want %s", want, err) |
| }() |
| } |
| |
| // incorrect handle type |
| { |
| handleInfos := []zx.HandleInfo{ |
| { |
| Handle: handleDispositions[0].Handle, |
| Rights: handleDispositions[0].Rights, |
| Type: 1, |
| }, |
| } |
| output := &bindingstest.HandleRightsSubtypeTestStruct{} |
| func() { |
| _, _, err := fidl.Unmarshal(data, handleInfos, output) |
| want := fidl.ErrIncorrectHandleType |
| switch err := err.(type) { |
| case fidl.ValidationError: |
| if err.Code() == want { |
| return |
| } |
| } |
| t.Fatalf("got fidl.Unmarshal(...) = (_, _, %v), want %s", want, err) |
| }() |
| } |
| } |
| |
| // Handle rights is not in conformance testing. |
| func TestHandleUncheckedSubtypeMarshalUnmarshal(t *testing.T) { |
| data := make([]byte, 1024) |
| handleDispositions := make([]zx.HandleDisposition, 1) |
| input := &bindingstest.PlainHandleTestStruct{H: zx.Handle(5)} |
| _, nh, err := fidl.Marshal(input, data, handleDispositions) |
| if err != nil { |
| t.Fatal(err) |
| } |
| if nh != 1 { |
| t.Fatalf("unexpected number of handles: want %d, got %d", 1, nh) |
| } |
| if handleDispositions[0].Handle != input.H { |
| t.Fatalf("expected handle to match: want %d, got %d", input.H, handleDispositions[0].Handle) |
| } |
| if handleDispositions[0].Type != 0 { |
| t.Fatalf("incorrect subtype: want %d, got %d", 0, handleDispositions[0].Type) |
| } |
| |
| // normal unmarshaling |
| { |
| handleInfos := []zx.HandleInfo{ |
| { |
| Handle: handleDispositions[0].Handle, |
| Type: handleDispositions[0].Type, |
| }, |
| } |
| output := &bindingstest.PlainHandleTestStruct{} |
| if _, _, err := fidl.Unmarshal(data, handleInfos, output); err != nil { |
| t.Fatal(err) |
| } |
| if output.H != input.H { |
| t.Fatalf("incorrect handle: want %d, got %d", input.H, output.H) |
| } |
| } |
| |
| // unchecked handle type |
| { |
| handleInfos := []zx.HandleInfo{ |
| { |
| Handle: handleDispositions[0].Handle, |
| Type: 1, |
| }, |
| } |
| output := &bindingstest.PlainHandleTestStruct{} |
| if _, _, err = fidl.Unmarshal(data, handleInfos, output); err != nil { |
| t.Fatalf("expected handle of type ZX_OBJ_TYPE_NONE to be unchecked") |
| } |
| if output.H != input.H { |
| t.Fatalf("incorrect handle: want %d, got %d", input.H, output.H) |
| } |
| } |
| } |
| |
| // This is a specific test checking that the marshaler construction properly |
| // fails with a clear error message if fed incorrect generated code. Hence, |
| // this has to stay a hand written test. |
| func TestFailureNullableTable(t *testing.T) { |
| type TestNullableTable struct { |
| _ struct{} `fidl:"s"` |
| A *bindingstest.SimpleTable `fidl:"0" fidl_offset_v1:"0"` |
| } |
| _, err := fidl.CreateMarshaler(TestNullableTable{}) |
| if err == nil { |
| t.Fatalf("expected error creating marshaler for nullable table") |
| } |
| if !strings.Contains(err.Error(), "optional field marshaler") { |
| t.Fatalf("unexpected error: %s", err.Error()) |
| } |
| } |
| |
| // TODO(https://fxbug.dev/7832): We are lacking in negative tests in the conformance suite. |
| func TestFailuresMarshal(t *testing.T) { |
| v1 := []int64{1, 2, 3} |
| cases := []struct { |
| name string |
| input fidl.Message |
| errorCode fidl.ErrorCode |
| }{ |
| {"string3-string-too-long", &bindingstest.TestString3{ |
| A: [2]string{ |
| "too long!", // limit is 4, provided is longer(tm) |
| "g", |
| }, |
| B: [2]*string{nil, nil}, |
| }, fidl.ErrStringTooLong}, |
| {"vector1-C-vector-too-long", &bindingstest.TestVector1{ |
| A: []int8{1, 2, 3, 4}, |
| B: nil, |
| C: []int32{99, 100, 101}, // limit is 2, provided is 3 |
| D: nil, |
| }, fidl.ErrVectorTooLong}, |
| {"vector1-D-vector-too-long", &bindingstest.TestVector1{ |
| A: []int8{1, 2, 3, 4}, |
| B: nil, |
| C: []int32{99}, |
| D: &v1, // limit is 2, provided is 3 |
| }, fidl.ErrVectorTooLong}, |
| } |
| for _, ex := range cases { |
| t.Run(ex.name, func(t *testing.T) { |
| var respb [zx.ChannelMaxMessageBytes]byte |
| var resphd [zx.ChannelMaxMessageHandles]zx.HandleDisposition |
| _, _, err := fidl.MarshalWithContext(testCtx, ex.input, respb[:], resphd[:]) |
| switch err := err.(type) { |
| case fidl.ValidationError: |
| if err.Code() == ex.errorCode { |
| return |
| } |
| } |
| t.Fatalf("got fidl.MarshalWithContext(...) = (_, _, %v), want %s", ex.errorCode, err) |
| }) |
| } |
| } |
| |
| // TODO(https://fxbug.dev/7832): We are lacking in negative tests in the conformance suite. |
| func TestFailuresUnmarshalNoHandles(t *testing.T) { |
| for _, ex := range allErrorCasesUnmarshal { |
| t.Run(ex.name, func(t *testing.T) { |
| _, _, err := fidl.Unmarshal(ex.input, nil, ex.message) |
| switch err := err.(type) { |
| case fidl.ValidationError: |
| if err.Code() == ex.errorCode { |
| return |
| } |
| } |
| t.Fatalf("got fidl.Unmarshal(...) = (_, _, %v), want %s", ex.errorCode, err) |
| }) |
| } |
| } |
| |
| // TODO(https://fxbug.dev/62647): Move to GIDL once we support protocol handles. |
| func TestConformanceClientEnd(t *testing.T) { |
| successCase{ |
| name: "handles-clientend", |
| context: testCtx, |
| input: &bindingstest.HasClientEnd{ |
| ClientEnd: bindingstest.ExampleProtocolWithCtxInterface(fidl.ChannelProxy{ |
| Channel: zx.Channel(0x44332211), |
| }), |
| }, |
| bytes: []byte{ |
| 0xff, 0xff, 0xff, 0xff, // handle present |
| 0x00, 0x00, 0x00, 0x00, // padding |
| }, |
| handleInfos: []zx.HandleInfo{ |
| { |
| Handle: zx.Handle(0x44332211), |
| Rights: fidl.ProtocolRights, |
| Type: zx.ObjectTypeChannel, |
| }, |
| }, |
| checkRights: true, |
| }.check(t) |
| } |
| |
| // TODO(https://fxbug.dev/62647): Move to GIDL once we support protocol handles. |
| func TestConformanceServerEnd(t *testing.T) { |
| successCase{ |
| name: "handles-serverend", |
| context: testCtx, |
| input: &bindingstest.HasServerEnd{ |
| ServerEnd: bindingstest.ExampleProtocolWithCtxInterfaceRequest(fidl.InterfaceRequest{ |
| Channel: zx.Channel(0x44332211), |
| }), |
| }, |
| bytes: []byte{ |
| 0xff, 0xff, 0xff, 0xff, // handle present |
| 0x00, 0x00, 0x00, 0x00, // padding |
| }, |
| handleInfos: []zx.HandleInfo{ |
| { |
| Handle: zx.Handle(0x44332211), |
| Rights: fidl.ProtocolRights, |
| Type: zx.ObjectTypeChannel, |
| }, |
| }, |
| checkRights: true, |
| }.check(t) |
| } |
| |
| func TestBitsApi(t *testing.T) { |
| raw := uint32(0b110101) |
| |
| unknownStrict := bindingstest.StrictBits(raw) |
| if !unknownStrict.HasUnknownBits() { |
| t.Error("unknown bits returned false for HasUnknownBits") |
| } |
| if unknownStrict.GetUnknownBits() != 0b110100 { |
| t.Errorf( |
| "Got wrong unknown bits: expected %b, was %b", 0b110100, unknownStrict.GetUnknownBits()) |
| } |
| if unknownStrict.InvertBits() != 0b10 { |
| t.Errorf( |
| "Got wrong InvertBits: expected %b, got %b", 0b10, unknownStrict.InvertBits()) |
| } |
| if unknownStrict.InvertBits().InvertBits() != 0b1 { |
| t.Errorf( |
| "Got wrong double InvertBits: expected %b, got %b", 0b1, unknownStrict.InvertBits().InvertBits()) |
| } |
| if !unknownStrict.HasBits(0b1) { |
| t.Errorf("Failed to match on known bits for HasBits") |
| } |
| if !unknownStrict.HasBits(0b110000) { |
| t.Errorf("Failed to match on unknown bits for HasBits") |
| } |
| if unknownStrict.HasBits(0b10) { |
| t.Errorf("Matched on known bits for HasBits when it should not") |
| } |
| if unknownStrict.HasBits(0b1000) { |
| t.Errorf("Matched on unknown bits for HasBits when it should not") |
| } |
| if unknownStrict.ClearBits(0b1) != bindingstest.StrictBits(0b110100) { |
| t.Errorf("Failed to clear known bits for ClearBits") |
| } |
| if unknownStrict.ClearBits(0b10000) != bindingstest.StrictBits(0b100101) { |
| t.Errorf("Failed to clear unknown bits for ClearBits") |
| } |
| if unknownStrict != unknownStrict.ClearBits(0b10) { |
| t.Errorf("Cleared known bits when it should not") |
| } |
| if unknownStrict != unknownStrict.ClearBits(0b1000) { |
| t.Errorf("Cleared unknown bits when it should not") |
| } |
| |
| knownStrict := unknownStrict & bindingstest.StrictBits_Mask |
| if knownStrict != bindingstest.StrictBitsOne { |
| t.Errorf("Expected masked value: %b, got %b", bindingstest.StrictBitsOne, knownStrict) |
| } |
| |
| unknownFlexible := bindingstest.FlexibleBits(raw) |
| if !unknownFlexible.HasUnknownBits() { |
| t.Error("unknown bits returned false for HasUnknownBits") |
| } |
| if unknownFlexible.GetUnknownBits() != 0b110100 { |
| t.Errorf( |
| "Got wrong unknown bits: expected %b, was %b", 0b110100, unknownFlexible.GetUnknownBits()) |
| } |
| if unknownFlexible.InvertBits() != 0b10 { |
| t.Errorf( |
| "Got wrong InvertBits: expected %b, got %b", 0b10, unknownFlexible.InvertBits()) |
| } |
| if unknownFlexible.InvertBits().InvertBits() != 0b1 { |
| t.Errorf( |
| "Got wrong double InvertBits: expected %b, got %b", 0b1, unknownFlexible.InvertBits().InvertBits()) |
| } |
| if !unknownFlexible.HasBits(0b1) { |
| t.Errorf("Failed to match on known bits for HasBits") |
| } |
| if !unknownFlexible.HasBits(0b110000) { |
| t.Errorf("Failed to match on unknown bits for HasBits") |
| } |
| if unknownFlexible.HasBits(0b10) { |
| t.Errorf("Matched on known bits for HasBits when it should not") |
| } |
| if unknownFlexible.HasBits(0b1000) { |
| t.Errorf("Matched on unknown bits for HasBits when it should not") |
| } |
| if unknownFlexible.ClearBits(0b1) != bindingstest.FlexibleBits(0b110100) { |
| t.Errorf("Failed to clear known bits for ClearBits") |
| } |
| if unknownFlexible.ClearBits(0b10000) != bindingstest.FlexibleBits(0b100101) { |
| t.Errorf("Failed to clear unknown bits for ClearBits") |
| } |
| if unknownFlexible != unknownFlexible.ClearBits(0b10) { |
| t.Errorf("Cleared known bits when it should not") |
| } |
| if unknownFlexible != unknownFlexible.ClearBits(0b1000) { |
| t.Errorf("Cleared unknown bits when it should not") |
| } |
| |
| knownFlexible := unknownFlexible & bindingstest.FlexibleBits_Mask |
| if knownFlexible != bindingstest.FlexibleBitsOne { |
| t.Errorf("Expected masked value: %b, got %b", bindingstest.FlexibleBitsOne, knownFlexible) |
| } |
| } |
| |
| func TestUnionApi(t *testing.T) { |
| union := bindingstest.XUnion1{ |
| I_xUnion1Tag: 4, |
| I_unknownData: fidl.UnknownData{ |
| Bytes: []byte{51}, |
| }, |
| } |
| if union.Which() != bindingstest.XUnion1_unknownData { |
| t.Errorf("Expected unknown union to have unknown tag") |
| } |
| |
| data := union.GetUnknownData() |
| if want := []byte{51}; !bytes.Equal(data.Bytes, want) { |
| t.Errorf("Expected unknown data to be %s, got: %s", want, data.Bytes) |
| } |
| if len(data.Handles) != 0 { |
| t.Errorf("Expected empty unknown handles, got %d", data.Handles) |
| } |
| |
| union.SetD(1.0) |
| if union != bindingstest.XUnion1WithD(1.0) { |
| t.Errorf("Expected modified-in-place union modified from unknown variant and constructed union to be equal") |
| } |
| |
| union.SetA([3]int8{0, 1, 2}) |
| if union != bindingstest.XUnion1WithA([3]int8{0, 1, 2}) { |
| t.Errorf("Expected modified-in-place union modified from known variant and constructed union to be equal") |
| } |
| } |
| |
| func TestTableApi(t *testing.T) { |
| var emptyTable bindingstest.SimpleTable |
| if emptyTable.HasUnknownData() { |
| t.Errorf("Expected new table to have empty unknown data") |
| } |
| |
| table := bindingstest.SimpleTable{ |
| I_unknownData: map[uint64]fidl.UnknownData{ |
| 3: { |
| Bytes: []byte{51}, |
| }, |
| }, |
| } |
| |
| table.SetX(5) |
| if !table.HasX() { |
| t.Errorf("Expected X to be set") |
| } |
| if table.GetX() != 5 { |
| t.Errorf("Expected X value 5, got: %d", table.GetX()) |
| } |
| if table.HasY() { |
| t.Errorf("Expected Y to be unset") |
| } |
| y := table.GetYWithDefault(13) |
| if y != 13 { |
| t.Errorf("Expected default Y value 13, got: %d", y) |
| } |
| if !table.HasUnknownData() { |
| t.Errorf("Expected table to have unknown data") |
| } |
| unknownData := table.GetUnknownData() |
| data, ok := unknownData[3] |
| if !ok { |
| t.Errorf("Expected table to have unknown ordinal 3") |
| } |
| if want := []byte{51}; !bytes.Equal(data.Bytes, want) { |
| t.Errorf("Expected unknown data to be %s, got: %s", want, data.Bytes) |
| } |
| if len(data.Handles) != 0 { |
| t.Errorf("Expected empty unknown handles") |
| } |
| } |
| |
| func TestRecursiveVectors(t *testing.T) { |
| successCase{ |
| name: "recursive-vector-struct", |
| context: testCtx, |
| input: &bindingstest.TestRecursiveVectorStruct{ |
| V: []*bindingstest.TestRecursiveVectorStruct{ |
| { |
| V: []*bindingstest.TestRecursiveVectorStruct{}, |
| }, |
| }, |
| }, |
| bytes: []byte{ |
| 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
| 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, |
| 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, |
| 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
| 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, |
| }, |
| }.check(t) |
| |
| a := bindingstest.TestRecursiveVectorUnionWithA(1.0) |
| b := bindingstest.TestRecursiveVectorUnionWithB([]*bindingstest.TestRecursiveVectorUnion{ |
| &a, |
| }) |
| successCase{ |
| name: "recursive-vector-union", |
| context: testCtx, |
| input: &bindingstest.TestRecursiveUnionStruct{ |
| U: &b, |
| }, |
| bytes: []byte{ |
| 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
| 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
| 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, |
| 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
| 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, |
| 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
| 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
| 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, |
| 0x00, 0x00, 0x80, 0x3f, 0x00, 0x00, 0x00, 0x00, |
| }, |
| }.check(t) |
| } |
