| // Copyright 2021 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 golang |
| |
| import ( |
| "fmt" |
| "strings" |
| |
| gidlir "go.fuchsia.dev/fuchsia/tools/fidl/gidl/ir" |
| gidlmixer "go.fuchsia.dev/fuchsia/tools/fidl/gidl/mixer" |
| "go.fuchsia.dev/fuchsia/tools/fidl/lib/fidlgen" |
| ) |
| |
| func BuildEqualityCheck(actualExpr string, expectedValue gidlir.Value, decl gidlmixer.Declaration, koidArrayVar string) string { |
| builder := equalityCheckBuilder{ |
| koidArrayVar: koidArrayVar, |
| } |
| builder.visit(actualExpr, expectedValue, decl) |
| return builder.String() |
| } |
| |
| // Generator of new variable names from a sequence. |
| type varSeq int |
| |
| func (v *varSeq) next() string { |
| *v++ |
| return fmt.Sprintf("f%d", *v) |
| } |
| |
| type equalityCheckBuilder struct { |
| strings.Builder |
| varSeq varSeq |
| koidArrayVar string |
| } |
| |
| func (b *equalityCheckBuilder) write(format string, vals ...interface{}) { |
| b.WriteString(fmt.Sprintf(format, vals...)) |
| } |
| |
| func (b *equalityCheckBuilder) createAndAssignVar(val string) string { |
| varName := b.varSeq.next() |
| b.write("%s := %s\n", varName, val) |
| b.write("ignore_unused_warning(%s)\n", varName) |
| return varName |
| } |
| |
| func (b *equalityCheckBuilder) assertEquals(actual, expected string) { |
| b.write( |
| `if %[1]s != %[2]s { |
| t.Fatalf("unexpectedly unequal: %%s and %%s", %[1]q, %[2]q) |
| } |
| `, actual, expected) |
| } |
| |
| func (b *equalityCheckBuilder) expectEquals(actual, expected string) { |
| b.write( |
| `if %[1]s != %[2]s { |
| t.Errorf("unexpectedly unequal: %%s and %%s", %[1]q, %[2]q) |
| } |
| `, actual, expected) |
| } |
| |
| func (b *equalityCheckBuilder) expectNotEquals(actual, expected string) { |
| b.write( |
| `if %[1]s == %[2]s { |
| t.Errorf("unexpectedly equal: %%s and %%s", %[1]q, %[2]q) |
| } |
| `, actual, expected) |
| } |
| |
| func (b *equalityCheckBuilder) expectFalse(value string) { |
| b.write( |
| `if %[1]s { |
| t.Errorf("expected false but was true: %%s", %[1]q) |
| } |
| `, value) |
| } |
| |
| func (b *equalityCheckBuilder) expectTrue(value string) { |
| b.write( |
| `if !(%[1]s) { |
| t.Errorf("expected true but was false: %%s", %[1]q) |
| } |
| `, value) |
| } |
| |
| func (b *equalityCheckBuilder) assertTrue(value string) { |
| b.write( |
| `if !(%[1]s) { |
| t.Fatalf("expected true but was false: %%s", %[1]q) |
| } |
| `, value) |
| } |
| |
| func (b *equalityCheckBuilder) expectNil(value string) { |
| b.write( |
| `if %[1]s != nil { |
| t.Errorf("expected nil but was non-nil: %%s", %[1]q) |
| } |
| `, value) |
| } |
| |
| func (b *equalityCheckBuilder) expectKoidEquals(actual string, expectedHandle gidlir.Handle) { |
| var handleVar = fmt.Sprintf("&%s.Handle", b.createAndAssignVar(actual)) |
| infoVar := b.varSeq.next() |
| b.write( |
| `if runtime.GOOS == "fuchsia" { |
| %s, err := handleGetBasicInfo(%s) |
| if err != nil { |
| t.Fatal(err) |
| } |
| `, infoVar, handleVar) |
| b.expectEquals(fmt.Sprintf("%s.Koid", infoVar), fmt.Sprintf("%s[%d]", b.koidArrayVar, expectedHandle)) |
| b.write("}\n") |
| } |
| |
| func (b *equalityCheckBuilder) visit(actualExpr string, expectedValue gidlir.Value, decl gidlmixer.Declaration) { |
| switch expectedValue := expectedValue.(type) { |
| case bool, int64, uint64, float64: |
| b.expectEquals(actualExpr, fmt.Sprintf("%v", expectedValue)) |
| return |
| case gidlir.RawFloat: |
| switch decl.(*gidlmixer.FloatDecl).Subtype() { |
| case fidlgen.Float32: |
| b.expectEquals(fmt.Sprintf("math.Float32bits(%s)", actualExpr), fmt.Sprintf("%d", expectedValue)) |
| return |
| case fidlgen.Float64: |
| b.expectEquals(fmt.Sprintf("math.Float64bits(%s)", actualExpr), fmt.Sprintf("%d", expectedValue)) |
| return |
| } |
| case string: |
| if decl.IsNullable() { |
| actualExpr = b.createAndAssignVar(fmt.Sprintf("*(%s)", actualExpr)) |
| } |
| b.expectEquals(actualExpr, fmt.Sprintf("%q", expectedValue)) |
| return |
| case gidlir.HandleWithRights: |
| b.visitHandle(actualExpr, expectedValue, decl.(*gidlmixer.HandleDecl)) |
| return |
| case gidlir.Record: |
| switch decl := decl.(type) { |
| case *gidlmixer.StructDecl: |
| b.visitStruct(actualExpr, expectedValue, decl) |
| return |
| case *gidlmixer.TableDecl: |
| b.visitTable(actualExpr, expectedValue, decl) |
| return |
| case *gidlmixer.UnionDecl: |
| b.visitUnion(actualExpr, expectedValue, decl) |
| return |
| } |
| case []gidlir.Value: |
| b.visitList(actualExpr, expectedValue, decl.(gidlmixer.ListDeclaration)) |
| return |
| case nil: |
| switch decl.(type) { |
| case *gidlmixer.HandleDecl: |
| b.expectEquals(actualExpr, "zx.HandleInvalid") |
| return |
| default: |
| b.expectNil(actualExpr) |
| return |
| } |
| } |
| panic(fmt.Sprintf("not implemented: %T (decl: %T)", expectedValue, decl)) |
| } |
| |
| func (b *equalityCheckBuilder) visitHandle(actualExpr string, expectedValue gidlir.HandleWithRights, decl *gidlmixer.HandleDecl) { |
| var handleVar string |
| if decl.Subtype() == fidlgen.Handle { |
| handleVar = fmt.Sprintf("&%s", b.createAndAssignVar(actualExpr)) |
| } else { |
| handleVar = fmt.Sprintf("%s.Handle()", actualExpr) |
| } |
| infoVar := b.varSeq.next() |
| b.write( |
| `if runtime.GOOS == "fuchsia" { |
| %s, err := handleGetBasicInfo(%s) |
| if err != nil { |
| t.Fatal(err) |
| } |
| `, infoVar, handleVar) |
| b.expectEquals(fmt.Sprintf("%s.Koid", infoVar), fmt.Sprintf("%s[%d]", b.koidArrayVar, expectedValue.Handle)) |
| b.expectTrue(fmt.Sprintf("%[1]s.Type == %[2]d || %[2]d == zx.ObjectTypeNone", infoVar, expectedValue.Type)) |
| b.expectTrue(fmt.Sprintf("%[1]s.Rights == %[2]d || %[2]d == zx.RightSameRights", infoVar, expectedValue.Rights)) |
| b.write("}\n") |
| } |
| |
| func (b *equalityCheckBuilder) visitStruct(actualExpr string, expectedValue gidlir.Record, decl *gidlmixer.StructDecl) { |
| if decl.IsNullable() { |
| actualExpr = b.createAndAssignVar(fmt.Sprintf("*(%s)", actualExpr)) |
| } |
| actualVar := b.createAndAssignVar(actualExpr) |
| for _, field := range expectedValue.Fields { |
| fieldDecl, ok := decl.Field(field.Key.Name) |
| if !ok { |
| panic(fmt.Sprintf("field %q not found", field.Key.Name)) |
| } |
| actualFieldExpr := fmt.Sprintf("%s.%s", actualVar, fidlgen.ToUpperCamelCase(field.Key.Name)) |
| b.visit(actualFieldExpr, field.Value, fieldDecl) |
| } |
| } |
| |
| func (b *equalityCheckBuilder) visitTable(actualExpr string, expectedValue gidlir.Record, decl *gidlmixer.TableDecl) { |
| actualVar := b.createAndAssignVar(actualExpr) |
| expectedFieldValues := map[string]gidlir.Value{} |
| for _, field := range expectedValue.Fields { |
| if field.Key.IsKnown() { |
| expectedFieldValues[field.Key.Name] = field.Value |
| continue |
| } |
| ud := field.Value.(gidlir.UnknownData) |
| b.write( |
| `if _, ok := %[1]s.GetUnknownData()[%[2]d]; !ok { |
| t.Fatalf("expected unknown data for %[1]s at ordinal: %[2]d") |
| } |
| `, actualVar, field.Key.UnknownOrdinal) |
| b.assertEquals(fmt.Sprintf("len(%s.GetUnknownData()[%d].Bytes)", actualVar, field.Key.UnknownOrdinal), fmt.Sprintf("%d", len(ud.Bytes))) |
| for i, byt := range ud.Bytes { |
| b.expectEquals(fmt.Sprintf("%s.GetUnknownData()[%d].Bytes[%d]", actualVar, field.Key.UnknownOrdinal, i), fmt.Sprintf("%d", byt)) |
| } |
| b.assertEquals(fmt.Sprintf("len(%s.GetUnknownData()[%d].Handles)", actualVar, field.Key.UnknownOrdinal), fmt.Sprintf("%d", len(ud.Handles))) |
| for i, h := range ud.Handles { |
| b.expectKoidEquals(fmt.Sprintf("%s.GetUnknownData()[%d].Handles[%d]", actualVar, field.Key.UnknownOrdinal, i), h) |
| } |
| } |
| |
| for _, fieldName := range decl.FieldNames() { |
| fieldDecl, ok := decl.Field(fieldName) |
| if !ok { |
| panic(fmt.Sprintf("field decl %s not found", fieldName)) |
| } |
| goFieldName := fidlgen.ToUpperCamelCase(fieldName) |
| if expectedFieldValue, ok := expectedFieldValues[fieldName]; ok { |
| b.assertTrue(fmt.Sprintf("%s.Has%s()", actualVar, goFieldName)) |
| fieldVar := b.createAndAssignVar(fmt.Sprintf("%s.Get%s()", actualVar, goFieldName)) |
| b.visit(fieldVar, expectedFieldValue, fieldDecl) |
| } else { |
| b.expectFalse(fmt.Sprintf("%s.Has%s()", actualVar, goFieldName)) |
| } |
| } |
| } |
| |
| func (b *equalityCheckBuilder) visitUnion(actualExpr string, expectedValue gidlir.Record, decl *gidlmixer.UnionDecl) { |
| if len(expectedValue.Fields) != 1 { |
| panic("unions have exactly one assigned field") |
| } |
| actualVar := b.createAndAssignVar(actualExpr) |
| field := expectedValue.Fields[0] |
| if field.Key.IsUnknown() { |
| ud := field.Value.(gidlir.UnknownData) |
| b.assertEquals(fmt.Sprintf("len(%s.GetUnknownData().Bytes)", actualVar), fmt.Sprintf("%d", len(ud.Bytes))) |
| for i, byt := range ud.Bytes { |
| b.expectEquals(fmt.Sprintf("%s.GetUnknownData().Bytes[%d]", actualVar, i), fmt.Sprintf("%d", byt)) |
| } |
| b.assertEquals(fmt.Sprintf("len(%s.GetUnknownData().Handles)", actualVar), fmt.Sprintf("%d", len(ud.Handles))) |
| for i, h := range ud.Handles { |
| b.expectKoidEquals(fmt.Sprintf("%s.GetUnknownData().Handles[%d]", actualVar, i), h) |
| } |
| return |
| } |
| |
| fieldDecl, ok := decl.Field(field.Key.Name) |
| if !ok { |
| panic(fmt.Sprintf("field %q not found", field.Key.Name)) |
| } |
| |
| fieldName := fidlgen.ToUpperCamelCase(field.Key.Name) |
| b.assertEquals(fmt.Sprintf("%s.Which()", actualVar), |
| fmt.Sprintf("%s%s", declName(decl), fieldName)) |
| fieldVar := b.createAndAssignVar(fmt.Sprintf("%s.%s", actualVar, fieldName)) |
| b.visit(fieldVar, field.Value, fieldDecl) |
| } |
| |
| func (b *equalityCheckBuilder) visitList(actualExpr string, expectedValue []gidlir.Value, decl gidlmixer.ListDeclaration) { |
| if decl.IsNullable() { |
| actualExpr = fmt.Sprintf("*(%s)", actualExpr) |
| } |
| actualVar := b.createAndAssignVar(actualExpr) |
| if _, ok := decl.(*gidlmixer.VectorDecl); ok { |
| b.assertEquals(fmt.Sprintf("len(%s)", actualVar), fmt.Sprintf("%d", len(expectedValue))) |
| } |
| for i, item := range expectedValue { |
| b.visit(fmt.Sprintf("%s[%d]", actualVar, i), item, decl.Elem()) |
| } |
| } |
