converter/string_test.go at main · tech4works/converter · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
package converter

import (
	"testing"
)

var testData = []struct {
	name        string
	input       any
	expect      string
	expectError bool
}{
	{name: "String", input: "test", expect: "test", expectError: false},
	{name: "Integer", input: 64, expect: "64", expectError: false},
	{name: "Unsigned integer", input: uint(64), expect: "64", expectError: false},
	{name: "Float", input: 64.64, expect: "64.64", expectError: false},
	{name: "Complex number", input: complex(64, 64), expect: "(64+64i)", expectError: false},
	{name: "Boolean", input: true, expect: "true", expectError: false},
	{name: "Byte Slice", input: []byte("test"), expect: "test", expectError: false},
	{name: "Map", input: map[string]interface{}{"key": "value"}, expect: `{"key":"value"}`, expectError: false},
	{name: "Nil pointer", input: (*ConvertTest)(nil), expect: "", expectError: true},
}

type ConvertTest struct {
	Value string
}

func TestCouldBeString(t *testing.T) {
	for _, data := range testData {
		t.Run(data.name, func(t *testing.T) {
			ret := CouldBeString(data.input)
			if ret && data.expectError {
				t.Error("expected failure but conversion was successful")
			} else if !ret && !data.expectError {
				t.Error("expected success but conversion failed")
			}
		})
	}
}

func TestToString(t *testing.T) {
	for _, data := range testData {
		t.Run(data.name, func(t *testing.T) {
			defer func() {
				if r := recover(); r != nil && !data.expectError {
					t.Errorf("unexpected panic: %v", r)
				}
			}()

			ret := ToString(data.input)
			if ret != data.expect {
				t.Errorf("expected %q but got %q", data.expect, ret)
			}
		})
	}
}

func TestToStringWithErr(t *testing.T) {
	for _, data := range testData {
		t.Run(data.name, func(t *testing.T) {
			ret, err := ToStringWithErr(data.input)
			if err != nil && !data.expectError {
				t.Errorf("error occurred: %v", err)
			} else if err == nil && data.expectError {
				t.Error("expected error but none occurred")
			} else if ret != data.expect {
				t.Errorf("expected %q but got %q", data.expect, ret)
			}
		})
	}
}

func TestToCompactString(t *testing.T) {
	for _, data := range testData {
		t.Run(data.name, func(t *testing.T) {
			defer func() {
				if r := recover(); r != nil && !data.expectError {
					t.Errorf("unexpected panic: %v", r)
				}
			}()

			ret := ToCompactString(data.input)
			if ret != data.expect {
				t.Errorf("expected %q but got %q", data.expect, ret)
			}
		})
	}
}

func TestToCompactStringWithErr(t *testing.T) {
	for _, data := range testData {
		t.Run(data.name, func(t *testing.T) {
			ret, err := ToCompactStringWithErr(data.input)
			if err != nil && !data.expectError {
				t.Errorf("error occurred: %v", err)
			} else if err == nil && data.expectError {
				t.Error("expected error but none occurred")
			} else if ret != data.expect {
				t.Errorf("expected %q but got %q", data.expect, ret)
			}
		})
	}
}