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