1 /***********************************************************************************************************************************
2 Test Convert C Types
3 ***********************************************************************************************************************************/
4 #include "common/stackTrace.h"
5 
6 /***********************************************************************************************************************************
7 Test Run
8 ***********************************************************************************************************************************/
9 void
testRun(void)10 testRun(void)
11 {
12     FUNCTION_HARNESS_VOID();
13 
14     // *****************************************************************************************************************************
15     if (testBegin("cvtBoolToZ()"))
16     {
17         char buffer[STACK_TRACE_PARAM_MAX];
18 
19         TEST_ERROR(cvtBoolToZ(true, buffer, 4), AssertError, "buffer overflow");
20 
21         TEST_RESULT_UINT(cvtBoolToZ(true, buffer, STACK_TRACE_PARAM_MAX), 4, "convert true bool to string");
22         TEST_RESULT_Z(buffer, "true", "    check buffer");
23         TEST_RESULT_UINT(cvtBoolToZ(false, buffer, STACK_TRACE_PARAM_MAX), 5, "convert false bool to string");
24         TEST_RESULT_Z(buffer, "false", "    check buffer");
25     }
26 
27     // *****************************************************************************************************************************
28     if (testBegin("cvtCharToZ()"))
29     {
30         char buffer[STACK_TRACE_PARAM_MAX];
31 
32         TEST_ERROR(cvtCharToZ('A', buffer, 1), AssertError, "buffer overflow");
33 
34         TEST_RESULT_UINT(cvtCharToZ('C', buffer, STACK_TRACE_PARAM_MAX), 1, "convert char to string");
35         TEST_RESULT_Z(buffer, "C", "    check buffer");
36     }
37 
38     // *****************************************************************************************************************************
39     if (testBegin("cvtDoubleToZ() and cvtZToDouble()"))
40     {
41         char buffer[STACK_TRACE_PARAM_MAX];
42 
43         TEST_ERROR(cvtDoubleToZ(999.1234, buffer, 4), AssertError, "buffer overflow");
44 
45         TEST_RESULT_UINT(cvtDoubleToZ(999.1234, buffer, STACK_TRACE_PARAM_MAX), 8, "convert double to string");
46         TEST_RESULT_Z(buffer, "999.1234", "    check buffer");
47 
48         TEST_RESULT_UINT(cvtDoubleToZ(999999999.123456, buffer, STACK_TRACE_PARAM_MAX), 16, "convert double to string");
49         TEST_RESULT_Z(buffer, "999999999.123456", "    check buffer");
50 
51         TEST_RESULT_UINT(cvtDoubleToZ(999.0, buffer, STACK_TRACE_PARAM_MAX), 3, "convert double to string");
52         TEST_RESULT_Z(buffer, "999", "    check buffer");
53 
54         TEST_ERROR(cvtZToDouble("AAA"), FormatError, "unable to convert string 'AAA' to double");
55         TEST_RESULT_DOUBLE(cvtZToDouble("0"), 0, "convert string to double");
56         TEST_RESULT_DOUBLE(cvtZToDouble("123.123"), 123.123, "convert string to double");
57         TEST_RESULT_DOUBLE(cvtZToDouble("-999999999.123456"), -999999999.123456, "convert string to double");
58     }
59 
60     // *****************************************************************************************************************************
61     if (testBegin("cvtIntToZ() and cvtZToInt()"))
62     {
63         char buffer[STACK_TRACE_PARAM_MAX];
64 
65         TEST_ERROR(cvtIntToZ(9999, buffer, 4), AssertError, "buffer overflow");
66 
67         TEST_RESULT_UINT(cvtIntToZ(1234567890, buffer, STACK_TRACE_PARAM_MAX), 10, "convert int to string");
68         TEST_RESULT_Z(buffer, "1234567890", "    check buffer");
69 
70         TEST_ERROR(cvtZToInt("FEF"), FormatError, "unable to convert base 10 string 'FEF' to int");
71         TEST_ERROR(cvtZToInt("9223372036854775807"), FormatError, "unable to convert base 10 string '9223372036854775807' to int");
72         TEST_ERROR(
73             cvtZToInt("-9223372036854775807"), FormatError, "unable to convert base 10 string '-9223372036854775807' to int");
74 
75         TEST_RESULT_INT(cvtZToIntBase("-FF", 16), -255, "convert string to int");
76         TEST_RESULT_INT(cvtZToInt("0"), 0, "convert string to int");
77         TEST_RESULT_INT(cvtZToInt("1234567890"), 1234567890, "convert string to int");
78         TEST_RESULT_INT(cvtZToInt("-1234567890"), -1234567890, "convert string to int");
79     }
80 
81     // *****************************************************************************************************************************
82     if (testBegin("cvtInt32ToZigZag(), cvtInt32FromZigZag(), cvtInt64ToZigZag(), and cvtInt64FromZigZag()"))
83     {
84         TEST_TITLE("32-bit zigzag");
85 
86         TEST_RESULT_UINT(cvtInt32ToZigZag(-1), 1, "-1 to zigzag");
87         TEST_RESULT_UINT(cvtInt32ToZigZag(INT32_MIN), UINT32_MAX, "INT32_MIN to zigzag");
88         TEST_RESULT_UINT(cvtInt32ToZigZag(INT32_MAX), UINT32_MAX - 1, "INT32_MAX to zigzag");
89         TEST_RESULT_INT(cvtInt32FromZigZag(1), -1, "-1 to zigzag");
90         TEST_RESULT_INT(cvtInt32FromZigZag(UINT32_MAX), INT32_MIN, "zigzag to INT32_MIN");
91         TEST_RESULT_INT(cvtInt32FromZigZag(UINT32_MAX - 1), INT32_MAX, "zigzag to INT32_MAX");
92 
93         TEST_TITLE("64-bit zigzag");
94 
95         TEST_RESULT_UINT(cvtInt64ToZigZag(-1), 1, "-1 to zigzag");
96         TEST_RESULT_UINT(cvtInt64ToZigZag(INT64_MIN), UINT64_MAX, "INT64_MIN to zigzag");
97         TEST_RESULT_UINT(cvtInt64ToZigZag(INT64_MAX), UINT64_MAX - 1, "INT64_MAX to zigzag");
98         TEST_RESULT_INT(cvtInt64FromZigZag(1), -1, "-1 to zigzag");
99         TEST_RESULT_INT(cvtInt64FromZigZag(UINT64_MAX), INT64_MIN, "zigzag to INT64_MIN");
100         TEST_RESULT_INT(cvtInt64FromZigZag(UINT64_MAX - 1), INT64_MAX, "zigzag to INT64_MAX");
101     }
102 
103     // *****************************************************************************************************************************
104     if (testBegin("cvtModeToZ()"))
105     {
106         char buffer[STACK_TRACE_PARAM_MAX];
107 
108         TEST_ERROR(cvtModeToZ(0750, buffer, 4), AssertError, "buffer overflow");
109 
110         TEST_RESULT_UINT(cvtModeToZ(0777, buffer, STACK_TRACE_PARAM_MAX), 4, "convert mode to string");
111         TEST_RESULT_Z(buffer, "0777", "    check buffer");
112 
113         TEST_RESULT_UINT(cvtZToMode("0700"), 0700, "convert string to mode");
114     }
115 
116     // *****************************************************************************************************************************
117     if (testBegin("cvtSizeToZ() and cvtSSizeToZ()"))
118     {
119         char buffer[STACK_TRACE_PARAM_MAX];
120 
121         TEST_ERROR(cvtSizeToZ(9999, buffer, 4), AssertError, "buffer overflow");
122 
123         TEST_RESULT_UINT(cvtSizeToZ(4294967295, buffer, STACK_TRACE_PARAM_MAX), 10, "convert size to string");
124         TEST_RESULT_Z(buffer, "4294967295", "    check buffer");
125 
126         // ------------------------------------------------------------------------------------------------------------------------
127         TEST_ERROR(cvtSSizeToZ(-9999, buffer, 4), AssertError, "buffer overflow");
128 
129         TEST_RESULT_UINT(cvtSSizeToZ(-9999, buffer, STACK_TRACE_PARAM_MAX), 5, "convert ssize to string");
130         TEST_RESULT_Z(buffer, "-9999", "    check buffer");
131     }
132 
133     // *****************************************************************************************************************************
134     if (testBegin("cvtTimeToZ()"))
135     {
136         char buffer[STACK_TRACE_PARAM_MAX];
137 
138         TEST_ERROR(cvtTimeToZ(9999, buffer, 4), AssertError, "buffer overflow");
139 
140         TEST_RESULT_UINT(cvtTimeToZ(1573222014, buffer, STACK_TRACE_PARAM_MAX), 10, "convert time to string");
141         TEST_RESULT_Z(buffer, "1573222014", "    check buffer");
142     }
143 
144     // *****************************************************************************************************************************
145     if (testBegin("cvtUIntToZ() and cvtZToUInt()"))
146     {
147         char buffer[STACK_TRACE_PARAM_MAX];
148 
149         TEST_ERROR(cvtUIntToZ(9999, buffer, 4), AssertError, "buffer overflow");
150 
151         TEST_RESULT_UINT(cvtUIntToZ(4294967295, buffer, STACK_TRACE_PARAM_MAX), 10, "convert unsigned int to string");
152         TEST_RESULT_Z(buffer, "4294967295", "    check buffer");
153 
154         TEST_ERROR(cvtZToUInt("-1"), FormatError, "unable to convert base 10 string '-1' to unsigned int");
155         TEST_ERROR(cvtZToUInt("5000000000"), FormatError, "unable to convert base 10 string '5000000000' to unsigned int");
156 
157         TEST_RESULT_UINT(cvtZToUIntBase("FF", 16), 255, "convert string to unsigned int");
158         TEST_RESULT_UINT(cvtZToUInt("3333333333"), 3333333333U, "convert string to unsigned int");
159     }
160 
161     // *****************************************************************************************************************************
162     if (testBegin("cvtInt64ToZ() and cvtZToInt64()"))
163     {
164         char buffer[STACK_TRACE_PARAM_MAX];
165 
166         TEST_ERROR(cvtInt64ToZ(9999, buffer, 4), AssertError, "buffer overflow");
167 
168         TEST_RESULT_UINT(cvtInt64ToZ(9223372036854775807, buffer, STACK_TRACE_PARAM_MAX), 19, "convert int64 to string");
169         TEST_RESULT_Z(buffer, "9223372036854775807", "    check buffer");
170 
171         TEST_ERROR(cvtZToInt64("123INV"), FormatError, "unable to convert base 10 string '123INV' to int64");
172         TEST_ERROR(cvtZToInt64("FEF"), FormatError, "unable to convert base 10 string 'FEF' to int64");
173         TEST_ERROR(cvtZToInt64(""), FormatError, "unable to convert base 10 string '' to int64");
174         TEST_ERROR(cvtZToInt64(" 1"), FormatError, "unable to convert base 10 string ' 1' to int64");
175         TEST_ERROR(cvtZToInt64("\t1"), FormatError, "unable to convert base 10 string '\t1' to int64");
176         TEST_ERROR(cvtZToInt64("1\t"), FormatError, "unable to convert base 10 string '1\t' to int64");
177         TEST_ERROR(
178             cvtZToInt64("9223372036854775808"), FormatError, "unable to convert base 10 string '9223372036854775808' to int64");
179 
180         TEST_RESULT_INT(cvtZToInt64Base("-FF", 16), -255, "convert string to int64");
181         TEST_RESULT_INT(cvtZToInt64("0"), 0, "convert string to int64");
182         TEST_RESULT_INT(cvtZToInt64("9223372036854775807"), 9223372036854775807, "convert string to int64");
183         TEST_RESULT_INT(cvtZToInt64("-9223372036854775807"), -9223372036854775807, "convert string to int64");
184     }
185 
186     // *****************************************************************************************************************************
187     if (testBegin("UInt64ToZ() and cvtZToUInt64()"))
188     {
189         char buffer[STACK_TRACE_PARAM_MAX];
190 
191         TEST_ERROR(cvtUInt64ToZ(9999, buffer, 4), AssertError, "buffer overflow");
192 
193         TEST_RESULT_UINT(cvtUInt64ToZ(0xFFFFFFFFFFFFFFFF, buffer, STACK_TRACE_PARAM_MAX), 20, "convert uint64 to string");
194         TEST_RESULT_Z(buffer, "18446744073709551615", "    check buffer");
195 
196         TEST_ERROR(cvtZToUInt64("FEF"), FormatError, "unable to convert base 10 string 'FEF' to uint64");
197         TEST_ERROR(cvtZToUInt64(" 10"), FormatError, "unable to convert base 10 string ' 10' to uint64");
198         TEST_ERROR(cvtZToUInt64("10 "), FormatError, "unable to convert base 10 string '10 ' to uint64");
199         TEST_ERROR(cvtZToUInt64("-1"), FormatError, "unable to convert base 10 string '-1' to uint64");
200 
201         TEST_RESULT_UINT(cvtZToUInt64Base("FF", 16), 255, "convert string to uint64");
202         TEST_RESULT_UINT(cvtZToUInt64("18446744073709551615"), 18446744073709551615U, "convert string to uint64");
203     }
204 
205     FUNCTION_HARNESS_RETURN_VOID();
206 }
207