github.com/lineaje-labs/syft@v0.98.1-0.20231227153149-9e393f60ff1b/syft/format/common/property_encoder_test.go (about)

     1  package common
     2  
     3  import (
     4  	"reflect"
     5  	"testing"
     6  
     7  	"github.com/stretchr/testify/assert"
     8  )
     9  
    10  type T1 struct {
    11  	Name     string
    12  	Val      int
    13  	ValU     uint
    14  	Flag     bool `json:"bool_flag"`
    15  	Float    float64
    16  	T2       T2
    17  	T2Ptr    *T2
    18  	T2Arr    []T2
    19  	T2PtrArr []*T2
    20  	StrArr   []string
    21  	IntArr   []int
    22  	FloatArr []float64
    23  	BoolArr  []bool
    24  	T3Arr    []T3
    25  }
    26  
    27  type T2 struct {
    28  	Name string
    29  }
    30  
    31  type T3 struct {
    32  	T4Arr []T4
    33  }
    34  
    35  type T4 struct {
    36  	Typ    string
    37  	IntPtr *int
    38  }
    39  
    40  type T5 struct {
    41  	Map map[string]string
    42  }
    43  
    44  func Test_EncodeDecodeCycle(t *testing.T) {
    45  	val := 99
    46  
    47  	tests := []struct {
    48  		name  string
    49  		value interface{}
    50  	}{
    51  		{
    52  			name: "all values",
    53  			value: T1{
    54  				Name:  "name",
    55  				Val:   10,
    56  				ValU:  16,
    57  				Flag:  true,
    58  				Float: 1.2,
    59  				T2: T2{
    60  					Name: "embedded t2",
    61  				},
    62  				T2Ptr: &T2{
    63  					"t2 ptr",
    64  				},
    65  				T2Arr: []T2{
    66  					{"t2 elem 0"},
    67  					{"t2 elem 1"},
    68  				},
    69  				T2PtrArr: []*T2{
    70  					{"t2 ptr v1"},
    71  					{"t2 ptr v2"},
    72  				},
    73  				StrArr:   []string{"s 1", "s 2", "s 3"},
    74  				IntArr:   []int{9, 12, -1},
    75  				FloatArr: []float64{-23.99, 15.234321, 39912342314},
    76  				BoolArr:  []bool{false, true, true, true, false},
    77  				T3Arr: []T3{
    78  					{
    79  						T4Arr: []T4{
    80  							{
    81  								Typ: "t4 nested typ 1",
    82  							},
    83  							{
    84  								Typ:    "t4 nested typ 2",
    85  								IntPtr: &val,
    86  							},
    87  						},
    88  					},
    89  				},
    90  			},
    91  		},
    92  		{
    93  			name: "nil values",
    94  			value: T1{
    95  				Name:     "t1 test",
    96  				Val:      0,
    97  				ValU:     0,
    98  				Flag:     false,
    99  				Float:    0,
   100  				T2:       T2{},
   101  				T2Ptr:    nil,
   102  				T2Arr:    nil,
   103  				T2PtrArr: nil,
   104  				StrArr:   nil,
   105  				IntArr:   nil,
   106  				FloatArr: nil,
   107  				BoolArr:  nil,
   108  				T3Arr:    nil,
   109  			},
   110  		},
   111  		{
   112  			name: "array values",
   113  			value: []T2{
   114  				{"t2 elem 0"},
   115  				{"t2 elem 1"},
   116  			},
   117  		},
   118  		{
   119  			name: "array ptr",
   120  			value: &[]T2{
   121  				{"t2 elem 0"},
   122  				{"t2 elem 1"},
   123  			},
   124  		},
   125  		{
   126  			name: "map of strings",
   127  			value: &T5{
   128  				Map: map[string]string{
   129  					"key1": "value1",
   130  					"key2": "value2",
   131  				},
   132  			},
   133  		},
   134  	}
   135  
   136  	for _, test := range tests {
   137  		t.Run(test.name, func(t *testing.T) {
   138  			vals := Encode(test.value, "props", OptionalJSONTag)
   139  
   140  			typ := reflect.TypeOf(test.value)
   141  
   142  			if typ.Kind() != reflect.Slice && typ.Kind() != reflect.Ptr {
   143  				assert.NotEmpty(t, vals["props:bool_flag"])
   144  
   145  				t2 := T1{}
   146  				DecodeInto(&t2, vals, "props", OptionalJSONTag)
   147  
   148  				assert.EqualValues(t, test.value, t2)
   149  			}
   150  
   151  			t3 := Decode(typ, vals, "props", OptionalJSONTag)
   152  
   153  			assert.EqualValues(t, test.value, t3)
   154  		})
   155  	}
   156  }