Change module name to go.fd.io/govpp

[govpp.git] / binapigen / generator_test.go

diff --git a/binapigen/generator_test.go b/binapigen/generator_test.go
index ddbda99..8c2046d 100644 (file)
--- a/binapigen/generator_test.go
+++ b/binapigen/generator_test.go
@@ -15,9 +15,27 @@
 package binapigen
 
 import (
+       "bufio"
+       "fmt"
+       "go.fd.io/govpp/binapigen/vppapi"
+       . "github.com/onsi/gomega"
+       "os"
+       "strings"
        "testing"
 )
 
+func TestGoModule(t *testing.T) {
+       const expected = "go.fd.io/govpp/binapi"
+
+       impPath, err := resolveImportPath("../binapi")
+       if err != nil {
+               t.Fatalf("unexpected error: %v", err)
+       }
+       if impPath != expected {
+               t.Fatalf("expected: %q, got: %q", expected, impPath)
+       }
+}
+
 func TestBinapiTypeSizes(t *testing.T) {
        tests := []struct {
                name    string
@@ -33,7 +51,7 @@ func TestBinapiTypeSizes(t *testing.T) {
        }
        for _, test := range tests {
                t.Run(test.name, func(t *testing.T) {
-                       size := getBinapiTypeSize(test.input)
+                       size := getSizeOfBinapiBaseType(test.input, 1)
                        if size != test.expsize {
                                t.Errorf("expected %d, got %d", test.expsize, size)
                        }
@@ -41,70 +59,86 @@ func TestBinapiTypeSizes(t *testing.T) {
        }
 }
 
-/*func TestSizeOfType(t *testing.T) {
-       tests := []struct {
-               name    string
-               input   StructType
-               expsize int
-       }{
-               {
-                       name: "basic1",
-                       input: StructType{
-                               Fields: []Field{
-                                       {Type: "u8"},
-                               },
-                       },
-                       expsize: 1,
-               },
-               {
-                       name: "basic2",
-                       input: Type{
-                               Fields: []Field{
-                                       {Type: "u8", Length: 4},
-                               },
-                       },
-                       expsize: 4,
-               },
-               {
-                       name: "basic3",
-                       input: Type{
-                               Fields: []Field{
-                                       {Type: "u8", Length: 16},
-                               },
-                       },
-                       expsize: 16,
-               },
-               {
-                       name: "withEnum",
-                       input: Type{
-                               Fields: []Field{
-                                       {Type: "u16"},
-                                       {Type: "vl_api_myenum_t"},
-                               },
-                       },
-                       expsize: 6,
-               },
-               {
-                       name: "invalid1",
-                       input: Type{
-                               Fields: []Field{
-                                       {Type: "x", Length: 16},
-                               },
-                       },
-                       expsize: 0,
-               },
+func TestBinapiUnionSizes(t *testing.T) {
+       RegisterTestingT(t)
+
+       // order of the union sizes in file generated from union.api.json
+       var sizes = []int{16, 4, 32, 16, 64, 111}
+
+       // remove directory created during test
+       defer func() {
+               err := os.RemoveAll(testOutputDir)
+               Expect(err).ToNot(HaveOccurred())
+       }()
+
+       err := GenerateFromFile("vppapi/testdata/union.api.json", Options{OutputDir: testOutputDir})
+       Expect(err).ShouldNot(HaveOccurred())
+
+       file, err := os.Open(testOutputDir + "/union/union.ba.go")
+       Expect(err).ShouldNot(HaveOccurred())
+       defer func() {
+               err := file.Close()
+               Expect(err).ToNot(HaveOccurred())
+       }()
+
+       // the generated line with union size is in format XXX_UnionData [<size>]byte
+       // the prefix identifies these lines (the starting tab is important)
+       prefix := fmt.Sprintf("\t%s", "XXX_UnionData [")
+
+       index := 0
+       scanner := bufio.NewScanner(file)
+       for scanner.Scan() {
+               if strings.HasPrefix(scanner.Text(), prefix) {
+                       Expect(scanner.Text()).To(Equal(prefix + fmt.Sprintf("%d]byte", sizes[index])))
+                       index++
+               }
        }
-       for _, test := range tests {
-               t.Run(test.name, func(t *testing.T) {
-                       module := &File{
-                               Enums: []Enum{
-                                       {Name: "myenum", Type: "u32"},
-                               },
-                       }
-                       size := getSizeOfType(module, &test.input)
-                       if size != test.expsize {
-                               t.Errorf("expected %d, got %d", test.expsize, size)
-                       }
+       // ensure all union sizes were found and tested
+       Expect(index).To(Equal(len(sizes)))
+}
+
+// Typed data used for union size evaluation testing.
+type typeTestData struct {
+       typ    string
+       value  string
+       fields []*typeTestData
+}
+
+func (t typeTestData) getUnion(name string) *Union {
+       return &Union{
+               UnionType: vppapi.UnionType{Name: name},
+               Fields:    t.getUnionFields(name),
+       }
+}
+
+func (t typeTestData) getUnionFields(parentName string) (fields []*Field) {
+       for i, field := range t.fields {
+               var (
+                       dataType   string
+                       aliasType  *Alias
+                       enumType   *Enum
+                       structType *Struct
+                       unionType  *Union
+               )
+               switch field.typ {
+               case "alias":
+                       aliasType = &Alias{AliasType: vppapi.AliasType{Name: fmt.Sprintf("%s_alias_%d", parentName, i), Type: field.value}}
+               case "enum":
+                       enumType = &Enum{EnumType: vppapi.EnumType{Name: fmt.Sprintf("%s_enum_%d", parentName, i), Type: field.value}}
+               case "struct":
+                       structType = &Struct{Fields: field.getUnionFields(fmt.Sprintf("%s_struct_%d", parentName, i))}
+               case "union":
+                       unionType = field.getUnion(parentName)
+               default:
+                       dataType = field.value
+               }
+               fields = append(fields, &Field{
+                       Field:      vppapi.Field{Name: fmt.Sprintf("%s_field_%d", parentName, i), Type: dataType},
+                       TypeAlias:  aliasType,
+                       TypeEnum:   enumType,
+                       TypeStruct: structType,
+                       TypeUnion:  unionType,
                })
        }
-}*/
+       return fields
+}