binapigen/generator_test.go

   1 //  Copyright (c) 2020 Cisco and/or its affiliates.
   2 //
   3 //  Licensed under the Apache License, Version 2.0 (the "License");
   4 //  you may not use this file except in compliance with the License.
   5 //  You may obtain a copy of the License at:
   6 //
   7 //      http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 //  Unless required by applicable law or agreed to in writing, software
  10 //  distributed under the License is distributed on an "AS IS" BASIS,
  11 //  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 //  See the License for the specific language governing permissions and
  13 //  limitations under the License.
  14
  15 package binapigen
  16
  17 import (
  18         "testing"
  19 )
  20
  21 func TestModule(t *testing.T) {
  22         const expected = "git.fd.io/govpp.git/examples/binapi"
  23
  24         impPath := resolveImportPath("../examples/binapi")
  25         if impPath != expected {
  26                 t.Fatalf("expected: %q, got: %q", expected, impPath)
  27         }
  28 }
  29
  30 func TestBinapiTypeSizes(t *testing.T) {
  31         tests := []struct {
  32                 name    string
  33                 input   string
  34                 expsize int
  35         }{
  36                 {name: "basic1", input: "u8", expsize: 1},
  37                 {name: "basic2", input: "i8", expsize: 1},
  38                 {name: "basic3", input: "u16", expsize: 2},
  39                 {name: "basic4", input: "i32", expsize: 4},
  40                 {name: "string", input: "string", expsize: 1},
  41                 {name: "invalid1", input: "x", expsize: 0},
  42         }
  43         for _, test := range tests {
  44                 t.Run(test.name, func(t *testing.T) {
  45                         size := getBinapiTypeSize(test.input)
  46                         if size != test.expsize {
  47                                 t.Errorf("expected %d, got %d", test.expsize, size)
  48                         }
  49                 })
  50         }
  51 }
  52
  53 /*func TestSizeOfType(t *testing.T) {
  54         tests := []struct {
  55                 name    string
  56                 input   StructType
  57                 expsize int
  58         }{
  59                 {
  60                         name: "basic1",
  61                         input: StructType{
  62                                 Fields: []Field{
  63                                         {Type: "u8"},
  64                                 },
  65                         },
  66                         expsize: 1,
  67                 },
  68                 {
  69                         name: "basic2",
  70                         input: Type{
  71                                 Fields: []Field{
  72                                         {Type: "u8", Length: 4},
  73                                 },
  74                         },
  75                         expsize: 4,
  76                 },
  77                 {
  78                         name: "basic3",
  79                         input: Type{
  80                                 Fields: []Field{
  81                                         {Type: "u8", Length: 16},
  82                                 },
  83                         },
  84                         expsize: 16,
  85                 },
  86                 {
  87                         name: "withEnum",
  88                         input: Type{
  89                                 Fields: []Field{
  90                                         {Type: "u16"},
  91                                         {Type: "vl_api_myenum_t"},
  92                                 },
  93                         },
  94                         expsize: 6,
  95                 },
  96                 {
  97                         name: "invalid1",
  98                         input: Type{
  99                                 Fields: []Field{
 100                                         {Type: "x", Length: 16},
 101                                 },
 102                         },
 103                         expsize: 0,
 104                 },
 105         }
 106         for _, test := range tests {
 107                 t.Run(test.name, func(t *testing.T) {
 108                         module := &File{
 109                                 Enums: []Enum{
 110                                         {Name: "myenum", Type: "u32"},
 111                                 },
 112                         }
 113                         size := getSizeOfType(module, &test.input)
 114                         if size != test.expsize {
 115                                 t.Errorf("expected %d, got %d", test.expsize, size)
 116                         }
 117                 })
 118         }
 119 }*/