package to // Copyright 2017 Microsoft Corporation // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. import ( "reflect" "testing" ) func TestString(t *testing.T) { v := "" if String(&v) != v { t.Fatalf("to: String failed to return the correct string -- expected %v, received %v", v, String(&v)) } } func TestStringHandlesNil(t *testing.T) { if String(nil) != "" { t.Fatalf("to: String failed to correctly convert nil -- expected %v, received %v", "", String(nil)) } } func TestStringPtr(t *testing.T) { v := "" if *StringPtr(v) != v { t.Fatalf("to: StringPtr failed to return the correct string -- expected %v, received %v", v, *StringPtr(v)) } } func TestStringSlice(t *testing.T) { v := []string{} if out := StringSlice(&v); !reflect.DeepEqual(out, v) { t.Fatalf("to: StringSlice failed to return the correct slice -- expected %v, received %v", v, out) } } func TestStringSliceHandlesNil(t *testing.T) { if out := StringSlice(nil); out != nil { t.Fatalf("to: StringSlice failed to correctly convert nil -- expected %v, received %v", nil, out) } } func TestStringSlicePtr(t *testing.T) { v := []string{"a", "b"} if out := StringSlicePtr(v); !reflect.DeepEqual(*out, v) { t.Fatalf("to: StringSlicePtr failed to return the correct slice -- expected %v, received %v", v, *out) } } func TestStringMap(t *testing.T) { msp := map[string]*string{"foo": StringPtr("foo"), "bar": StringPtr("bar"), "baz": StringPtr("baz")} for k, v := range StringMap(msp) { if *msp[k] != v { t.Fatalf("to: StringMap incorrectly converted an entry -- expected [%s]%v, received[%s]%v", k, v, k, *msp[k]) } } } func TestStringMapHandlesNil(t *testing.T) { msp := map[string]*string{"foo": StringPtr("foo"), "bar": nil, "baz": StringPtr("baz")} for k, v := range StringMap(msp) { if msp[k] == nil && v != "" { t.Fatalf("to: StringMap incorrectly converted a nil entry -- expected [%s]%v, received[%s]%v", k, v, k, *msp[k]) } } } func TestStringMapPtr(t *testing.T) { ms := map[string]string{"foo": "foo", "bar": "bar", "baz": "baz"} for k, msp := range *StringMapPtr(ms) { if ms[k] != *msp { t.Fatalf("to: StringMapPtr incorrectly converted an entry -- expected [%s]%v, received[%s]%v", k, ms[k], k, *msp) } } } func TestBool(t *testing.T) { v := false if Bool(&v) != v { t.Fatalf("to: Bool failed to return the correct string -- expected %v, received %v", v, Bool(&v)) } } func TestBoolHandlesNil(t *testing.T) { if Bool(nil) != false { t.Fatalf("to: Bool failed to correctly convert nil -- expected %v, received %v", false, Bool(nil)) } } func TestBoolPtr(t *testing.T) { v := false if *BoolPtr(v) != v { t.Fatalf("to: BoolPtr failed to return the correct string -- expected %v, received %v", v, *BoolPtr(v)) } } func TestInt(t *testing.T) { v := 0 if Int(&v) != v { t.Fatalf("to: Int failed to return the correct string -- expected %v, received %v", v, Int(&v)) } } func TestIntHandlesNil(t *testing.T) { if Int(nil) != 0 { t.Fatalf("to: Int failed to correctly convert nil -- expected %v, received %v", 0, Int(nil)) } } func TestIntPtr(t *testing.T) { v := 0 if *IntPtr(v) != v { t.Fatalf("to: IntPtr failed to return the correct string -- expected %v, received %v", v, *IntPtr(v)) } } func TestInt32(t *testing.T) { v := int32(0) if Int32(&v) != v { t.Fatalf("to: Int32 failed to return the correct string -- expected %v, received %v", v, Int32(&v)) } } func TestInt32HandlesNil(t *testing.T) { if Int32(nil) != int32(0) { t.Fatalf("to: Int32 failed to correctly convert nil -- expected %v, received %v", 0, Int32(nil)) } } func TestInt32Ptr(t *testing.T) { v := int32(0) if *Int32Ptr(v) != v { t.Fatalf("to: Int32Ptr failed to return the correct string -- expected %v, received %v", v, *Int32Ptr(v)) } } func TestInt64(t *testing.T) { v := int64(0) if Int64(&v) != v { t.Fatalf("to: Int64 failed to return the correct string -- expected %v, received %v", v, Int64(&v)) } } func TestInt64HandlesNil(t *testing.T) { if Int64(nil) != int64(0) { t.Fatalf("to: Int64 failed to correctly convert nil -- expected %v, received %v", 0, Int64(nil)) } } func TestInt64Ptr(t *testing.T) { v := int64(0) if *Int64Ptr(v) != v { t.Fatalf("to: Int64Ptr failed to return the correct string -- expected %v, received %v", v, *Int64Ptr(v)) } } func TestFloat32(t *testing.T) { v := float32(0) if Float32(&v) != v { t.Fatalf("to: Float32 failed to return the correct string -- expected %v, received %v", v, Float32(&v)) } } func TestFloat32HandlesNil(t *testing.T) { if Float32(nil) != float32(0) { t.Fatalf("to: Float32 failed to correctly convert nil -- expected %v, received %v", 0, Float32(nil)) } } func TestFloat32Ptr(t *testing.T) { v := float32(0) if *Float32Ptr(v) != v { t.Fatalf("to: Float32Ptr failed to return the correct string -- expected %v, received %v", v, *Float32Ptr(v)) } } func TestFloat64(t *testing.T) { v := float64(0) if Float64(&v) != v { t.Fatalf("to: Float64 failed to return the correct string -- expected %v, received %v", v, Float64(&v)) } } func TestFloat64HandlesNil(t *testing.T) { if Float64(nil) != float64(0) { t.Fatalf("to: Float64 failed to correctly convert nil -- expected %v, received %v", 0, Float64(nil)) } } func TestFloat64Ptr(t *testing.T) { v := float64(0) if *Float64Ptr(v) != v { t.Fatalf("to: Float64Ptr failed to return the correct string -- expected %v, received %v", v, *Float64Ptr(v)) } } func TestByteSlicePtr(t *testing.T) { v := []byte("bytes") if out := ByteSlicePtr(v); !reflect.DeepEqual(*out, v) { t.Fatalf("to: ByteSlicePtr failed to return the correct slice -- expected %v, received %v", v, *out) } }