| // 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 ir |
| |
| import ( |
| "fmt" |
| "reflect" |
| "testing" |
| |
| "fidl/compiler/backend/types" |
| . "fidl/compiler/backend/typestest" |
| ) |
| |
| type expectKind int |
| |
| const ( |
| expectEnums expectKind = iota |
| expectStructs |
| expectInterface |
| expectTable |
| ) |
| |
| func compileExpect(t *testing.T, testName string, kind expectKind, input types.Root, wrapped_expect Root) { |
| t.Run(testName, func(t *testing.T) { |
| wrapped_actual := Compile(input) |
| var actual, expect interface{} |
| switch kind { |
| case expectEnums: |
| actual = wrapped_actual.Enums |
| expect = wrapped_expect.Enums |
| case expectStructs: |
| actual = wrapped_actual.Structs |
| expect = wrapped_expect.Structs |
| case expectInterface: |
| actual = wrapped_actual.Interfaces |
| expect = wrapped_expect.Interfaces |
| case expectTable: |
| actual = wrapped_actual.Tables |
| expect = wrapped_expect.Tables |
| default: |
| panic(fmt.Sprintf("unknown expect kind %d", kind)) |
| } |
| if !reflect.DeepEqual(actual, expect) { |
| t.Fatalf("expected: %+v,\ngot :%+v", expect, actual) |
| } |
| }) |
| } |
| |
| func compileEnumsExpect(t *testing.T, testName string, input []types.Enum, expect []Enum) { |
| compileExpect(t, testName, expectEnums, types.Root{Enums: input}, Root{Enums: expect}) |
| } |
| |
| func compileStructsExpect(t *testing.T, testName string, input []types.Struct, expect []Struct) { |
| compileExpect(t, testName, expectStructs, types.Root{Structs: input}, Root{Structs: expect}) |
| } |
| |
| func compileTableExpect(t *testing.T, testName string, input types.Table, expect Table) { |
| compileExpect(t, testName, expectTable, types.Root{Tables: []types.Table{input}}, Root{Tables: []Table{expect}}) |
| } |
| |
| func compileInterfaceExpect(t *testing.T, testName string, input types.Interface, expect Interface) { |
| compileExpect(t, testName, expectInterface, types.Root{Interfaces: []types.Interface{input}}, Root{Interfaces: []Interface{expect}}) |
| } |
| |
| func TestCompileStruct(t *testing.T) { |
| t.Parallel() |
| |
| compileStructsExpect(t, "Basic struct", []types.Struct{ |
| { |
| Name: types.EncodedCompoundIdentifier("Test"), |
| Members: []types.StructMember{ |
| { |
| Type: PrimitiveType(types.Int8), |
| Name: types.Identifier("Test"), |
| }, |
| { |
| Type: PrimitiveType(types.Float32), |
| Name: types.Identifier("Test2"), |
| }, |
| }, |
| }, |
| }, []Struct{ |
| { |
| Name: "Test", |
| Members: []StructMember{ |
| { |
| Type: "int8", |
| PrivateName: "test", |
| Name: "Test", |
| }, |
| { |
| Type: "float32", |
| PrivateName: "test2", |
| Name: "Test2", |
| }, |
| }, |
| }, |
| }) |
| |
| compileStructsExpect(t, "Struct with name mangling", []types.Struct{ |
| { |
| Name: types.EncodedCompoundIdentifier("test"), |
| Members: []types.StructMember{ |
| { |
| Type: PrimitiveType(types.Int8), |
| Name: types.Identifier("test"), |
| }, |
| }, |
| }, |
| }, []Struct{ |
| { |
| Name: "Test", |
| Members: []StructMember{ |
| { |
| Type: "int8", |
| PrivateName: "test", |
| Name: "Test", |
| }, |
| }, |
| }, |
| }) |
| |
| compileStructsExpect(t, "Struct with array types", []types.Struct{ |
| { |
| Name: types.EncodedCompoundIdentifier("Test"), |
| Members: []types.StructMember{ |
| { |
| Type: ArrayType(PrimitiveType(types.Uint8), 10), |
| Name: types.Identifier("Flat"), |
| }, |
| { |
| Type: ArrayType(ArrayType(PrimitiveType(types.Bool), 1), 27), |
| Name: types.Identifier("Nested"), |
| }, |
| }, |
| }, |
| }, []Struct{ |
| { |
| Name: "Test", |
| Members: []StructMember{ |
| { |
| Type: "[10]uint8", |
| PrivateName: "flat", |
| Name: "Flat", |
| }, |
| { |
| Type: "[27][1]bool", |
| PrivateName: "nested", |
| Name: "Nested", |
| }, |
| }, |
| }, |
| }) |
| |
| maxElems := 40 |
| compileStructsExpect(t, "Struct with string types", []types.Struct{ |
| { |
| Name: types.EncodedCompoundIdentifier("Test"), |
| Members: []types.StructMember{ |
| { |
| Type: StringType(nil), |
| Name: types.Identifier("Flat"), |
| }, |
| { |
| Type: Nullable(StringType(nil)), |
| Name: types.Identifier("Nullable"), |
| }, |
| { |
| Type: Nullable(StringType(&maxElems)), |
| Name: types.Identifier("Max"), |
| }, |
| { |
| Type: ArrayType(StringType(nil), 27), |
| Name: types.Identifier("Nested"), |
| }, |
| { |
| Type: ArrayType(Nullable(StringType(&maxElems)), 27), |
| Name: types.Identifier("NestedNullableMax"), |
| }, |
| }, |
| }, |
| }, []Struct{ |
| { |
| Name: "Test", |
| Members: []StructMember{ |
| { |
| Type: "string", |
| PrivateName: "flat", |
| Name: "Flat", |
| }, |
| { |
| Type: "*string", |
| PrivateName: "nullable", |
| Name: "Nullable", |
| }, |
| { |
| Type: "*string", |
| PrivateName: "max", |
| Name: "Max", |
| Tags: "`" + `fidl:"40" fidl2:"40"` + "`", |
| }, |
| { |
| Type: "[27]string", |
| PrivateName: "nested", |
| Name: "Nested", |
| }, |
| { |
| Type: "[27]*string", |
| PrivateName: "nestedNullableMax", |
| Name: "NestedNullableMax", |
| Tags: "`" + `fidl:"40" fidl2:"40"` + "`", |
| }, |
| }, |
| }, |
| }) |
| |
| compileStructsExpect(t, "Struct with vector types", []types.Struct{ |
| { |
| Name: types.EncodedCompoundIdentifier("Test"), |
| Members: []types.StructMember{ |
| { |
| Type: VectorType(PrimitiveType(types.Uint8), nil), |
| Name: types.Identifier("Flat"), |
| }, |
| { |
| Type: VectorType(PrimitiveType(types.Uint8), &maxElems), |
| Name: types.Identifier("Max"), |
| }, |
| { |
| Type: VectorType(VectorType(PrimitiveType(types.Bool), nil), nil), |
| Name: types.Identifier("Nested"), |
| }, |
| { |
| Type: VectorType(Nullable(VectorType(PrimitiveType(types.Bool), nil)), nil), |
| Name: types.Identifier("Nullable"), |
| }, |
| { |
| Type: VectorType(VectorType(VectorType(PrimitiveType(types.Uint8), &maxElems), nil), nil), |
| Name: types.Identifier("NestedMax"), |
| }, |
| }, |
| }, |
| }, []Struct{ |
| { |
| Name: "Test", |
| Members: []StructMember{ |
| { |
| Type: "[]uint8", |
| PrivateName: "flat", |
| Name: "Flat", |
| }, |
| { |
| Type: "[]uint8", |
| PrivateName: "max", |
| Name: "Max", |
| Tags: "`" + `fidl:"40" fidl2:"40"` + "`", |
| }, |
| { |
| Type: "[][]bool", |
| PrivateName: "nested", |
| Name: "Nested", |
| }, |
| { |
| Type: "[]*[]bool", |
| PrivateName: "nullable", |
| Name: "Nullable", |
| }, |
| { |
| Type: "[][][]uint8", |
| PrivateName: "nestedMax", |
| Name: "NestedMax", |
| Tags: "`" + `fidl:"40,," fidl2:",,40"` + "`", |
| }, |
| }, |
| }, |
| }) |
| |
| compileStructsExpect(t, "Struct with nullable handles", []types.Struct{ |
| { |
| Name: types.EncodedCompoundIdentifier("Test"), |
| Members: []types.StructMember{ |
| { |
| Type: VectorType(Nullable(HandleType()), nil), |
| Name: types.Identifier("NullableHandles"), |
| }, |
| { |
| Type: VectorType(HandleType(), &maxElems), |
| Name: types.Identifier("BoundedNonNullableHandles"), |
| }, |
| }, |
| }, |
| }, []Struct{ |
| { |
| Name: "Test", |
| Members: []StructMember{ |
| { |
| Type: "[]_zx.Handle", |
| PrivateName: "nullableHandles", |
| Name: "NullableHandles", |
| Tags: "`" + `fidl:"*," fidl2:",1"` + "`", |
| }, |
| { |
| Type: "[]_zx.Handle", |
| PrivateName: "boundedNonNullableHandles", |
| Name: "BoundedNonNullableHandles", |
| Tags: "`" + `fidl:"40" fidl2:"40,0"` + "`", |
| }, |
| }, |
| }, |
| }) |
| |
| one, three := 1, 3 |
| compileStructsExpect(t, "Struct with arrays and vectors", []types.Struct{ |
| { |
| Name: types.EncodedCompoundIdentifier("Test"), |
| Members: []types.StructMember{ |
| { |
| Type: VectorType(ArrayType(VectorType(ArrayType(PrimitiveType(types.Uint8), 4), nil), 2), nil), |
| Name: types.Identifier("no_vec_bounds"), |
| }, |
| { |
| Type: VectorType(ArrayType(VectorType(ArrayType(PrimitiveType(types.Uint8), 4), nil), 2), &one), |
| Name: types.Identifier("outer_vec_bounds"), |
| }, |
| { |
| Type: VectorType(ArrayType(VectorType(ArrayType(PrimitiveType(types.Uint8), 4), &three), 2), nil), |
| Name: types.Identifier("inner_vec_bounds"), |
| }, |
| { |
| Type: VectorType(ArrayType(VectorType(ArrayType(PrimitiveType(types.Uint8), 4), &three), 2), &one), |
| Name: types.Identifier("both_vec_bounds"), |
| }, |
| }, |
| }, |
| }, []Struct{ |
| { |
| Name: "Test", |
| Members: []StructMember{ |
| { |
| Type: "[][2][][4]uint8", |
| PrivateName: "noVecBounds", |
| Name: "NoVecBounds", |
| }, |
| { |
| Type: "[][2][][4]uint8", |
| PrivateName: "outerVecBounds", |
| Name: "OuterVecBounds", |
| Tags: "`" + `fidl:",1" fidl2:"1,"` + "`", |
| }, |
| { |
| Type: "[][2][][4]uint8", |
| PrivateName: "innerVecBounds", |
| Name: "InnerVecBounds", |
| Tags: "`" + `fidl:"3," fidl2:",3"` + "`", |
| }, |
| { |
| Type: "[][2][][4]uint8", |
| PrivateName: "bothVecBounds", |
| Name: "BothVecBounds", |
| Tags: "`" + `fidl:"3,1" fidl2:"1,3"` + "`", |
| }, |
| }, |
| }, |
| }) |
| } |
| |
| func TestCompileEnum(t *testing.T) { |
| t.Parallel() |
| |
| compileEnumsExpect(t, "Basic enum", []types.Enum{ |
| { |
| Name: types.EncodedCompoundIdentifier("Test"), |
| Type: types.Int64, |
| Members: []types.EnumMember{ |
| { |
| Name: types.Identifier("One"), |
| Value: NumericLiteral(1), |
| }, |
| { |
| Name: types.Identifier("Two"), |
| Value: NumericLiteral(2), |
| }, |
| }, |
| }, |
| }, []Enum{ |
| { |
| Name: "Test", |
| Type: "int64", |
| Members: []EnumMember{ |
| { |
| Name: "One", |
| Value: "1", |
| }, |
| { |
| Name: "Two", |
| Value: "2", |
| }, |
| }, |
| }, |
| }) |
| |
| compileEnumsExpect(t, "Bool enum", []types.Enum{ |
| { |
| Name: types.EncodedCompoundIdentifier("Test"), |
| Type: types.Bool, |
| Members: []types.EnumMember{ |
| { |
| Name: types.Identifier("One"), |
| Value: BoolLiteral(true), |
| }, |
| { |
| Name: types.Identifier("Two"), |
| Value: BoolLiteral(false), |
| }, |
| }, |
| }, |
| }, []Enum{ |
| { |
| Name: "Test", |
| Type: "bool", |
| Members: []EnumMember{ |
| { |
| Name: "One", |
| Value: "true", |
| }, |
| { |
| Name: "Two", |
| Value: "false", |
| }, |
| }, |
| }, |
| }) |
| |
| compileEnumsExpect(t, "Enum with name mangling", []types.Enum{ |
| { |
| Name: types.EncodedCompoundIdentifier("test"), |
| Type: types.Uint32, |
| Members: []types.EnumMember{ |
| { |
| Name: types.Identifier("test"), |
| Value: NumericLiteral(125412512), |
| }, |
| }, |
| }, |
| }, []Enum{ |
| { |
| Name: "Test", |
| Type: "uint32", |
| Members: []EnumMember{ |
| { |
| Name: "Test", |
| Value: "125412512", |
| }, |
| }, |
| }, |
| }) |
| } |
| |
| func TestCompileInterface(t *testing.T) { |
| compileInterfaceExpect(t, "Basic", types.Interface{ |
| Attributes: types.Attributes{ |
| Attributes: []types.Attribute{ |
| {Name: types.Identifier("ServiceName"), Value: "Test"}, |
| }, |
| }, |
| Name: types.EncodedCompoundIdentifier("Test"), |
| Methods: []types.Method{ |
| { |
| Ordinal: types.Ordinal(1), |
| GenOrdinal: types.Ordinal(1789789), |
| Name: types.Identifier("First"), |
| HasRequest: true, |
| Request: []types.Parameter{ |
| { |
| Type: PrimitiveType(types.Int16), |
| Name: types.Identifier("Value"), |
| }, |
| }, |
| RequestSize: 18, |
| }, |
| { |
| Ordinal: types.Ordinal(2), |
| GenOrdinal: types.Ordinal(2789789), |
| Name: types.Identifier("Second"), |
| HasRequest: true, |
| Request: []types.Parameter{ |
| { |
| Type: Nullable(StringType(nil)), |
| Name: types.Identifier("Value"), |
| }, |
| }, |
| RequestSize: 32, |
| HasResponse: true, |
| Response: []types.Parameter{ |
| { |
| Type: PrimitiveType(types.Uint32), |
| Name: types.Identifier("Value"), |
| }, |
| }, |
| ResponseSize: 20, |
| }, |
| }, |
| }, Interface{ |
| Attributes: types.Attributes{ |
| Attributes: []types.Attribute{ |
| {Name: types.Identifier("ServiceName"), Value: "Test"}, |
| }, |
| }, |
| Name: "Test", |
| ProxyName: "TestInterface", |
| ProxyType: "ChannelProxy", |
| StubName: "TestStub", |
| EventProxyName: "TestEventProxy", |
| TransitionalBaseName: "TestTransitionalBase", |
| RequestName: "TestInterfaceRequest", |
| ServerName: "TestService", |
| ServiceNameString: "", |
| ServiceNameConstant: "TestName", |
| Methods: []Method{ |
| { |
| Ordinal: types.Ordinal(1), |
| OrdinalName: "TestFirstOrdinal", |
| GenOrdinal: types.Ordinal(1789789), |
| GenOrdinalName: "TestFirstGenOrdinal", |
| Name: "First", |
| Request: &Struct{ |
| Name: "TestFirstRequest", |
| Members: []StructMember{ |
| { |
| Name: "Value", |
| PrivateName: "value", |
| Type: "int16", |
| }, |
| }, |
| Size: 2, |
| }, |
| EventExpectName: "ExpectFirst", |
| IsEvent: false, |
| }, |
| { |
| Ordinal: types.Ordinal(2), |
| OrdinalName: "TestSecondOrdinal", |
| GenOrdinal: types.Ordinal(2789789), |
| GenOrdinalName: "TestSecondGenOrdinal", |
| Name: "Second", |
| Request: &Struct{ |
| Name: "TestSecondRequest", |
| Members: []StructMember{ |
| { |
| Name: "Value", |
| PrivateName: "value", |
| Type: "*string", |
| }, |
| }, |
| Size: 16, |
| }, |
| Response: &Struct{ |
| Name: "TestSecondResponse", |
| Members: []StructMember{ |
| { |
| Name: "Value", |
| PrivateName: "value", |
| Type: "uint32", |
| }, |
| }, |
| Size: 4, |
| }, |
| EventExpectName: "ExpectSecond", |
| IsEvent: false, |
| }, |
| }, |
| }) |
| |
| compileInterfaceExpect(t, "Event and name mangling", types.Interface{ |
| Attributes: types.Attributes{ |
| Attributes: []types.Attribute{ |
| {Name: types.Identifier("ServiceName"), Value: "Test"}, |
| }, |
| }, |
| Name: types.EncodedCompoundIdentifier("test"), |
| Methods: []types.Method{ |
| { |
| Ordinal: types.Ordinal(1), |
| GenOrdinal: types.Ordinal(9), |
| Name: types.Identifier("first"), |
| HasResponse: true, |
| Response: []types.Parameter{ |
| { |
| Type: StringType(nil), |
| Name: types.Identifier("value"), |
| }, |
| }, |
| ResponseSize: 32, |
| }, |
| }, |
| }, Interface{ |
| Attributes: types.Attributes{ |
| Attributes: []types.Attribute{ |
| {Name: types.Identifier("ServiceName"), Value: "Test"}, |
| }, |
| }, |
| Name: "Test", |
| ProxyName: "TestInterface", |
| ProxyType: "ChannelProxy", |
| StubName: "TestStub", |
| EventProxyName: "TestEventProxy", |
| TransitionalBaseName: "TestTransitionalBase", |
| RequestName: "TestInterfaceRequest", |
| ServerName: "TestService", |
| ServiceNameString: "", |
| ServiceNameConstant: "TestName", |
| Methods: []Method{ |
| { |
| Ordinal: types.Ordinal(1), |
| OrdinalName: "TestFirstOrdinal", |
| GenOrdinal: types.Ordinal(9), |
| GenOrdinalName: "TestFirstGenOrdinal", |
| Name: "First", |
| Response: &Struct{ |
| Name: "TestFirstResponse", |
| Members: []StructMember{ |
| { |
| Name: "Value", |
| PrivateName: "value", |
| Type: "string", |
| }, |
| }, |
| Size: 16, |
| }, |
| EventExpectName: "ExpectFirst", |
| IsEvent: true, |
| }, |
| }, |
| }) |
| } |
| func TestCompileTable(t *testing.T) { |
| five, seven := 5, 7 |
| compileTableExpect( |
| t, |
| "Basic", |
| types.Table{ |
| Name: types.EncodedCompoundIdentifier("Test"), |
| Size: 123, |
| Alignment: 456, |
| Members: []types.TableMember{ |
| { |
| Reserved: true, |
| Ordinal: 1, |
| }, |
| { |
| Ordinal: 2, |
| Name: "second", |
| Reserved: false, |
| Type: VectorType(PrimitiveType(types.Uint32), &seven), |
| }, |
| }, |
| }, |
| Table{ |
| Name: "Test", |
| Size: 123, |
| Alignment: 456, |
| Members: []TableMember{ |
| { |
| Type: "[]uint32", |
| DataField: "Second", |
| PrivateDataField: "second", |
| PresenceField: "SecondPresent", |
| Setter: "SetSecond", |
| Getter: "GetSecond", |
| Haser: "HasSecond", |
| Clearer: "ClearSecond", |
| Tags: "`" + `fidl:"7,2" fidl2:"2,7"` + "`", |
| }, |
| }, |
| }) |
| |
| compileTableExpect( |
| t, |
| "MoreComplex", |
| types.Table{ |
| Name: types.EncodedCompoundIdentifier("Test"), |
| Size: 123, |
| Alignment: 456, |
| Members: []types.TableMember{ |
| { |
| Ordinal: 1, |
| Reserved: true, |
| }, |
| { |
| Ordinal: 2, |
| Name: "second", |
| Type: VectorType(ArrayType(VectorType(PrimitiveType(types.Uint32), &seven), 6), &five), |
| }, |
| { |
| Ordinal: 3, |
| Reserved: true, |
| }, |
| { |
| Ordinal: 4, |
| Name: "fourth", |
| Type: VectorType(Nullable(HandleType()), &five), |
| }, |
| }, |
| }, |
| Table{ |
| Name: "Test", |
| Size: 123, |
| Alignment: 456, |
| Members: []TableMember{ |
| { |
| Type: "[][6][]uint32", |
| DataField: "Second", |
| PrivateDataField: "second", |
| PresenceField: "SecondPresent", |
| Setter: "SetSecond", |
| Getter: "GetSecond", |
| Haser: "HasSecond", |
| Clearer: "ClearSecond", |
| Tags: "`" + `fidl:"7,5,2" fidl2:"2,5,7"` + "`", |
| }, |
| { |
| Type: "[]_zx.Handle", |
| DataField: "Fourth", |
| PrivateDataField: "fourth", |
| PresenceField: "FourthPresent", |
| Setter: "SetFourth", |
| Getter: "GetFourth", |
| Haser: "HasFourth", |
| Clearer: "ClearFourth", |
| Tags: "`" + `fidl:"*,5,4" fidl2:"4,5,1"` + "`", |
| }, |
| }, |
| }) |
| } |
