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 TestBinapiTypeSizes(t *testing.T) {
  22         tests := []struct {
  23                 name    string
  24                 input   string
  25                 expsize int
  26         }{
  27                 {name: "basic1", input: "u8", expsize: 1},
  28                 {name: "basic2", input: "i8", expsize: 1},
  29                 {name: "basic3", input: "u16", expsize: 2},
  30                 {name: "basic4", input: "i32", expsize: 4},
  31                 {name: "string", input: "string", expsize: 1},
  32                 {name: "invalid1", input: "x", expsize: 0},
  33         }
  34         for _, test := range tests {
  35                 t.Run(test.name, func(t *testing.T) {
  36                         size := getBinapiTypeSize(test.input)
  37                         if size != test.expsize {
  38                                 t.Errorf("expected %d, got %d", test.expsize, size)
  39                         }
  40                 })
  41         }
  42 }
  43
  44 /*func TestSizeOfType(t *testing.T) {
  45         tests := []struct {
  46                 name    string
  47                 input   StructType
  48                 expsize int
  49         }{
  50                 {
  51                         name: "basic1",
  52                         input: StructType{
  53                                 Fields: []Field{
  54                                         {Type: "u8"},
  55                                 },
  56                         },
  57                         expsize: 1,
  58                 },
  59                 {
  60                         name: "basic2",
  61                         input: Type{
  62                                 Fields: []Field{
  63                                         {Type: "u8", Length: 4},
  64                                 },
  65                         },
  66                         expsize: 4,
  67                 },
  68                 {
  69                         name: "basic3",
  70                         input: Type{
  71                                 Fields: []Field{
  72                                         {Type: "u8", Length: 16},
  73                                 },
  74                         },
  75                         expsize: 16,
  76                 },
  77                 {
  78                         name: "withEnum",
  79                         input: Type{
  80                                 Fields: []Field{
  81                                         {Type: "u16"},
  82                                         {Type: "vl_api_myenum_t"},
  83                                 },
  84                         },
  85                         expsize: 6,
  86                 },
  87                 {
  88                         name: "invalid1",
  89                         input: Type{
  90                                 Fields: []Field{
  91                                         {Type: "x", Length: 16},
  92                                 },
  93                         },
  94                         expsize: 0,
  95                 },
  96         }
  97         for _, test := range tests {
  98                 t.Run(test.name, func(t *testing.T) {
  99                         module := &File{
 100                                 Enums: []Enum{
 101                                         {Name: "myenum", Type: "u32"},
 102                                 },
 103                         }
 104                         size := getSizeOfType(module, &test.input)
 105                         if size != test.expsize {
 106                                 t.Errorf("expected %d, got %d", test.expsize, size)
 107                         }
 108                 })
 109         }
 110 }*/