1// Licensed to the .NET Foundation under one or more agreements.
2// The .NET Foundation licenses this file to you under the MIT license.
3// See the LICENSE file in the project root for more information.
4
5#pragma once
6#include <stdio.h>
7#include <stdlib.h> // required by itoa
8#include <iostream>
9#include "platformdefines.h"
10
11//////////////////////////////////////////////////////////////////////////////
12// Macro definitions
13//////////////////////////////////////////////////////////////////////////////
14#define ARRAY_SIZE 100
15#define ROWS 2
16#define COLUMNS 3
17
18#define COUNTOF(__arr) sizeof(__arr) / sizeof(__arr[0])
19#define ELEM_PER_ROW_2D(__arr) (&(__arr[1][0]) - &(__arr[0][0]))
20#define ROWS_2D(__arr) sizeof(__arr) / (ELEM_PER_ROW_2D(__arr) * sizeof(__arr[0][0]))
21
22#define ENTERFUNC() printf("============ [%s]\t ============\n", __FUNCTION__)
23
24#define CHECK_PARAM_NOT_EMPTY(__p) \
25 ENTERFUNC(); \
26 if ( (__p) == NULL ) \
27 { \
28 printf("[%s] Error: parameter actual is NULL\n", __FUNCTION__); \
29 return false; \
30 }
31
32#define CHECK_PARAM_EMPTY(__p) \
33 ENTERFUNC(); \
34 if ( __p != NULL ) \
35 { \
36 printf("[%s] Error: parameter ppActual is not NULL\n", __FUNCTION__); \
37 return false; \
38 }
39
40#define VERIFY_ERROR(__expect, __actual) \
41 std::cout << '[' << __FUNCSIG__ << "] EXPECT: " << (__expect) << ", ACTUAL: " << (__actual) << std::endl
42
43#define TRACE(__msg) \
44 std::cout << __msg << std::endl
45
46#define VERIFY_ERROR_MSG(__msg, __expect, __actual) \
47 printf("["##__FUNCSIG__##"] "##__msg, (__expect), (__actual))
48
49//////////////////////////////////////////////////////////////////////////////
50// Verify helper methods
51//////////////////////////////////////////////////////////////////////////////
52
53template<typename T>
54bool IsObjectEquals(const T& o1, const T& o2)
55{
56 return o1 == o2;
57}
58
59template<>
60bool IsObjectEquals(const LPSTR& o1, const LPSTR& o2)
61{
62 if (o1 == NULL)
63 {
64 return (o2 == NULL);
65 }
66 else if (o2 == NULL)
67 {
68 return false;
69 }
70
71 size_t cLen1 = strlen(o1);
72 size_t cLen2 = strlen(o2);
73
74 if (cLen1 != cLen2 )
75 {
76 printf("Not equals in %s\n",__FUNCTION__);
77 return false;
78 }
79
80 return strncmp(o1, o2, cLen1) == 0;
81}
82
83template<>
84bool IsObjectEquals(const LPCSTR& o1, const LPCSTR& o2)
85{
86 if (o1 == NULL)
87 {
88 return (o2 == NULL);
89 }
90 else if (o2 == NULL)
91 {
92 return false;
93 }
94
95 size_t cLen1 = strlen(o1);
96 size_t cLen2 = strlen(o2);
97
98 if (cLen1 != cLen2 )
99 {
100 printf("Not equals in %s\n",__FUNCTION__);
101 return false;
102 }
103
104 return strncmp(o1, o2, cLen1) == 0;
105}
106
107#ifdef _WIN32
108template<>
109bool IsObjectEquals(const BSTR& o1, const BSTR& o2)
110{
111 if (o1 == NULL)
112 {
113 return (o2 == NULL);
114 }
115 else if (o2 == NULL)
116 {
117 return false;
118 }
119
120 UINT uLen1 = SysStringLen(o1);
121 UINT uLen2 = SysStringLen(o2);
122
123 if (uLen1 != uLen2 )
124 {
125 printf("Not equals in %s\n",__FUNCTION__);
126 return false;
127 }
128
129 return memcmp(o1, o2, uLen1 * sizeof(*o1)) == 0;
130}
131#endif
132
133//////////////////////////////////////////////////////////////////////////////
134// Test Data Structure
135//////////////////////////////////////////////////////////////////////////////
136
137LPSTR ToString(int i)
138{
139 CHAR *pBuffer = (CHAR *)CoreClrAlloc(10 * sizeof(CHAR)); // 10 is enough for our case
140 _itoa_s(i, pBuffer, 10, 10);
141
142 return pBuffer;
143}
144
145#ifdef _WIN32
146BSTR ToBSTR(int i)
147{
148 BSTR bstrRet = NULL;
149 VarBstrFromI4(i, 0, 0, &bstrRet);
150
151 return bstrRet;
152}
153#endif
154
155struct TestStruct
156{
157 inline TestStruct()
158 : x(0)
159 , d(0)
160 , l(0)
161 , str(NULL)
162 {
163 }
164
165 inline TestStruct(int v)
166 : x(v)
167 , d(v)
168 , l(v)
169 {
170 str = ToString(v);
171 }
172
173 int x;
174 double d;
175 LONG64 l;
176 LPSTR str;
177
178 inline bool operator==(const TestStruct &other) const
179 {
180 return IsObjectEquals(x, other.x) &&
181 IsObjectEquals(d, other.d) &&
182 IsObjectEquals(l, other.l) &&
183 IsObjectEquals(str, other.str);
184 }
185};
186
187typedef struct S2
188{
189 INT i32;
190 UINT ui32;
191 SHORT s1;
192 WORD us1;
193 BYTE b;
194 CHAR sb;
195 SHORT i16;
196 WORD ui16;
197 LONG64 i64;
198 ULONG64 ui64;
199 FLOAT sgl;
200 DOUBLE d;
201}S2;
202
203//////////////////////////////////////////////////////////////////////////////
204// Other methods
205//////////////////////////////////////////////////////////////////////////////
206
207#ifdef _WIN32
208// Do not output variants, and suppress the boring template compile warning
209std::ostream &operator<<(std::ostream &ostr, VARIANT &v)
210{
211 return ostr;
212}
213
214std::ostream &operator<<(std::ostream &ostr, BSTR &b)
215{
216 std::wcout << b;
217 return ostr;
218}
219#endif
220
221//////////////////////////////////method for struct S2////////////////////////////////////////////////
222void InstanceS2(S2 * pREC, int i32,UINT ui32,SHORT s1,WORD us1,BYTE b,CHAR sb,SHORT i16,WORD ui16,
223 LONG64 i64,ULONG64 ui64,FLOAT sgl,DOUBLE d)
224{
225 pREC->i32 = i32;
226 pREC->ui32 = ui32;
227 pREC->s1 = s1;
228 pREC->us1 = us1;
229 pREC->b = b;
230 pREC->sb = sb;
231 pREC->i16 = i16;
232 pREC->ui16 = ui16;
233 pREC->i64 = i64;
234 pREC->ui64 = ui64;
235 pREC->sgl = sgl;
236 pREC->d = d;
237}
238
239bool ValidateS2LPArray(S2 * pREC, S2 * pRECCorrect, int numArrElement)
240{
241 for(int i = 0; i<numArrElement;i++)
242 {
243 if(pREC[i].i32 != pRECCorrect[i].i32)
244 {
245 printf("\t The field of int is not the expected!");
246 printf("\t\tpREC[%d].i32 = %d\n", i, pREC[i].i32);
247 printf("\t\tpRECCorrect[%d].i32 = %d\n", i, pRECCorrect[i].i32);
248 return false;
249 }
250 else if(pREC[i].ui32 != pRECCorrect[i].ui32)
251 {
252 printf("\t The field of UInt32 is not the expected!");
253 printf("\t\tpREC[%d].ui32 = %d\n", i, pREC[i].ui32);
254 printf("\t\tpRECCorrect[%d].ui32 = %u\n", i, pRECCorrect[i].ui32);
255 return false;
256 }
257 else if(pREC[i].s1 != pRECCorrect[i].s1)
258 {
259 printf("\t The field of short is not the expected!");
260 printf("\t\tpREC[%d].s1 = %d\n", i, pREC[i].s1);
261 printf("\t\tpRECCorrect[%d].s1 = %d\n", i, pRECCorrect[i].s1);
262 return false;
263 }
264 else if(pREC[i].us1 != pRECCorrect[i].us1)
265 {
266 printf("\t The field of ushort is not the expected!");
267 printf("\t\tpREC[%d].us1 = %d\n", i, pREC[i].us1);
268 printf("\t\tpRECCorrect[%d].us1 = %u\n", i, pRECCorrect[i].us1);
269 return false;
270 }
271 else if(pREC[i].b != pRECCorrect[i].b)
272 {
273 printf("\t The field of byte is not the expected!");
274 printf("\t\tpREC[%d].b = %d\n", i, pREC[i].b);
275 printf("\t\tpRECCorrect[%d].b = %d\n", i, pRECCorrect[i].b);
276 return false;
277 }
278 else if(pREC[i].sb != pRECCorrect[i].sb)
279 {
280 printf("\t The field of sbyte is not the expected!");
281 printf("\t\tpREC[%d].sb = %d\n", i, pREC[i].sb);
282 printf("\t\tpRECCorrect[%d].sb = %u\n", i, pRECCorrect[i].sb);
283 return false;
284 }
285 else if(pREC[i].i16 != pRECCorrect[i].i16)
286 {
287 printf("\t The field of Int16 is not the expected!");
288 printf("\t\tpREC[%d].i16 = %d\n", i, pREC[i].i16);
289 printf("\t\tpRECCorrect[%d].i16 = %d\n", i, pRECCorrect[i].i16);
290 return false;
291 }
292 else if(pREC[i].ui16 != pRECCorrect[i].ui16)
293 {
294 printf("\t The field of UInt16 is not the expected!");
295 printf("\t\tpREC[%d].ui16 = %d\n", i, pREC[i].ui16);
296 printf("\t\tpRECCorrect[%d].ui16 = %u\n", i, pRECCorrect[i].ui16);
297 return false;
298 }
299 else if(pREC[i].i64 != pRECCorrect[i].i64)
300 {
301 printf("\t The field of Int64 is not the expected!");
302 printf("\t\tpREC[%d].i64 = %lld\n", i, pREC[i].i64);
303 printf("\t\tpRECCorrect[%d].i64 = %lld\n", i, pRECCorrect[i].i64);
304 return false;
305 }
306 else if(pREC[i].ui64 != pRECCorrect[i].ui64)
307 {
308 printf("\t The field of UInt64 is not the expected!");
309 printf("\t\tpREC[%d].ui64 = %llu\n", i, pREC[i].ui64);
310 printf("\t\tpRECCorrect[%d].ui64 = %llu\n", i, pRECCorrect[i].ui64);
311 return false;
312 }
313 else if(pREC[i].sgl != pRECCorrect[i].sgl)
314 {
315 printf("\t The field of single is not the expected!");
316 printf("\t\tpREC[%d].sgl = %f\n", i, pREC[i].sgl);
317 printf("\t\tpRECCorrect[%d].sgl = %f\n", i, pRECCorrect[i].sgl);
318 return false;
319 }
320 else if(pREC[i].d != pRECCorrect[i].d)
321 {
322 printf("\t The field of double is not the expected!");
323 printf("\t\tpREC[%d].d = %f\n", i, pREC[i].d);
324 printf("\t\tpRECCorrect[%d].d = %f\n", i, pRECCorrect[i].d);
325 return false;
326 }
327 }
328 return true;
329}
330