1 krisbash 1.1 /*
2 **==============================================================================
3 **
4 ** Open Management Infrastructure (OMI)
5 **
6 ** Copyright (c) Microsoft Corporation
7 **
8 ** Licensed under the Apache License, Version 2.0 (the "License"); you may not
9 ** use this file except in compliance with the License. You may obtain a copy
10 ** of the License at
11 **
12 ** http://www.apache.org/licenses/LICENSE-2.0
13 **
14 ** THIS CODE IS PROVIDED *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15 ** KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
16 ** WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
17 ** MERCHANTABLITY OR NON-INFRINGEMENT.
18 **
19 ** See the Apache 2 License for the specific language governing permissions
20 ** and limitations under the License.
21 **
22 krisbash 1.1 **==============================================================================
23 */
24
25 #include <ut/ut.h>
26 #include <math.h>
27 #include <micxx/dinstance.h>
28 #include <tests/base/Outer.h>
29
30 using namespace std;
31 using namespace mi;
32
33 // TODO: Override new operator if needed for fault injection
34 // Currently most places in micxx code use new operator with already allocated memory
35 // so i am not sure how crucial it is to override that with an injected version for fault injection
36
37 template<class ZT>
38 Array<ZT> MakeArray(const ZT& x, const ZT& y)
39 {
40 Array<ZT> a;
41 a.PushBack(x);
42 a.PushBack(y);
43 krisbash 1.1 return a;
44 }
45
46 Array<String> MakeStrA(const String& x, const String& y)
47 {
48 Array<String> a;
49 a.PushBack(x);
50 a.PushBack(y);
51 return a;
52 }
53
54 NitsTest(Test1)
55 {
56 NitsDisableFaultSim;
57
58 DInstance di(ZT("Gadget"), DInstance::CLASS);
59 const StringA COLORS = MakeArray<String>(ZT("Red"), ZT("Green"));
60 const Uint32A NUMBERS = MakeArray<Uint32>(10, 20);
61
62 UT_ASSERT(di.AddBoolean(ZT("True"), true));
63 UT_ASSERT(di.AddBoolean(ZT("False"), false));
64 krisbash 1.1 UT_ASSERT(di.AddUint8(ZT("Uint8S"), 8));
65 UT_ASSERT(di.AddString(ZT("Color"), ZT("Red")));
66 UT_ASSERT(di.AddStringA(ZT("Colors"), COLORS));
67 UT_ASSERT(di.AddUint32A(ZT("Numbers"), NUMBERS));
68
69 {
70 Boolean tmp;
71 UT_ASSERT(di.GetBoolean(ZT("True"), tmp));
72 UT_ASSERT(tmp);
73 }
74 {
75 Boolean tmp;
76 UT_ASSERT(di.GetBoolean(ZT("False"), tmp));
77 UT_ASSERT(!tmp);
78 }
79 {
80 Uint8 tmp;
81 UT_ASSERT(di.GetUint8(ZT("Uint8S"), tmp));
82 UT_ASSERT(tmp == 8);
83 }
84 {
85 krisbash 1.1 Uint32A tmp;
86 UT_ASSERT(di.GetUint32A(ZT("Numbers"), tmp));
87 UT_ASSERT(tmp.GetSize() == 2);
88 UT_ASSERT(tmp[0] == NUMBERS[0]);
89 UT_ASSERT(tmp[1] == NUMBERS[1]);
90 }
91 {
92 StringA tmp;
93 UT_ASSERT(di.GetStringA(ZT("Colors"), tmp));
94 UT_ASSERT(tmp.GetSize() == COLORS.GetSize());
95 UT_ASSERT(tmp.GetSize() == 2);
96 UT_ASSERT(tmp[0] == COLORS[0]);
97 UT_ASSERT(tmp[1] == COLORS[1]);
98 }
99 {
100 String color;
101 UT_ASSERT(di.SetString(ZT("Color"), ZT("Blue")));
102 }
103
104
105 // Person.Key=1
106 krisbash 1.1 {
107 DInstance person(ZT("Person"), DInstance::ASSOCIATION);
108 UT_ASSERT(person.AddUint32(ZT("Key"), 1, false, true));
109 UT_ASSERT(person.AddString(ZT("First"), ZT("George")));
110 UT_ASSERT(person.AddString(ZT("Last"), ZT("Washington")));
111
112 Uint32 Key;
113 bool isKey;
114 bool isNull;
115 UT_ASSERT(person.GetUint32(ZT("Key"), Key, isNull, isKey));
116 UT_ASSERT(Key == 1);
117 UT_ASSERT(isKey);
118 UT_ASSERT(!isNull);
119
120 String First;
121 UT_ASSERT(person.GetString(ZT("First"), First));
122 UT_ASSERT(First == ZT("George"));
123
124 String Last;
125 UT_ASSERT(person.GetString(ZT("Last"), Last));
126 UT_ASSERT(Last == ZT("Washington"));
127 krisbash 1.1 UT_ASSERT(di.AddInstance(ZT("Person"), person));
128 }
129
130 DInstance d1(di);
131 d1.AddString(ZT("Reason"), ZT("None"));
132 }
133 NitsEndTest
134
135 NitsTest(Test2)
136 {
137 NitsDisableFaultSim;
138
139 DInstance d1;
140 DInstance d2(d1);
141 d2.AddUint32(ZT("P2"), 0);
142 UT_ASSERT(true); //TODO.
143 }
144 NitsEndTest
145
146 NitsTest(Test3)
147 {
148 krisbash 1.1 NitsDisableFaultSim;
149
150 DInstance d1;
151 d1.AddUint32(ZT("P2"), 0);
152 d1.AddUint32(ZT("P1"), 0);
153
154 DInstance d2(d1);
155 DInstance d3(d2);
156 DInstance d4;
157 d4 = d3;
158 d4 = d1;
159 d4 = d2;
160 UT_ASSERT(true); //TODO.
161 }
162 NitsEndTest
163
164 #if 0
165 template<class ZT>
166 Array<ZT> MakeArray(const ZT& x, Uint32 n)
167 {
168 Array<ZT> a;
169 krisbash 1.1 for (Uint32 i = 0; i < n; i++)
170 {
171 a.PushBack(x);
172 }
173
174 return a;
175 }
176 #endif
177
178 static double dabs(double x)
179 {
180 return x < 0.0 ? -x : x;
181 }
182
183 bool Close(double x, double y)
184 {
185 return dabs(x - y) <= 0.00001;
186 }
187
188 void CheckInnerInstance(const Inner_Class& inner)
189 {
190 krisbash 1.1 UT_ASSERT(inner.Key_value() == 32);
191 UT_ASSERT(inner.Str_value() == ZT("Hello"));
192 }
193
194 template<class ZT>
195 struct CheckArray
196 {
197 static bool func(const Array<ZT>& a, const ZT& x, const ZT& y)
198 {
199 return a.GetSize() == 2 && a[0] == x && a[1] == y;
200 }
201 };
202
203 template<>
204 struct CheckArray<Real32>
205 {
206 static bool func(const Array<Real32>& a, const Real32& x, const Real32& y)
207 {
208 return a.GetSize() == 2 && Close(a[0], x) && Close(a[1], y);
209 }
210 };
211 krisbash 1.1
212 template<>
213 struct CheckArray<Real64>
214 {
215 static bool func(const Array<Real64>& a, const Real64& x, const Real64& y)
216 {
217 return a.GetSize() == 2 && Close(a[0], x) && Close(a[1], y);
218 }
219 };
220
221 void CheckOuterInstance(const Outer_Class& x)
222 {
223 UT_ASSERT(x.booleanScalar_value()); // == true
224 UT_ASSERT(x.uint8Scalar_value() == 8);
225 UT_ASSERT(x.sint8Scalar_value() == -8);
226 UT_ASSERT(x.uint16Scalar_value() == 16);
227 UT_ASSERT(x.sint16Scalar_value() == -16);
228 UT_ASSERT(x.uint32Scalar_value() == 32);
229 UT_ASSERT(x.sint32Scalar_value() == -32);
230 UT_ASSERT(x.uint64Scalar_value() == 64);
231 UT_ASSERT(x.sint64Scalar_value() == -64);
232 krisbash 1.1 UT_ASSERT(Close(x.real32Scalar_value(), 32.32));
233 UT_ASSERT(Close(x.real64Scalar_value(), 64.64));
234 UT_ASSERT(x.char16Scalar_value() == 16);
235
236 {
237 Datetime datetimeScalar;
238 datetimeScalar.Set(MI_T("20091231120030.123456+360"));
239 UT_ASSERT(x.datetimeScalar_value() == datetimeScalar);
240 }
241
242 UT_ASSERT(x.stringScalar_value() == ZT("string"));
243
244 CheckInnerInstance(x.instanceScalar_value());
245
246 UT_ASSERT(CheckArray<Boolean>::func(x.booleanArray_value(), true, false));
247 UT_ASSERT(CheckArray<Uint8>::func(x.uint8Array_value(), 8, 8));
248 UT_ASSERT(CheckArray<Sint8>::func(x.sint8Array_value(), -8, -8));
249 UT_ASSERT(CheckArray<Uint16>::func(x.uint16Array_value(), 16, 16));
250 UT_ASSERT(CheckArray<Sint16>::func(x.sint16Array_value(), -16, -16));
251 UT_ASSERT(CheckArray<Uint32>::func(x.uint32Array_value(), 32, 32));
252 UT_ASSERT(CheckArray<Sint32>::func(x.sint32Array_value(), -32, -32));
253 krisbash 1.1 UT_ASSERT(CheckArray<Uint64>::func(x.uint64Array_value(), 64, 64));
254 UT_ASSERT(CheckArray<Sint64>::func(x.sint64Array_value(), -64, -64));
255 UT_ASSERT(CheckArray<Real32>::func(x.real32Array_value(), 32.32f, 32.32f));
256 UT_ASSERT(CheckArray<Real64>::func(x.real64Array_value(), 64.64, 64.64));
257 UT_ASSERT(CheckArray<Char16>::func(x.char16Array_value(), 16, 16));
258 UT_ASSERT(CheckArray<String>::func(x.stringArray_value(),
259 String(ZT("string")), String(ZT("string"))));
260
261 {
262 Datetime dt;
263 dt.Set(ZT("20091231120030.123456+360"));
264 UT_ASSERT(CheckArray<Datetime>::func(x.datetimeArray_value(), dt, dt));
265 }
266
267 {
268 UT_ASSERT(x.instanceArray_value().GetSize() == 2);
269 CheckInnerInstance(x.instanceArray_value()[0]);
270 CheckInnerInstance(x.instanceArray_value()[1]);
271 }
272 }
273
274 krisbash 1.1 NitsTest(Test4)
275 {
276 NitsDisableFaultSim;
277
278 DInstance d0(ZT("Inner"), DInstance::CLASS);
279 d0.AddUint32(ZT("Key"), 32);
280 d0.AddString(ZT("Str"), ZT("Hello"));
281
282 DInstance d1(ZT("Outer"), DInstance::CLASS);
283 d1.AddBoolean(ZT("booleanScalar"), true);
284 d1.AddUint8(ZT("uint8Scalar"), 8);
285 d1.AddSint8(ZT("sint8Scalar"), -8);
286 d1.AddUint16(ZT("uint16Scalar"), 16);
287 d1.AddSint16(ZT("sint16Scalar"), -16);
288 d1.AddUint32(ZT("uint32Scalar"), 32);
289 d1.AddSint32(ZT("sint32Scalar"), -32);
290 d1.AddUint64(ZT("uint64Scalar"), 64);
291 d1.AddSint64(ZT("sint64Scalar"), -64);
292 d1.AddReal32(ZT("real32Scalar"), 32.32f);
293 d1.AddReal64(ZT("real64Scalar"), 64.64);
294 d1.AddChar16(ZT("char16Scalar"), 16);
295 krisbash 1.1 Datetime datetimeScalar;
296 datetimeScalar.Set(ZT("20091231120030.123456+360"));
297 d1.AddDatetime(ZT("datetimeScalar"), datetimeScalar);
298 d1.AddString(ZT("stringScalar"), ZT("string"));
299 d1.AddInstance(ZT("instanceScalar"), d0);
300
301 d1.AddBooleanA(ZT("booleanArray"), MakeArray(Boolean(true), Boolean(false)));
302 d1.AddUint8A(ZT("uint8Array"), MakeArray(Uint8(8), Uint8(8)));
303 d1.AddSint8A(ZT("sint8Array"), MakeArray(Sint8(-8), Sint8(-8)));
304 d1.AddUint16A(ZT("uint16Array"), MakeArray(Uint16(16), Uint16(16)));
305 d1.AddSint16A(ZT("sint16Array"), MakeArray(Sint16(-16), Sint16(-16)));
306 d1.AddUint32A(ZT("uint32Array"), MakeArray(Uint32(32), Uint32(32)));
307 d1.AddSint32A(ZT("sint32Array"), MakeArray(Sint32(-32), Sint32(-32)));
308 d1.AddUint64A(ZT("uint64Array"), MakeArray(Uint64(64), Uint64(64)));
309 d1.AddSint64A(ZT("sint64Array"), MakeArray(Sint64(-64), Sint64(-64)));
310 d1.AddReal32A(ZT("real32Array"), MakeArray(Real32(32.32), Real32(32.32)));
311 d1.AddReal64A(ZT("real64Array"), MakeArray(Real64(64.64), Real64(64.64)));
312 d1.AddChar16A(ZT("char16Array"), MakeArray(Char16(16), Char16(16)));
313 d1.AddDatetimeA(ZT("datetimeArray"),
314 MakeArray(datetimeScalar, datetimeScalar));
315 d1.AddStringA(ZT("stringArray"),
316 krisbash 1.1 MakeArray(String(ZT("string")), String(ZT("string"))));
317 #if 1
318 d1.AddInstanceA(ZT("instanceArray"), MakeArray(d0, d0));
319 #endif
320
321 Outer_Class outer;
322 bool flag = DInstance::DynamicToStatic(d1, false, false, outer);
323 UT_ASSERT(flag == true);
324 CheckOuterInstance(outer);
325 }
326 NitsEndTest
327
328 NitsTest(Test5)
329 {
330 NitsDisableFaultSim;
331
332 DInstance d0(ZT("Inner"), DInstance::CLASS);
333 d0.AddUint32(ZT("Key"), 32);
334 d0.AddString(ZT("Str"), ZT("Hello"));
335
336 DInstance d1(ZT("Outer"), DInstance::CLASS);
337 krisbash 1.1 d1.AddString(ZT("booleanScalar"), ZT("true"));
338 d1.AddString(ZT("uint8Scalar"), ZT("8"));
339 d1.AddString(ZT("uint8Scalar"), ZT("8"));
340 d1.AddString(ZT("sint8Scalar"), ZT("-8"));
341 d1.AddString(ZT("uint16Scalar"), ZT("16"));
342 d1.AddString(ZT("sint16Scalar"), ZT("-16"));
343 d1.AddString(ZT("uint32Scalar"), ZT("32"));
344 d1.AddString(ZT("sint32Scalar"), ZT("-32"));
345 d1.AddString(ZT("uint64Scalar"), ZT("64"));
346 d1.AddString(ZT("sint64Scalar"), ZT("-64"));
347 d1.AddString(ZT("real32Scalar"), ZT("32.32"));
348 d1.AddString(ZT("real64Scalar"), ZT("64.64"));
349 d1.AddString(ZT("char16Scalar"), ZT("16"));
350 d1.AddString(ZT("datetimeScalar"), ZT("20091231120030.123456+360"));
351 d1.AddString(ZT("stringScalar"), ZT("string"));
352 d1.AddInstance(ZT("instanceScalar"), d0);
353
354 d1.AddStringA(ZT("booleanArray"), MakeStrA(ZT("true"), ZT("false")));
355
356 d1.AddStringA(ZT("uint8Array"), MakeStrA(ZT("8"), ZT("8")));
357 d1.AddStringA(ZT("sint8Array"), MakeStrA(ZT("-8"), ZT("-8")));
358 krisbash 1.1
359 d1.AddStringA(ZT("uint16Array"), MakeStrA(ZT("16"), ZT("16")));
360 d1.AddStringA(ZT("sint16Array"), MakeStrA(ZT("-16"), ZT("-16")));
361
362 d1.AddStringA(ZT("uint32Array"), MakeStrA(ZT("32"), ZT("32")));
363 d1.AddStringA(ZT("sint32Array"), MakeStrA(ZT("-32"), ZT("-32")));
364
365 d1.AddStringA(ZT("uint64Array"), MakeStrA(ZT("64"), ZT("64")));
366 d1.AddStringA(ZT("sint64Array"), MakeStrA(ZT("-64"), ZT("-64")));
367
368 d1.AddStringA(ZT("real32Array"), MakeStrA(ZT("32.32"), ZT("32.32")));
369 d1.AddStringA(ZT("real64Array"), MakeStrA(ZT("64.64"), ZT("64.64")));
370
371 d1.AddStringA(ZT("char16Array"), MakeStrA(ZT("16"), ZT("16")));
372
373 d1.AddStringA(ZT("datetimeArray"), MakeStrA(ZT("20091231120030.123456+360"),
374 ZT("20091231120030.123456+360")));
375
376 d1.AddStringA(ZT("stringArray"),
377 MakeArray(String(ZT("string")), String(ZT("string"))));
378 d1.AddInstanceA(ZT("instanceArray"), MakeArray(d0, d0));
379 krisbash 1.1
380 Outer_Class outer;
381 bool flag = DInstance::DynamicToStatic(d1, false, false, outer);
382 UT_ASSERT(flag == true);
383
384 CheckOuterInstance(outer);
385
386 DInstance dinst2;
387 flag = DInstance::StaticToDynamic(outer, false, dinst2);
388 UT_ASSERT(flag == true);
389
390 Outer_Class outer2;
391 flag = DInstance::DynamicToStatic(dinst2, false, false, outer2);
392 UT_ASSERT(flag == true);
393
394 CheckOuterInstance(outer2);
395 }
396 NitsEndTest
397
|
Return to
test_micxx.cpp
CVS log
Up to [OMI] / omi / tests / micxx