X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=binapigen%2Fgenerator_test.go;h=8c2046d98602fd115633dcd89b4f8e3e52308cd9;hb=67cea0df30f7ef348e265c9326f7a9f15ba26240;hp=ddbda999061c6c6dcffd808496ee70d9fbaf9764;hpb=94620e85f0bdbb054af07ce3670fadc1f76cfdf0;p=govpp.git

diff --git a/binapigen/generator_test.go b/binapigen/generator_test.go
index ddbda99..8c2046d 100644
--- 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
+}