Skip to content

Commit 2db4eaf

Browse files
paultyngPaddy
paultyng
and
Paddy
authored
Support more types in NewValue (#46)
* Support more types in NewValue * Update tfprotov5/tftypes/value_test.go Co-authored-by: Paul Tyng <[email protected]> Co-authored-by: Paddy <[email protected]>
1 parent 1be51fa commit 2db4eaf

File tree

2 files changed

+300
-6
lines changed

2 files changed

+300
-6
lines changed

‎tfprotov5/tftypes/value.go‎

Lines changed: 150 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -58,15 +58,16 @@ type Value struct {
5858
//
5959
// The builtin Value representations are:
6060
//
61-
// * string for String
61+
// * String: string, *string
6262
//
63-
// * *big.Float for Number
63+
// * Number: *big.Float, int64, *int64, int32, *int32, int16, *int16, int8, *int8, int, *int,
64+
// uint64, *uint64, uint32, *uint32, uint16, *uint16, uint8, *uint8, byte, *byte, uint, *uint
6465
//
65-
// * bool for Bool
66+
// * Bool: bool, *bool
6667
//
67-
// * map[string]Value for Map and Object
68+
// * Map and Object: map[string]Value
6869
//
69-
// * []Value for Tuple, List, and Set
70+
// * Tuple, List, and Set: []Value
7071
func NewValue(t Type, val interface{}) Value {
7172
if val == nil || val == UnknownValue {
7273
return Value{
@@ -81,7 +82,150 @@ func NewValue(t Type, val interface{}) Value {
8182
panic("error creating tftypes.Value: " + err.Error())
8283
}
8384
}
84-
switch val.(type) {
85+
86+
switch val := val.(type) {
87+
case *string:
88+
if val == nil {
89+
return Value{
90+
typ: t,
91+
value: nil,
92+
}
93+
}
94+
return Value{
95+
typ: t,
96+
value: *val,
97+
}
98+
case *bool:
99+
if val == nil {
100+
return Value{
101+
typ: t,
102+
value: nil,
103+
}
104+
}
105+
return Value{
106+
typ: t,
107+
value: *val,
108+
}
109+
case *uint:
110+
if val == nil {
111+
return Value{
112+
typ: t,
113+
value: nil,
114+
}
115+
}
116+
f := new(big.Float).SetUint64(uint64(*val))
117+
return Value{
118+
typ: t,
119+
value: f,
120+
}
121+
case *uint64:
122+
if val == nil {
123+
return Value{
124+
typ: t,
125+
value: nil,
126+
}
127+
}
128+
f := new(big.Float).SetUint64(uint64(*val))
129+
return Value{
130+
typ: t,
131+
value: f,
132+
}
133+
case *uint8:
134+
if val == nil {
135+
return Value{
136+
typ: t,
137+
value: nil,
138+
}
139+
}
140+
f := new(big.Float).SetInt64(int64(*val))
141+
return Value{
142+
typ: t,
143+
value: f,
144+
}
145+
case *uint16:
146+
if val == nil {
147+
return Value{
148+
typ: t,
149+
value: nil,
150+
}
151+
}
152+
f := new(big.Float).SetInt64(int64(*val))
153+
return Value{
154+
typ: t,
155+
value: f,
156+
}
157+
case *uint32:
158+
if val == nil {
159+
return Value{
160+
typ: t,
161+
value: nil,
162+
}
163+
}
164+
f := new(big.Float).SetInt64(int64(*val))
165+
return Value{
166+
typ: t,
167+
value: f,
168+
}
169+
case *int:
170+
if val == nil {
171+
return Value{
172+
typ: t,
173+
value: nil,
174+
}
175+
}
176+
f := new(big.Float).SetInt64(int64(*val))
177+
return Value{
178+
typ: t,
179+
value: f,
180+
}
181+
case *int8:
182+
if val == nil {
183+
return Value{
184+
typ: t,
185+
value: nil,
186+
}
187+
}
188+
f := new(big.Float).SetInt64(int64(*val))
189+
return Value{
190+
typ: t,
191+
value: f,
192+
}
193+
case *int16:
194+
if val == nil {
195+
return Value{
196+
typ: t,
197+
value: nil,
198+
}
199+
}
200+
f := new(big.Float).SetInt64(int64(*val))
201+
return Value{
202+
typ: t,
203+
value: f,
204+
}
205+
case *int32:
206+
if val == nil {
207+
return Value{
208+
typ: t,
209+
value: nil,
210+
}
211+
}
212+
f := new(big.Float).SetInt64(int64(*val))
213+
return Value{
214+
typ: t,
215+
value: f,
216+
}
217+
case *int64:
218+
if val == nil {
219+
return Value{
220+
typ: t,
221+
value: nil,
222+
}
223+
}
224+
f := new(big.Float).SetInt64(*val)
225+
return Value{
226+
typ: t,
227+
value: f,
228+
}
85229
case string, *big.Float, bool, map[string]Value, []Value:
86230
return Value{
87231
typ: t,

‎tfprotov5/tftypes/value_test.go‎

Lines changed: 150 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -24,6 +24,36 @@ func TestValueAs(t *testing.T) {
2424
numberPointerPointer := func(in *big.Float) **big.Float {
2525
return &in
2626
}
27+
int64Pointer := func(in int64) *int64 {
28+
return &in
29+
}
30+
int32Pointer := func(in int32) *int32 {
31+
return &in
32+
}
33+
int16Pointer := func(in int16) *int16 {
34+
return &in
35+
}
36+
int8Pointer := func(in int8) *int8 {
37+
return &in
38+
}
39+
intPointer := func(in int) *int {
40+
return &in
41+
}
42+
uint64Pointer := func(in uint64) *uint64 {
43+
return &in
44+
}
45+
uint32Pointer := func(in uint32) *uint32 {
46+
return &in
47+
}
48+
uint16Pointer := func(in uint16) *uint16 {
49+
return &in
50+
}
51+
uint8Pointer := func(in uint8) *uint8 {
52+
return &in
53+
}
54+
uintPointer := func(in uint) *uint {
55+
return &in
56+
}
2757
boolPointer := func(in bool) *bool {
2858
return &in
2959
}
@@ -58,16 +88,126 @@ func TestValueAs(t *testing.T) {
5888
as: strPointerPointer(strPointer("")),
5989
expected: strPointerPointer(strPointer("hello")),
6090
},
91+
"string-pointer-in": {
92+
in: NewValue(String, strPointer("hello")),
93+
as: strPointerPointer(strPointer("")),
94+
expected: strPointerPointer(strPointer("hello")),
95+
},
6196
"string-pointer-null": {
6297
in: NewValue(String, nil),
6398
as: strPointerPointer(strPointer("this value should be removed")),
6499
expected: strPointerPointer(nil),
65100
},
101+
"string-pointer-string-null": {
102+
in: NewValue(String, (*string)(nil)),
103+
as: strPointerPointer(strPointer("this value should be removed")),
104+
expected: strPointerPointer(nil),
105+
},
66106
"number": {
67107
in: NewValue(Number, big.NewFloat(123)),
68108
as: big.NewFloat(0),
69109
expected: big.NewFloat(123),
70110
},
111+
"number-pointer-int64": {
112+
in: NewValue(Number, int64Pointer(123)),
113+
as: big.NewFloat(0),
114+
expected: big.NewFloat(123),
115+
},
116+
"number-pointer-int64-null": {
117+
in: NewValue(Number, (*int64)(nil)),
118+
as: numberPointerPointer(big.NewFloat(123)),
119+
expected: numberPointerPointer(nil),
120+
},
121+
"number-pointer-int32": {
122+
in: NewValue(Number, int32Pointer(123)),
123+
as: big.NewFloat(0),
124+
expected: big.NewFloat(123),
125+
},
126+
"number-pointer-int32-null": {
127+
in: NewValue(Number, (*int32)(nil)),
128+
as: numberPointerPointer(big.NewFloat(123)),
129+
expected: numberPointerPointer(nil),
130+
},
131+
"number-pointer-int16": {
132+
in: NewValue(Number, int16Pointer(123)),
133+
as: big.NewFloat(0),
134+
expected: big.NewFloat(123),
135+
},
136+
"number-pointer-int16-null": {
137+
in: NewValue(Number, (*int16)(nil)),
138+
as: numberPointerPointer(big.NewFloat(123)),
139+
expected: numberPointerPointer(nil),
140+
},
141+
"number-pointer-int8": {
142+
in: NewValue(Number, int8Pointer(123)),
143+
as: big.NewFloat(0),
144+
expected: big.NewFloat(123),
145+
},
146+
"number-pointer-int8-null": {
147+
in: NewValue(Number, (*int8)(nil)),
148+
as: numberPointerPointer(big.NewFloat(123)),
149+
expected: numberPointerPointer(nil),
150+
},
151+
"number-pointer-int": {
152+
in: NewValue(Number, intPointer(123)),
153+
as: big.NewFloat(0),
154+
expected: big.NewFloat(123),
155+
},
156+
"number-pointer-int-null": {
157+
in: NewValue(Number, (*int)(nil)),
158+
as: numberPointerPointer(big.NewFloat(123)),
159+
expected: numberPointerPointer(nil),
160+
},
161+
"number-pointer-uint64": {
162+
in: NewValue(Number, uint64Pointer(123)),
163+
as: big.NewFloat(0),
164+
expected: big.NewFloat(123),
165+
},
166+
"number-pointer-uint64-null": {
167+
in: NewValue(Number, (*uint64)(nil)),
168+
as: numberPointerPointer(big.NewFloat(123)),
169+
expected: numberPointerPointer(nil),
170+
},
171+
"number-pointer-uint32": {
172+
in: NewValue(Number, uint32Pointer(123)),
173+
as: big.NewFloat(0),
174+
expected: big.NewFloat(123),
175+
},
176+
"number-pointer-uint32-null": {
177+
in: NewValue(Number, (*uint32)(nil)),
178+
as: numberPointerPointer(big.NewFloat(123)),
179+
expected: numberPointerPointer(nil),
180+
},
181+
"number-pointer-uint16": {
182+
in: NewValue(Number, uint16Pointer(123)),
183+
as: big.NewFloat(0),
184+
expected: big.NewFloat(123),
185+
},
186+
"number-pointer-uint16-null": {
187+
in: NewValue(Number, (*uint16)(nil)),
188+
as: numberPointerPointer(big.NewFloat(123)),
189+
expected: numberPointerPointer(nil),
190+
},
191+
"number-pointer-uint8": {
192+
in: NewValue(Number, uint8Pointer(123)),
193+
as: big.NewFloat(0),
194+
expected: big.NewFloat(123),
195+
},
196+
"number-pointer-uint8-null": {
197+
in: NewValue(Number, (*uint8)(nil)),
198+
as: numberPointerPointer(big.NewFloat(123)),
199+
expected: numberPointerPointer(nil),
200+
},
201+
"number-pointer-uint": {
202+
in: NewValue(Number, uintPointer(123)),
203+
as: big.NewFloat(0),
204+
expected: big.NewFloat(123),
205+
},
206+
"number-pointer-uint-null": {
207+
in: NewValue(Number, (*uint)(nil)),
208+
as: numberPointerPointer(big.NewFloat(123)),
209+
expected: numberPointerPointer(nil),
210+
},
71211
"number-null": {
72212
in: NewValue(Number, nil),
73213
as: big.NewFloat(123),
@@ -98,11 +238,21 @@ func TestValueAs(t *testing.T) {
98238
as: boolPointerPointer(boolPointer(false)),
99239
expected: boolPointerPointer(boolPointer(true)),
100240
},
241+
"bool-pointer-in": {
242+
in: NewValue(Bool, boolPointer(true)),
243+
as: boolPointerPointer(boolPointer(false)),
244+
expected: boolPointerPointer(boolPointer(true)),
245+
},
101246
"bool-pointer-null": {
102247
in: NewValue(Bool, nil),
103248
as: boolPointerPointer(boolPointer(true)),
104249
expected: boolPointerPointer(nil),
105250
},
251+
"bool-pointer-bool-null": {
252+
in: NewValue(Bool, (*bool)(nil)),
253+
as: boolPointerPointer(boolPointer(true)),
254+
expected: boolPointerPointer(nil),
255+
},
106256
"map": {
107257
in: NewValue(Map{AttributeType: String}, map[string]Value{
108258
"hello": NewValue(String, "world"),

0 commit comments

Comments
 (0)