cmd/binapi-generator/parse_test.go

   1 package main
   2
   3 import (
   4         "testing"
   5 )
   6
   7 func TestBinapiTypeSizes(t *testing.T) {
   8         tests := []struct {
   9                 name    string
  10                 input   string
  11                 expsize int
  12         }{
  13                 {name: "basic1", input: "u8", expsize: 1},
  14                 {name: "basic2", input: "i8", expsize: 1},
  15                 {name: "basic3", input: "u16", expsize: 2},
  16                 {name: "basic4", input: "i32", expsize: 4},
  17                 {name: "invalid1", input: "x", expsize: -1},
  18         }
  19         for _, test := range tests {
  20                 t.Run(test.name, func(t *testing.T) {
  21                         size := getBinapiTypeSize(test.input)
  22                         if size != test.expsize {
  23                                 t.Errorf("expected %d, got %d", test.expsize, size)
  24                         }
  25                 })
  26         }
  27 }
  28
  29 func TestSizeOfType(t *testing.T) {
  30         tests := []struct {
  31                 name    string
  32                 input   Type
  33                 expsize int
  34         }{
  35                 {
  36                         name: "basic1",
  37                         input: Type{
  38                                 Fields: []Field{
  39                                         {Type: "u8"},
  40                                 },
  41                         },
  42                         expsize: 1,
  43                 },
  44                 {
  45                         name: "basic2",
  46                         input: Type{
  47                                 Fields: []Field{
  48                                         {Type: "u8", Length: 4},
  49                                 },
  50                         },
  51                         expsize: 4,
  52                 },
  53                 {
  54                         name: "basic3",
  55                         input: Type{
  56                                 Fields: []Field{
  57                                         {Type: "u8", Length: 16},
  58                                 },
  59                         },
  60                         expsize: 16,
  61                 },
  62                 {
  63                         name: "withEnum",
  64                         input: Type{
  65                                 Fields: []Field{
  66                                         {Type: "u16"},
  67                                         {Type: "vl_api_myenum_t"},
  68                                 },
  69                         },
  70                         expsize: 6,
  71                 },
  72                 {
  73                         name: "invalid1",
  74                         input: Type{
  75                                 Fields: []Field{
  76                                         {Type: "x", Length: 16},
  77                                 },
  78                         },
  79                         expsize: 0,
  80                 },
  81         }
  82         for _, test := range tests {
  83                 t.Run(test.name, func(t *testing.T) {
  84                         ctx := &context{
  85                                 packageData: &Package{
  86                                         Enums: []Enum{
  87                                                 {Name: "myenum", Type: "u32"},
  88                                         },
  89                                 },
  90                         }
  91                         size := getSizeOfType(ctx, &test.input)
  92                         if size != test.expsize {
  93                                 t.Errorf("expected %d, got %d", test.expsize, size)
  94                         }
  95                 })
  96         }
  97 }