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 /* Must be defined first (define MI_CHAR_TYPE) */
26 #include <mof/mof.h>
27
28 #include <string>
29 #include <map>
30 #include <iostream>
31
32 #if defined(_MSC_VER)
33 #include <io.h>
34 #define CONFIG_CIMSCHEMA "CIM-2.32.0"
35 #endif
36
37 #include <common.h>
38
39 #include <ut/ut.h>
40
41 #include <pal/format.h>
42 #include <pal/file.h>
43 krisbash 1.1 #include <base/paths.h>
44 #include <pal/dir.h>
45 #include <pal/strings.h>
46
47 using namespace std;
48
49 #if defined(_MSC_VER)
50 #undef BEGIN_EXTERNC
51 #undef END_EXTERNC
52 #define BEGIN_EXTERNC
53 #define END_EXTERNC
54 #endif
55
56 static char TEMP_FILE[PAL_MAX_PATH_SIZE];
57
58 static struct MofTestResults {
59 string m_error, m_warning;
60
61 map<string,string> m_classes, m_qualifiers;
62
63 void clear()
64 krisbash 1.1 {
65 m_error.clear();
66 m_warning.clear();
67 m_classes.clear();
68 m_qualifiers.clear();
69 }
70
71 } s_results;
72
73 extern "C" void ErrorCallback(const char* msg, const wchar_t* wmsg, void* )
74 {
75 MI_UNUSED(wmsg);
76 s_results.m_error += msg;
77 s_results.m_error += "\n";
78 fprintf(stderr, "%s\n", msg);
79 }
80
81 extern "C" void ErrorCallback_Quiet(const char* msg, const wchar_t* wmsg, void*)
82 {
83 MI_UNUSED(wmsg);
84 s_results.m_error += msg;
85 krisbash 1.1 s_results.m_error += "\n";
86 }
87
88 extern "C" void WarningCallback(const char* msg, const wchar_t* wmsg, void*)
89 {
90 MI_UNUSED(wmsg);
91 s_results.m_warning += msg;
92 s_results.m_warning += "\n";
93 //fprintf(stderr, "%s\n", msg);
94 }
95
96 extern "C" void PragmaCallback(const char* pragma, const char* value, void* )
97 {
98 printf("pragma: %s=%s\n", pragma, value);
99 }
100
101 BEGIN_EXTERNC
102 void ClassDeclCallback(const MI_ClassDecl* decl, void* )
103 {
104 //printf("class: %s, parent: %s\n", decl->name, decl->superClass != 0 ? decl->superClass : "");
105 // verify class definition
106 krisbash 1.1 if ( ut::String(MI_T("MyClass")) == decl->name )
107 {
108 UT_ASSERT( decl->superClass == 0 ||
109 ut::String() == decl->superClass);
110 }
111 else if ( ut::String(MI_T("MyAssoc")) == decl->name )
112 {
113 UT_ASSERT( decl->superClass == 0 ||
114 ut::String() == decl->superClass);
115 }
116 else if ( ut::String(MI_T("YourClass")) == decl->name )
117 {
118 UT_ASSERT( decl->superClass != 0 &&
119 ut::String(MI_T("MyClass")) == decl->superClass);
120 }
121 else if ( ut::String(MI_T("X")) == decl->name )
122 {
123 UT_ASSERT( decl->superClass == 0 ||
124 ut::String() == decl->superClass);
125 }
126 else if ( ut::String(MI_T("Y")) == decl->name )
127 krisbash 1.1 {
128 UT_ASSERT( decl->superClass != 0 &&
129 ut::String(MI_T("X")) == decl->superClass);
130 }
131 else if ( ut::String(MI_T("Z")) == decl->name )
132 {
133 UT_ASSERT( decl->superClass != 0 &&
134 ut::String(MI_T("Y")) == decl->superClass);
135 }
136 else if ( ut::String(MI_T("Y2")) == decl->name )
137 {
138 UT_ASSERT( decl->superClass != 0 &&
139 ut::String(MI_T("X")) == decl->superClass);
140 }
141 else if ( ut::String(MI_T("Z2")) == decl->name )
142 {
143 UT_ASSERT( decl->superClass != 0 &&
144 ut::String(MI_T("Y2")) == decl->superClass);
145 }
146 else if ( ut::String(MI_T("Class")) == decl->name )
147 {
148 krisbash 1.1 UT_ASSERT( decl->superClass == 0 ||
149 ut::String() == decl->superClass);
150 }
151 else if ( ut::String(MI_T("Tosubclass")) == decl->name )
152 {
153 UT_ASSERT( decl->superClass != 0 &&
154 ut::String("Class") == decl->superClass);
155 }
156 else if ( ut::String(MI_T("SMS_Class_Template")) == decl->name )
157 {
158 UT_ASSERT( decl->superClass == 0 ||
159 ut::String("") == decl->superClass);
160 }
161 else if ( ut::String(MI_T("Test_Misc")) == decl->name )
162 {
163 UT_ASSERT( decl->superClass != 0 &&
164 ut::String("SMS_Class_Template") == decl->superClass);
165 }
166 else
167 {
168 printf(MI_T("class: %s\n"), decl->name);
169 krisbash 1.1 UT_ASSERT(ut::_StrToFalse("unexpected classname"));
170 }
171 }
172
173 void ClassDeclCallback_Q(const MI_ClassDecl* decl, void* )
174 {
175 // verify class definition
176 if ( ut::String(MI_T("X")) == decl->name )
177 {
178 UT_ASSERT( decl->superClass == 0 ||
179 ut::String() == decl->superClass);
180 }
181 else if ( ut::String(MI_T("Y")) == decl->name )
182 {
183 UT_ASSERT( decl->superClass != 0 &&
184 ut::String(MI_T("X")) == decl->superClass);
185 }
186 else
187 {
188 printf(MI_T("class: %s\n"), decl->name);
189 UT_ASSERT(ut::_StrToFalse("unexpected classname"));
190 krisbash 1.1 }
191 }
192
193 void QualifierDeclCallback(const MI_QualifierDecl* decl, void* )
194 {
195 //printf("qualifier: %s\n", decl->name);
196 if ( ut::String(MI_T("Association")) == decl->name ||
197 ut::String(MI_T("Indication")) == decl->name ||
198 ut::String(MI_T("Abstract")) == decl->name ||
199 ut::String(MI_T("Aggregate")) == decl->name ||
200 ut::String(MI_T("Aggregation")) == decl->name ||
201 ut::String(MI_T("Composition")) == decl->name ||
202 ut::String(MI_T("Counter")) == decl->name ||
203 ut::String(MI_T("DN")) == decl->name ||
204 ut::String(MI_T("EmbeddedObject")) == decl->name ||
205 ut::String(MI_T("Exception")) == decl->name ||
206 ut::String(MI_T("Experimental")) == decl->name ||
207 ut::String(MI_T("Gauge")) == decl->name ||
208 ut::String(MI_T("In")) == decl->name ||
209 ut::String(MI_T("Key")) == decl->name ||
210 ut::String(MI_T("Octetstring")) == decl->name ||
211 krisbash 1.1 ut::String(MI_T("Out")) == decl->name ||
212 ut::String(MI_T("Read")) == decl->name ||
213 ut::String(MI_T("Required")) == decl->name ||
214 ut::String(MI_T("Static")) == decl->name ||
215 ut::String(MI_T("Terminal")) == decl->name ||
216 ut::String(MI_T("Weak")) == decl->name ||
217 ut::String(MI_T("Write")) == decl->name ||
218 ut::String(MI_T("BooleanQ")) == decl->name ||
219 ut::String(MI_T("SMS_Report")) == decl->name )
220 {
221 UT_ASSERT( decl->type == MI_BOOLEAN );
222 }
223 else if ( ut::String(MI_T("ArrayType")) == decl->name ||
224 ut::String(MI_T("Description")) == decl->name ||
225 ut::String(MI_T("DisplayName")) == decl->name ||
226 ut::String(MI_T("EmbeddedInstance")) == decl->name ||
227 ut::String(MI_T("Nonlocal")) == decl->name ||
228 ut::String(MI_T("NonlocalType")) == decl->name ||
229 ut::String(MI_T("NullValue")) == decl->name ||
230 ut::String(MI_T("Override")) == decl->name ||
231 ut::String(MI_T("Propagated")) == decl->name ||
232 krisbash 1.1 ut::String(MI_T("Revision")) == decl->name ||
233 ut::String(MI_T("Schema")) == decl->name ||
234 ut::String(MI_T("Source")) == decl->name ||
235 ut::String(MI_T("SourceType")) == decl->name ||
236 ut::String(MI_T("UMLPackagePath")) == decl->name ||
237 ut::String(MI_T("Units")) == decl->name ||
238 ut::String(MI_T("Version")) == decl->name ||
239 ut::String(MI_T("StringQ")) == decl->name ||
240 ut::String(MI_T("SMS_GroupName")) == decl->name ||
241 ut::String(MI_T("SMS_Class_ID")) == decl->name ||
242 ut::String(MI_T("SMS_Units")) == decl->name ||
243 ut::String(MI_T("SMS_Group_Name")) == decl->name )
244 {
245 UT_ASSERT( decl->type == MI_STRING );
246 }
247 else if ( ut::String(MI_T("BitMap")) == decl->name ||
248 ut::String(MI_T("BitValues")) == decl->name ||
249 ut::String(MI_T("ClassConstraint")) == decl->name ||
250 ut::String(MI_T("Deprecated")) == decl->name ||
251 ut::String(MI_T("MappingStrings")) == decl->name ||
252 ut::String(MI_T("MethodConstraint")) == decl->name ||
253 krisbash 1.1 ut::String(MI_T("ModelCorrespondence")) == decl->name ||
254 ut::String(MI_T("PropertyConstraint")) == decl->name ||
255 ut::String(MI_T("ValueMap")) == decl->name ||
256 ut::String(MI_T("Values")) == decl->name ||
257 ut::String(MI_T("StringAQ")) == decl->name )
258 {
259 UT_ASSERT( decl->type == MI_STRINGA );
260 }
261 else if ( ut::String(MI_T("Max")) == decl->name ||
262 ut::String(MI_T("MaxLen")) == decl->name ||
263 ut::String(MI_T("Min")) == decl->name ||
264 ut::String(MI_T("MinLen")) == decl->name ||
265 ut::String(MI_T("Uint32Q")) == decl->name ||
266 ut::String(MI_T("X")) == decl->name ||
267 ut::String(MI_T("Y")) == decl->name ||
268 ut::String(MI_T("Z")) == decl->name )
269 {
270 UT_ASSERT( decl->type == MI_UINT32 );
271 }
272 else if ( ut::String(MI_T("MaxValue")) == decl->name ||
273 ut::String(MI_T("MinValue")) == decl->name ||
274 krisbash 1.1 ut::String(MI_T("Sint64Q")) == decl->name )
275 {
276 UT_ASSERT( decl->type == MI_SINT64 );
277 }
278 else if ( ut::String(MI_T("Sint8Q")) == decl->name )
279 {
280 UT_ASSERT( decl->type == MI_SINT8 );
281 }
282 else if ( ut::String(MI_T("Uint8Q")) == decl->name )
283 {
284 UT_ASSERT( decl->type == MI_UINT8 );
285 }
286 else if ( ut::String(MI_T("Sint16Q")) == decl->name )
287 {
288 UT_ASSERT( decl->type == MI_SINT16 );
289 }
290 else if ( ut::String(MI_T("Uint16Q")) == decl->name )
291 {
292 UT_ASSERT( decl->type == MI_UINT16 );
293 }
294 else if ( ut::String(MI_T("Sint32Q")) == decl->name )
295 krisbash 1.1 {
296 UT_ASSERT( decl->type == MI_SINT32 );
297 }
298 else if ( ut::String(MI_T("Uint64Q")) == decl->name )
299 {
300 UT_ASSERT( decl->type == MI_UINT64 );
301 }
302 else if ( ut::String(MI_T("Real32Q")) == decl->name )
303 {
304 UT_ASSERT( decl->type == MI_REAL32 );
305 }
306 else if ( ut::String(MI_T("Real64Q")) == decl->name )
307 {
308 UT_ASSERT( decl->type == MI_REAL64 );
309 }
310 else if ( ut::String(MI_T("Char16Q")) == decl->name )
311 {
312 UT_ASSERT( decl->type == MI_CHAR16 );
313 }
314 else if ( ut::String(MI_T("DatetimeQ")) == decl->name ||
315 ut::String(MI_T("DatetimeQ2")) == decl->name )
316 krisbash 1.1 {
317 UT_ASSERT( decl->type == MI_DATETIME );
318 }
319 else if ( ut::String(MI_T("BooleanAQ")) == decl->name )
320 {
321 UT_ASSERT( decl->type == MI_BOOLEANA );
322 }
323 else if ( ut::String(MI_T("Sint8AQ")) == decl->name )
324 {
325 UT_ASSERT( decl->type == MI_SINT8A );
326 }
327 else if ( ut::String(MI_T("Uint8AQ")) == decl->name )
328 {
329 UT_ASSERT( decl->type == MI_UINT8A );
330 }
331 else if ( ut::String(MI_T("Sint16AQ")) == decl->name )
332 {
333 UT_ASSERT( decl->type == MI_SINT16A );
334 }
335 else if ( ut::String(MI_T("Uint16AQ")) == decl->name )
336 {
337 krisbash 1.1 UT_ASSERT( decl->type == MI_UINT16A );
338 }
339 else if ( ut::String(MI_T("Sint32AQ")) == decl->name )
340 {
341 UT_ASSERT( decl->type == MI_SINT32A );
342 }
343 else if ( ut::String(MI_T("Uint32AQ")) == decl->name )
344 {
345 UT_ASSERT( decl->type == MI_UINT32A );
346 }
347 else if ( ut::String(MI_T("Sint64AQ")) == decl->name )
348 {
349 UT_ASSERT( decl->type == MI_SINT64A );
350 }
351 else if ( ut::String(MI_T("Uint64AQ")) == decl->name )
352 {
353 UT_ASSERT( decl->type == MI_UINT64A );
354 }
355 else if ( ut::String(MI_T("Real32AQ")) == decl->name )
356 {
357 UT_ASSERT( decl->type == MI_REAL32A );
358 krisbash 1.1 }
359 else if ( ut::String(MI_T("Real64AQ")) == decl->name )
360 {
361 UT_ASSERT( decl->type == MI_REAL64A );
362 }
363 else if ( ut::String(MI_T("Char16AQ")) == decl->name )
364 {
365 UT_ASSERT( decl->type == MI_CHAR16A );
366 }
367 else if ( ut::String(MI_T("DatetimeAQ")) == decl->name )
368 {
369 UT_ASSERT( decl->type == MI_DATETIMEA );
370 }
371 else
372 {
373 printf(MI_T("qualifier: %s\n"), decl->name);
374 UT_ASSERT(ut::_StrToFalse("unexpected qualifier"));
375 }
376 }
377 END_EXTERNC
378
379 krisbash 1.1 static string findMofFile(const char* file)
380 {
381 string root = OMI_GetPath(ID_PREFIX);
382 return ut::findSampleFile(root.c_str(), "tests/mof/", file);
383 }
384
385 static int ParseFile(const char* file, bool ignore_callbacks, bool use_quiet_callback)
386 {
387 MOF_Parser* parser;
388
389 parser = MOF_Parser_New(0, 0);
390
391 MOF_Parser_SetErrorCallback(parser, use_quiet_callback ? ErrorCallback_Quiet : ErrorCallback, NULL);
392 MOF_Parser_SetWarningCallback(parser, WarningCallback, NULL);
393 if ( !ignore_callbacks)
394 {
395 MOF_Parser_SetPragmaCallback(parser, PragmaCallback, NULL);
396 MOF_Parser_SetClassDeclCallback(parser, ClassDeclCallback_Q, NULL);
397 //MOF_Parser_SetQualifierDeclCallback(parser, QualifierDeclCallback, NULL);
398 }
399
400 krisbash 1.1 /* clear results from previous run */
401 s_results.clear();
402
403 /* Parse the file */
404 int res = MOF_Parser_Parse(parser, file);
405
406 /* Delete the parser */
407 MOF_Parser_Delete(parser);
408
409 return res;
410 }
411
412 NitsSetup(TestMofSetup)
413 {
414 NitsDisableFaultSim;
415 Strlcpy(TEMP_FILE, OMI_GetPath(ID_TMPDIR), sizeof(TEMP_FILE));
416 Strlcat(TEMP_FILE, "/test_temp.tmp", sizeof(TEMP_FILE));
417
418 #if 0
419 string root = OMI_GetPath(ID_PREFIX);
420 root += "/unittest";
421 krisbash 1.1 Chdir(root.c_str());
422 #endif
423 s_results.clear();
424
425 #ifndef _MSC_VER
426 Chdir(CONFIG_SRCDIR);
427 #endif
428 }
429 NitsEndSetup
430
431 NitsCleanup(TestMofSetup)
432 {
433 ut::removeIfExist( TEMP_FILE );
434 }
435 NitsEndCleanup
436
437 NitsTestWithSetup(TestFailedIfFileDoesNotExist, TestMofSetup)
438 {
439 MOF_Parser* parser;
440
441 /* Create the parser */
442 krisbash 1.1 const char* paths [] = { "." };
443
444 parser = MOF_Parser_New(paths, sizeof(paths)/sizeof(paths[0]));
445 //MOF_Parser_SetErrorCallback(parser, ErrorCallback, NULL);
446 MOF_Parser_SetWarningCallback(parser, WarningCallback, NULL);
447 MOF_Parser_SetPragmaCallback(parser, PragmaCallback, NULL);
448 MOF_Parser_SetClassDeclCallback(parser, ClassDeclCallback, NULL);
449 MOF_Parser_SetQualifierDeclCallback(parser, QualifierDeclCallback, NULL);
450
451 /* expecting error */
452 int r = MOF_Parser_Parse(parser, "fileThatDoesnotExist.mof");
453
454 MOF_Parser_Delete(parser);
455
456 UT_ASSERT (r != 0);
457 }
458 NitsEndTest
459
460 NitsTestWithSetup(TestParseMofClasses, TestMofSetup)
461 {
462 MOF_Parser* parser;
463 krisbash 1.1
464 /* Create the parser */
465 const char* paths [] = { "." };
466
467 /* Parse the file with extensions enabled */
468
469 parser = MOF_Parser_New(paths, sizeof(paths)/sizeof(paths[0]));
470 MOF_Parser_SetErrorCallback(parser, ErrorCallback, NULL);
471 MOF_Parser_SetWarningCallback(parser, WarningCallback, NULL);
472 MOF_Parser_SetPragmaCallback(parser, PragmaCallback, NULL);
473 MOF_Parser_SetClassDeclCallback(parser, ClassDeclCallback, NULL);
474 MOF_Parser_SetQualifierDeclCallback(parser, QualifierDeclCallback, NULL);
475 MOF_Parser_EnableExtensions(parser, MI_TRUE);
476
477 UT_ASSERT (MOF_Parser_Parse(parser, findMofFile("classes.mof").c_str()) == 0);
478
479 UT_ASSERT( s_results.m_error.empty() );
480
481 /* Delete the parser */
482 MOF_Parser_Delete(parser);
483
484 krisbash 1.1 /* Parse the file with extensions disabled */
485
486 parser = MOF_Parser_New(paths, sizeof(paths)/sizeof(paths[0]));
487 MOF_Parser_SetErrorCallback(parser, ErrorCallback, NULL);
488 MOF_Parser_SetWarningCallback(parser, WarningCallback, NULL);
489 MOF_Parser_SetPragmaCallback(parser, PragmaCallback, NULL);
490 MOF_Parser_SetClassDeclCallback(parser, ClassDeclCallback, NULL);
491 MOF_Parser_SetQualifierDeclCallback(parser, QualifierDeclCallback, NULL);
492 MOF_Parser_EnableExtensions(parser, MI_FALSE);
493
494 UT_ASSERT (MOF_Parser_Parse(parser, findMofFile("classes.mof").c_str()) != 0);
495
496 UT_ASSERT( !s_results.m_error.empty() );
497
498 /* Delete the parser */
499 MOF_Parser_Delete(parser);
500 }
501 NitsEndTest
502
503 static char s_MofString[] =
504 {
505 krisbash 1.1 "Qualifier In : boolean = true, Scope(parameter), Flavor(DisableOverride);\n"
506 "\n"
507 "Qualifier Out : boolean = true, Scope(parameter), Flavor(DisableOverride);\n"
508 "\n"
509 "Qualifier Key : boolean = true, Scope(property, reference), Flavor(DisableOverride);\n"
510 "\n"
511 "Qualifier Static : boolean = true, Scope(method, property), Flavor(DisableOverride);\n"
512 "\n"
513 "class MyClass\n"
514 "{\n"
515 " [Key] MyClass REF Left;\n"
516 " [Key] MyClass REF Right;\n"
517 "};\n"
518 "\n"
519 "class YourClass : MyClass\n"
520 "{\n"
521 " [Key] String MyKey;\n"
522 " String YourProperty;\n"
523 " uint32 AnotherProperty;\n"
524 "\n"
525 " [Static] Uint32 Foo(\n"
526 krisbash 1.1 " [In] String Arg1,\n"
527 " [In, Out] String Arg2,\n"
528 " [In(false), Out] String Arg3);\n"
529 "};\n"
530 "\n"
531 "instance of YourClass as $Y\n"
532 "{\n"
533 " MyKey = \"My Key\";\n"
534 " YourProperty = \"Your Property\";\n"
535 " AnotherProperty = 3;\n"
536 "};\n"
537 };
538
539 NitsTestWithSetup(TestParseMofString, TestMofSetup)
540 {
541 MOF_Parser* parser;
542
543 /* Create the parser */
544 const char* paths [] = { "." };
545
546 /* Parse the file with extensions disabled */
547 krisbash 1.1
548 parser = MOF_Parser_New(paths, sizeof(paths)/sizeof(paths[0]));
549 MOF_Parser_SetErrorCallback(parser, ErrorCallback, NULL);
550 MOF_Parser_SetWarningCallback(parser, WarningCallback, NULL);
551 MOF_Parser_SetPragmaCallback(parser, PragmaCallback, NULL);
552 MOF_Parser_SetClassDeclCallback(parser, ClassDeclCallback, NULL);
553 MOF_Parser_SetQualifierDeclCallback(parser, QualifierDeclCallback, NULL);
554 MOF_Parser_EnableExtensions(parser, MI_FALSE);
555
556 UT_ASSERT (MOF_Parser_ParseString(parser, s_MofString) != 0);
557
558 UT_ASSERT( !s_results.m_error.empty() );
559
560 /* Delete the parser */
561 MOF_Parser_Delete(parser);
562 }
563 NitsEndTest
564
565 NitsTestWithSetup(TestAllTypesOfQualifiers, TestMofSetup)
566 {
567 MOF_Parser* parser;
568 krisbash 1.1
569 /* Create the parser */
570 const char* paths [] = {"."};
571
572 parser = MOF_Parser_New(paths, sizeof(paths)/sizeof(paths[0]));
573 MOF_Parser_SetErrorCallback(parser, ErrorCallback, NULL);
574 MOF_Parser_SetWarningCallback(parser, WarningCallback, NULL);
575 MOF_Parser_SetPragmaCallback(parser, PragmaCallback, NULL);
576 MOF_Parser_SetClassDeclCallback(parser, ClassDeclCallback_Q, NULL);
577 MOF_Parser_SetQualifierDeclCallback(parser, QualifierDeclCallback, NULL);
578
579 /* Parse the file */
580 UT_ASSERT (MOF_Parser_Parse(parser, findMofFile("quals.mof").c_str()) == 0);
581
582 /* Delete the parser */
583 MOF_Parser_Delete(parser);
584
585 UT_ASSERT( s_results.m_error.empty() );
586 }
587 NitsEndTest
588
589 krisbash 1.1 NitsTestWithSetup(TestDumpFunction, TestMofSetup)
590 {
591 MOF_Parser* parser;
592
593 parser = MOF_Parser_New(0,0);
594 MOF_Parser_SetErrorCallback(parser, ErrorCallback, NULL);
595 MOF_Parser_SetWarningCallback(parser, WarningCallback, NULL);
596 MOF_Parser_SetPragmaCallback(parser, PragmaCallback, NULL);
597 MOF_Parser_SetClassDeclCallback(parser, ClassDeclCallback, NULL);
598 MOF_Parser_SetQualifierDeclCallback(parser, QualifierDeclCallback, NULL);
599 MOF_Parser_EnableExtensions(parser, MI_TRUE);
600
601 /* Parse the file */
602 UT_ASSERT (MOF_Parser_Parse(parser, findMofFile("classes.mof").c_str()) == 0);
603
604 /* Dump */
605 FILE* f_null = File_Open(NULL_FILE,"a");
606
607 fprintf(f_null, "test out\n");
608 MOF_Parser_Dump(parser, f_null);
609 fclose(f_null);
610 krisbash 1.1
611 // if you want to see the output, un-comment next line
612 // MOF_Parser_Dump(parser, stdout);
613
614 /* Delete the parser */
615 MOF_Parser_Delete(parser);
616
617 UT_ASSERT( s_results.m_error.empty() );
618 }
619 NitsEndTest
620
621 static void ParseContentExpectToFail( const char* content, bool ignore_callbacks = true, bool use_quiet_callback = true )
622 {
623 ut::writeFileContent(TEMP_FILE,
624 vector<unsigned char>( reinterpret_cast<const unsigned char*>(content),
625 reinterpret_cast<const unsigned char*>(content)+strlen(content)));
626
627 UT_ASSERT( 0 != ParseFile(TEMP_FILE, ignore_callbacks, use_quiet_callback) );
628
629 // expect errors
630 UT_ASSERT( !s_results.m_error.empty() );
631 krisbash 1.1 }
632
633 static void ParseContentExpectToSucceed( const char* content, bool ignore_callbacks = false, bool use_quiet_callback = false )
634 {
635 ut::writeFileContent( TEMP_FILE, vector<unsigned char>( reinterpret_cast<const unsigned char*>(content),
636 reinterpret_cast<const unsigned char*>(content)+strlen(content)));
637
638 UT_ASSERT( 0 == ParseFile(TEMP_FILE, ignore_callbacks, use_quiet_callback) );
639
640 // expect no errors
641 UT_ASSERT( s_results.m_error.empty() );
642 }
643
644 static void AddQualifiersParseContentExpectToFail(const char* content, bool ignore_callbacks = true, bool use_quiet_callback = true )
645 {
646 #if defined(_MSC_VER)
647 string data = "\
648 #pragma include (\"../../share/omischema/" CONFIG_CIMSCHEMA "/qualifiers.mof\")\n\
649 #pragma include (\"../../share/omischema/" CONFIG_CIMSCHEMA "/qualifiers_optional.mof\")\n\
650 ";
651 #else
652 krisbash 1.1 string data = "\
653 #pragma include (\"./share/omischema/" CONFIG_CIMSCHEMA "/qualifiers.mof\")\n\
654 #pragma include (\"./share/omischema/" CONFIG_CIMSCHEMA "/qualifiers_optional.mof\")\n\
655 ";
656 #endif
657
658 data += content;
659
660 ParseContentExpectToFail(data.c_str(), ignore_callbacks, use_quiet_callback);
661 }
662
663 static void AddQualifiersParseContentExpectToSucceed(const char* content, bool ignore_callbacks = false, bool use_quiet_callback = false)
664 {
665 #if defined(_MSC_VER)
666 string data = "\
667 #pragma include (\"../../share/omischema/" CONFIG_CIMSCHEMA "/qualifiers.mof\")\n\
668 #pragma include (\"../../share/omischema/" CONFIG_CIMSCHEMA "/qualifiers_optional.mof\")\n\
669 ";
670 #else
671 string data = "\
672 #pragma include (\"./share/omischema/" CONFIG_CIMSCHEMA "/qualifiers.mof\")\n\
673 krisbash 1.1 #pragma include (\"./share/omischema/" CONFIG_CIMSCHEMA "/qualifiers_optional.mof\")\n\
674 ";
675 #endif
676
677 data += content;
678
679 ParseContentExpectToSucceed(data.c_str(), ignore_callbacks, use_quiet_callback);
680 }
681
682
683 NitsTestWithSetup(TestValidDateString, TestMofSetup)
684 {
685 // create a mof file with valid date-time quilifier
686 const char content [] =
687 "Qualifier DatetimeQ : Datetime = \"20091225123000.123456-360\", Scope(any), Flavor(DisableOverride);\n\
688 [DatetimeQ(\"12345678121212.123456:000\")] \n\
689 class X \n\
690 {\n\
691 };\n";
692
693
694 krisbash 1.1 ParseContentExpectToSucceed(content);
695 }
696 NitsEndTest
697
698
699 NitsTestWithSetup(TestInvalidDateShortString, TestMofSetup)
700 {
701 // create a mof file with invalid date-time quilifier
702 const char content [] =
703 "Qualifier DatetimeQ : Datetime = \"20091225123000.123456-36\", Scope(any), Flavor(DisableOverride);";
704
705 ParseContentExpectToFail(content);
706 }
707 NitsEndTest
708
709
710 NitsTestWithSetup(TestInvalidDateInvalidString, TestMofSetup)
711 {
712 // create a mof file with invalid date-time quilifier
713 const char content [] = "Qualifier DatetimeQ : Datetime = \"xxx\", Scope(any), Flavor(DisableOverride);";
714
715 krisbash 1.1 ParseContentExpectToFail(content);
716 }
717 NitsEndTest
718
719
720 NitsTestWithSetup(TestInvalidYear, TestMofSetup)
721 {
722 // create a mof file with invalid date-time quilifier
723 const char content [] = "Qualifier DatetimeQ : Datetime = \"y0091225123000.123456-360\", Scope(any), Flavor(DisableOverride);";
724
725 ParseContentExpectToFail(content);
726 }
727 NitsEndTest
728
729
730 NitsTestWithSetup(TestInvalidMonth, TestMofSetup)
731 {
732 // create a mof file with invalid date-time quilifier
733 const char content [] = "Qualifier DatetimeQ : Datetime = \"20091x25123000.123456-360\", Scope(any), Flavor(DisableOverride);";
734
735 ParseContentExpectToFail(content);
736 krisbash 1.1 }
737 NitsEndTest
738
739
740 NitsTestWithSetup(TestInvalidDay, TestMofSetup)
741 {
742 // create a mof file with invalid date-time quilifier
743 const char content [] = "Qualifier DatetimeQ : Datetime = \"2009112z123000.123456-360\", Scope(any), Flavor(DisableOverride);";
744
745 ParseContentExpectToFail(content);
746 }
747 NitsEndTest
748
749
750 NitsTestWithSetup(TestInvalidHour, TestMofSetup)
751 {
752 // create a mof file with invalid date-time quilifier
753 const char content [] = "Qualifier DatetimeQ : Datetime = \"20091121v23000.123456-360\", Scope(any), Flavor(DisableOverride);";
754
755 ParseContentExpectToFail(content);
756 }
757 krisbash 1.1 NitsEndTest
758
759
760 NitsTestWithSetup(TestInvalidMin, TestMofSetup)
761 {
762 // create a mof file with invalid date-time quilifier
763 const char content [] = "Qualifier DatetimeQ : Datetime = \"20091121v23000112hh56-360\", Scope(any), Flavor(DisableOverride);";
764
765 ParseContentExpectToFail(content);
766 }
767 NitsEndTest
768
769
770 NitsTestWithSetup(TestInvalidSec, TestMofSetup)
771 {
772 // create a mof file with invalid date-time quilifier
773 const char content [] = "Qualifier DatetimeQ : Datetime = \"20091121v2300011256ss-360\", Scope(any), Flavor(DisableOverride);";
774
775 ParseContentExpectToFail(content);
776 }
777 NitsEndTest
778 krisbash 1.1
779
780 NitsTestWithSetup(TestInvalidDateFormat2, TestMofSetup)
781 {
782 // create a mof file with invalid date-time quilifier
783 const char content [] = "Qualifier DatetimeQ : Datetime = \"12345?78121212.123456:000\", Scope(any), Flavor(DisableOverride);";
784
785 ParseContentExpectToFail(content);
786 }
787 NitsEndTest
788
789
790 NitsTestWithSetup(TestInvalidTimeFormat2, TestMofSetup)
791 {
792 //hh
793 ParseContentExpectToFail(
794 "Qualifier DatetimeQ : Datetime = \"123456781g1212.123456:000\", Scope(any), Flavor(DisableOverride);");
795 //mm
796 ParseContentExpectToFail(
797 "Qualifier DatetimeQ : Datetime = \"1234567812i212.123456:000\", Scope(any), Flavor(DisableOverride);");
798 //ss
799 krisbash 1.1 ParseContentExpectToFail(
800 "Qualifier DatetimeQ : Datetime = \"123456781212--.123456:000\", Scope(any), Flavor(DisableOverride);");
801
802 //MMMMMM
803 ParseContentExpectToFail(
804 "Qualifier DatetimeQ : Datetime = \"12345678121212.1!3456:000\", Scope(any), Flavor(DisableOverride);");
805 ParseContentExpectToFail(
806 "Qualifier DatetimeQ : Datetime = \"12345678121212.12.456:000\", Scope(any), Flavor(DisableOverride);");
807 ParseContentExpectToFail(
808 "Qualifier DatetimeQ : Datetime = \"12345678121212.1234--:000\", Scope(any), Flavor(DisableOverride);");
809
810 // .MM
811 ParseContentExpectToFail(
812 "Qualifier DatetimeQ : Datetime = \"12345678121212!123456:000\", Scope(any), Flavor(DisableOverride);");
813
814 // :000
815 ParseContentExpectToFail(
816 "Qualifier DatetimeQ : Datetime = \"12345678121212.123456:x00\", Scope(any), Flavor(DisableOverride);");
817 ParseContentExpectToFail(
818 "Qualifier DatetimeQ : Datetime = \"12345678121212.123456:0x0\", Scope(any), Flavor(DisableOverride);");
819 ParseContentExpectToFail(
820 krisbash 1.1 "Qualifier DatetimeQ : Datetime = \"12345678121212.123456:00x\", Scope(any), Flavor(DisableOverride);");
821
822 }
823 NitsEndTest
824
825
826
827 NitsTestWithSetup(TestInvalidDateTimeArray, TestMofSetup)
828 {
829 // create a mof file with invalid date-time quilifier
830 const char content [] = "Qualifier DatetimeQA : Datetime[] = { \"xxx1225123000.123456-360\" } , Scope(any), Flavor(DisableOverride);";
831
832 ParseContentExpectToFail(content);
833 }
834 NitsEndTest
835
836
837 NitsTestWithSetup(TestInvalidDateTimeLongArray, TestMofSetup)
838 {
839 // create a mof file with invalid date-time quilifier
840 const char content [] = "Qualifier DatetimeQA : Datetime[] = { \"20091225123000.123456-360\", \"20091225123000.123456-360\", \"20091225123000.123456-360\",\"xxx\" } , Scope(any), Flavor(DisableOverride);";
841 krisbash 1.1
842 ParseContentExpectToFail(content);
843 }
844 NitsEndTest
845
846
847 NitsTestWithSetup(TestSyntaxErrorThatCausedHanging, TestMofSetup)
848 {
849 // this specific file caused hanging initially and added for regression purposes
850 UT_ASSERT( 0 != ParseFile(findMofFile("syntaxerror.mof").c_str(), false, true) );
851
852 // expect errors
853 UT_ASSERT( !s_results.m_error.empty() );
854 }
855 NitsEndTest
856
857
858 NitsTestWithSetup(TestParseMofWithInclude, TestMofSetup)
859 {
860 // check 'pragma include' works
861 string content = "#pragma include(\"";
862 krisbash 1.1
863 content += findMofFile("quals.mof") + "\")";
864
865 ParseContentExpectToSucceed(content.c_str(), false);
866 }
867 NitsEndTest
868
869
870 NitsTestWithSetup(TestMinValueIncompatibleType, TestMofSetup)
871 {
872 AddQualifiersParseContentExpectToFail(
873 "class T { [MinValue(1234)]ut::String s = \"123\"; /* incompatible type */ };" );
874 }
875 NitsEndTest
876
877
878 NitsTestWithSetup(TestMinValueU8, TestMofSetup)
879 {
880 AddQualifiersParseContentExpectToSucceed(
881 "class T { [MinValue(14)]Uint8 x = 15; /* ok */};", true);
882 AddQualifiersParseContentExpectToSucceed(
883 krisbash 1.1 "class T { [MinValue(255)]Uint8 x = 255; /* ok */};", true);
884 }
885 NitsEndTest
886
887
888 NitsTestWithSetup(TestInvalidMinValueU8, TestMofSetup)
889 {
890 AddQualifiersParseContentExpectToFail(
891 "class T { [MinValue(1234)]Uint8 x = 0; /* overflow */ };" );
892 AddQualifiersParseContentExpectToFail(
893 "class T { [MinValue(1234)]Uint8 x = 256; /* overflow */ };" );
894 AddQualifiersParseContentExpectToFail(
895 "class T { [MinValue(1)]Uint8 x = 0; /* value too small */ };" );
896 AddQualifiersParseContentExpectToFail(
897 "class T { [MinValue(1)]Uint8 x = -1; /* underflow */ };" );
898 }
899 NitsEndTest
900
901
902 NitsTestWithSetup(TestMinValueU16, TestMofSetup)
903 {
904 krisbash 1.1 AddQualifiersParseContentExpectToSucceed(
905 "class T { [MinValue(1000)]Uint16 x = 1000; /* ok */};", true);
906 AddQualifiersParseContentExpectToSucceed(
907 "class T { [MinValue(65535)]Uint16 x = 65535; /* ok */};", true);
908 }
909 NitsEndTest
910
911
912 NitsTestWithSetup(TestInvalidMinValueU16, TestMofSetup)
913 {
914 // u16 range is 0-65535
915 AddQualifiersParseContentExpectToFail(
916 "class T { [MinValue(65536)]Uint16 x = 0; /* overflow */ };" );
917 AddQualifiersParseContentExpectToFail(
918 "class T { [MinValue(0)]Uint16 x = 65536; /* overflow */ };" );
919 AddQualifiersParseContentExpectToFail(
920 "class T { [MinValue(1)]Uint16 x = 0; /* value too small */ };" );
921 AddQualifiersParseContentExpectToFail(
922 "class T { [MinValue(1)]Uint16 x = -1; /* underflow */ };" );
923 }
924 NitsEndTest
925 krisbash 1.1
926
927 NitsTestWithSetup(TestMinValueU32, TestMofSetup)
928 {
929 AddQualifiersParseContentExpectToSucceed(
930 "class T { [MinValue(999)]Uint32 x = 1000; /* ok */};", true);
931 AddQualifiersParseContentExpectToSucceed(
932 "class T { [MinValue(4294967295)]Uint32 x = 4294967295; /* ok */};", true);
933 }
934 NitsEndTest
935
936
937 NitsTestWithSetup(TestInvalidMinValueU32, TestMofSetup)
938 {
939 // u32 range is 0-4294967295
940 AddQualifiersParseContentExpectToFail(
941 "class T { [MinValue(4294967296)]Uint32 x = 0; /* overflow */ };" );
942 AddQualifiersParseContentExpectToFail(
943 "class T { [MinValue(0)]Uint32 x = 4294967296; /* overflow */ };" );
944 AddQualifiersParseContentExpectToFail(
945 "class T { [MinValue(1)]Uint32 x = 0; /* value too small */ };" );
946 krisbash 1.1 AddQualifiersParseContentExpectToFail(
947 "class T { [MinValue(1)]Uint32 x = -1; /* underflow */ };" );
948 }
949 NitsEndTest
950
951
952 NitsTestWithSetup(TestMinValueU64, TestMofSetup)
953 {
954 AddQualifiersParseContentExpectToSucceed(
955 "class T { [MinValue(999)]Uint64 x = 1000; /* ok */};", true);
956 AddQualifiersParseContentExpectToSucceed(
957 "class T { [MinValue(9223372036854775807)]Uint64 x = 9223372036854775807; /* ok */};", true);
958 #if 0
959 //ATTN: values greater than sint64_max are not supported
960 AddQualifiersParseContentExpectToSucceed(
961 "class T { Uint64 x = 18446744073709551615; /* ok */};", true);
962 AddQualifiersParseContentExpectToSucceed(
963 "class T { [MinValue(NULL)]Uint64 x = 18446744073709551615; /* ok */};", true);
964 #endif
965 }
966 NitsEndTest
967 krisbash 1.1
968
969 NitsTestWithSetup(TestInvalidMinValueU64, TestMofSetup)
970 {
971 // u64 range is 0-18446744073709551615
972 // practically, attributes are limitted by sint64:
973 // -9223372036854775807 - 1 - 9223372036854775807
974 // however, MinValue is Sint64, so real max for Min value is 9223372036854775807
975
976 //ATTN: values greater than sint64_max are not supported
977 //AddQualifiersParseContentExpectToFail(
978 // "class T { [MinValue(18446744073709551616)]Uint64 x = 0; /* overflow */ };" );
979 //AddQualifiersParseContentExpectToFail(
980 // "class T { [MinValue(0)]Uint64 x = 18446744073709551616; /* overflow */ };" );
981
982 AddQualifiersParseContentExpectToFail(
983 "class T { [MinValue(1)]Uint64 x = 0; /* value too small */ };" );
984 AddQualifiersParseContentExpectToFail(
985 "class T { [MinValue(1)]Uint64 x = -1; /* underflow */ };" );
986 }
987 NitsEndTest
988 krisbash 1.1
989
990 NitsTestWithSetup(TestMinValueS8, TestMofSetup)
991 {
992 AddQualifiersParseContentExpectToSucceed(
993 "class T { [MinValue(14)]Sint8 x = 15; /* ok */};", true);
994 AddQualifiersParseContentExpectToSucceed(
995 "class T { [MinValue(-128)]Sint8 x = -128; /* ok */};", true);
996 AddQualifiersParseContentExpectToSucceed(
997 "class T { [MinValue(127)]Sint8 x = 127; /* ok */};", true);
998 }
999 NitsEndTest
1000
1001
1002 NitsTestWithSetup(TestInvalidMinValueS8, TestMofSetup)
1003 {
1004 AddQualifiersParseContentExpectToFail(
1005 "class T { [MinValue(1234)]Sint8 x = 0; /* overflow */ };" );
1006 AddQualifiersParseContentExpectToFail(
1007 "class T { [MinValue(1234)]Sint8 x = 256; /* overflow */ };" );
1008 AddQualifiersParseContentExpectToFail(
1009 krisbash 1.1 "class T { [MinValue(1)]Sint8 x = 0; /* value too small */ };" );
1010 AddQualifiersParseContentExpectToFail(
1011 "class T { [MinValue(-11)]Sint8 x = -12; /* value too small */ };" );
1012 AddQualifiersParseContentExpectToFail(
1013 "class T { [MinValue(1)]Sint8 x = -129; /* underflow */ };" );
1014 }
1015 NitsEndTest
1016
1017
1018 NitsTestWithSetup(TestMinValueS16, TestMofSetup)
1019 {
1020 AddQualifiersParseContentExpectToSucceed(
1021 "class T { [MinValue(1000)]Sint16 x = 1000; /* ok */};", true);
1022 AddQualifiersParseContentExpectToSucceed(
1023 "class T { [MinValue(32767)]Sint16 x = 32767; /* ok */};", true);
1024 AddQualifiersParseContentExpectToSucceed(
1025 "class T { [MinValue(-32768)]Sint16 x = -32768; /* ok */};", true);
1026 AddQualifiersParseContentExpectToSucceed(
1027 "class T { [MinValue(null)]Sint16 x = -32768; /* ok */};", true);
1028 }
1029 NitsEndTest
1030 krisbash 1.1
1031
1032 NitsTestWithSetup(TestInvalidMinValueS16, TestMofSetup)
1033 {
1034 // s16 range is -32768 - 32767
1035 AddQualifiersParseContentExpectToFail(
1036 "class T { [MinValue(32768)]Sint16 x = 0; /* overflow */ };" );
1037 AddQualifiersParseContentExpectToFail(
1038 "class T { [MinValue(0)]Sint16 x = 32768; /* overflow */ };" );
1039 AddQualifiersParseContentExpectToFail(
1040 "class T { [MinValue(1)]Sint16 x = 0; /* value too small */ };" );
1041 AddQualifiersParseContentExpectToFail(
1042 "class T { [MinValue(1)]Sint16 x = -32769; /* underflow */ };" );
1043 AddQualifiersParseContentExpectToFail(
1044 "class T { Sint16 x = -32769; /* underflow */ };" );
1045 }
1046 NitsEndTest
1047
1048
1049 NitsTestWithSetup(TestMinValueS32, TestMofSetup)
1050 {
1051 krisbash 1.1 AddQualifiersParseContentExpectToSucceed(
1052 "class T { [MinValue(999)]Sint32 x = 1000; /* ok */};", true);
1053 AddQualifiersParseContentExpectToSucceed(
1054 "class T { [MinValue(-2147483648)]Sint32 x = -2147483648; /* ok */};", true);
1055 AddQualifiersParseContentExpectToSucceed(
1056 "class T { [MinValue(-2147483648)]Sint32 x = -2147483647; /* ok */};", true);
1057 AddQualifiersParseContentExpectToSucceed(
1058 "class T { [MinValue(2147483647)]Sint32 x = 2147483647; /* ok */};", true);
1059 }
1060 NitsEndTest
1061
1062
1063 NitsTestWithSetup(TestInvalidMinValueS32, TestMofSetup)
1064 {
1065 // s32 range is -2147483648 - 2147483647
1066 AddQualifiersParseContentExpectToFail(
1067 "class T { [MinValue(2147483648)]Sint32 x = 0; /* overflow */ };" );
1068 AddQualifiersParseContentExpectToFail(
1069 "class T { [MinValue(0)]Sint32 x = 2147483648; /* overflow */ };" );
1070 AddQualifiersParseContentExpectToFail(
1071 "class T { [MinValue(1)]Sint32 x = 0; /* value too small */ };" );
1072 krisbash 1.1 AddQualifiersParseContentExpectToFail(
1073 "class T { Sint32 x = -2147483649; /* underflow */ };" );
1074 }
1075 NitsEndTest
1076
1077
1078 NitsTestWithSetup(TestMinValueS64, TestMofSetup)
1079 {
1080 AddQualifiersParseContentExpectToSucceed(
1081 "class T { [MinValue(999)]Sint64 x = 1000; /* ok */};", true);
1082 AddQualifiersParseContentExpectToSucceed(
1083 "class T { [MinValue(9223372036854775807)]Sint64 x = 9223372036854775807; /* ok */};", true);
1084 AddQualifiersParseContentExpectToSucceed(
1085 "class T { [MinValue(-9223372036854775808)]Sint64 x = -9223372036854775808; /* ok */};", true);
1086 AddQualifiersParseContentExpectToSucceed(
1087 "class T { [MinValue(-9223372036854775808)]Sint64 x = -9223372036854775807; /* ok */};", true);
1088 }
1089 NitsEndTest
1090
1091
1092 NitsTestWithSetup(TestInvalidMinValueS64, TestMofSetup)
1093 krisbash 1.1 {
1094 // u64 range is 0-18446744073709551615
1095 // practically, attributes are limitted by sint64:
1096 // -9223372036854775807 - 1 - 9223372036854775807
1097 //ATTN! int64 errors are not processed correctly yet
1098 #if 0
1099 AddQualifiersParseContentExpectToFail(
1100 "class T { [MinValue(9223372036854775808)]Sint64 x = 0; /* overflow */ };" );
1101 AddQualifiersParseContentExpectToFail(
1102 "class T { [MinValue(0)]Sint64 x = 9223372036854775808; /* overflow */ };" );
1103 AddQualifiersParseContentExpectToFail(
1104 "class T { Sint64 x = -9223372036854775809; /* underflow */ };" );
1105 #endif
1106 AddQualifiersParseContentExpectToFail(
1107 "class T { [MinValue(1)]Sint64 x = 0; /* value too small */ };" );
1108 }
1109 NitsEndTest
1110
1111
1112 NitsTestWithSetup(TestMinValueR32, TestMofSetup)
1113 {
1114 krisbash 1.1 AddQualifiersParseContentExpectToSucceed(
1115 "class T { [MinValue(999)]Real32 x = 999.1; /* ok */};", true);
1116 AddQualifiersParseContentExpectToSucceed(
1117 "class T { [MinValue(0)]Real32 x = 0.1e+0; /* ok */};", true);
1118 AddQualifiersParseContentExpectToSucceed(
1119 "class T { [MinValue(9223372036854775807)]Real32 x = 9.3e+18; /* ok */};", true);
1120 AddQualifiersParseContentExpectToSucceed(
1121 "class T { [MinValue(-9223372036854775808)]Real32 x = -9.22e18; /* ok */};", true);
1122 }
1123 NitsEndTest
1124
1125
1126 NitsTestWithSetup(TestInvalidMinValueR32, TestMofSetup)
1127 {
1128 AddQualifiersParseContentExpectToFail(
1129 "class T { [MinValue(999)]Real32 x = 998.1; /* too small */};");
1130 AddQualifiersParseContentExpectToFail(
1131 "class T { [MinValue(0)]Real32 x = -0.1e+0; /* too small */};");
1132 AddQualifiersParseContentExpectToFail(
1133 "class T { [MinValue(9223372036854775807)]Real32 x = 9.2e18; /* too small */};");
1134 AddQualifiersParseContentExpectToFail(
1135 krisbash 1.1 "class T { [MinValue(-9223372036854775808)]Real32 x = -9.23e18; /* too small */};");
1136 }
1137 NitsEndTest
1138
1139
1140 NitsTestWithSetup(TestMinValueR64, TestMofSetup)
1141 {
1142 AddQualifiersParseContentExpectToSucceed(
1143 "class T { [MinValue(999)]Real64 x = 999.1; /* ok */};", true);
1144 AddQualifiersParseContentExpectToSucceed(
1145 "class T { [MinValue(0)]Real64 x = 0.1e+0; /* ok */};", true);
1146 AddQualifiersParseContentExpectToSucceed(
1147 "class T { [MinValue(9223372036854775807)]Real64 x = 9.3e+18; /* ok */};", true);
1148 AddQualifiersParseContentExpectToSucceed(
1149 "class T { [MinValue(-9223372036854775808)]Real64 x = -9.22e18; /* ok */};", true);
1150 }
1151 NitsEndTest
1152
1153
1154 NitsTestWithSetup(TestInvalidMinValueR64, TestMofSetup)
1155 {
1156 krisbash 1.1 AddQualifiersParseContentExpectToFail(
1157 "class T { [MinValue(999)]Real64 x = 998.1; /* too small */};");
1158 AddQualifiersParseContentExpectToFail(
1159 "class T { [MinValue(0)]Real64 x = -0.1e+0; /* too small */};");
1160 AddQualifiersParseContentExpectToFail(
1161 "class T { [MinValue(9223372036854775807)]Real64 x = 9.2e18; /* too small */};");
1162 AddQualifiersParseContentExpectToFail(
1163 "class T { [MinValue(-9223372036854775808)]Real64 x = -9.23e18; /* too small */};");
1164 }
1165 NitsEndTest
1166
1167
1168 NitsTestWithSetup(TestMaxValueIncompatibleType, TestMofSetup)
1169 {
1170 AddQualifiersParseContentExpectToFail(
1171 "class T { [MaxValue(1234)]ut::String s = \"123\"; /* incompatible type */ };" );
1172 }
1173 NitsEndTest
1174
1175
1176
1177 krisbash 1.1 NitsTestWithSetup(TestMaxValueU8, TestMofSetup)
1178 {
1179 AddQualifiersParseContentExpectToSucceed(
1180 "class T { [MaxValue(14)]Uint8 x = 13; /* ok */};", true);
1181 AddQualifiersParseContentExpectToSucceed(
1182 "class T { [MaxValue(255)]Uint8 x = 255; /* ok */};", true);
1183 }
1184 NitsEndTest
1185
1186
1187 NitsTestWithSetup(TestInvalidMaxValueU8, TestMofSetup)
1188 {
1189 AddQualifiersParseContentExpectToFail(
1190 "class T { [MaxValue(-1)]Uint8 x = 0; /* overflow */ };" );
1191 AddQualifiersParseContentExpectToFail(
1192 "class T { [MaxValue(1234)]Uint8 x = 256; /* overflow */ };" );
1193 AddQualifiersParseContentExpectToFail(
1194 "class T { [MaxValue(1)]Uint8 x = 10; /* value too large */ };" );
1195 AddQualifiersParseContentExpectToFail(
1196 "class T { [MaxValue(1)]Uint8 x = -1; /* underflow */ };" );
1197 }
1198 krisbash 1.1 NitsEndTest
1199
1200
1201 NitsTestWithSetup(TestMaxValueU16, TestMofSetup)
1202 {
1203 AddQualifiersParseContentExpectToSucceed(
1204 "class T { [MaxValue(1000)]Uint16 x = 1000; /* ok */};", true);
1205 AddQualifiersParseContentExpectToSucceed(
1206 "class T { [MaxValue(65535)]Uint16 x = 65535; /* ok */};", true);
1207 }
1208 NitsEndTest
1209
1210
1211 NitsTestWithSetup(TestInvalidMaxValueU16, TestMofSetup)
1212 {
1213 // u16 range is 0-65535
1214 AddQualifiersParseContentExpectToFail(
1215 "class T { [MaxValue(65536)]Uint16 x = 65536; /* overflow */ };" );
1216 AddQualifiersParseContentExpectToFail(
1217 "class T { [MaxValue(0)]Uint16 x = 65536; /* overflow */ };" );
1218 AddQualifiersParseContentExpectToFail(
1219 krisbash 1.1 "class T { [MaxValue(1)]Uint16 x = 2; /* value too large */ };" );
1220 AddQualifiersParseContentExpectToFail(
1221 "class T { [MaxValue(1)]Uint16 x = -1; /* underflow */ };" );
1222 }
1223 NitsEndTest
1224
1225
1226 NitsTestWithSetup(TestMaxValueU32, TestMofSetup)
1227 {
1228 AddQualifiersParseContentExpectToSucceed(
1229 "class T { [MaxValue(999)]Uint32 x = 998; /* ok */};", true);
1230 AddQualifiersParseContentExpectToSucceed(
1231 "class T { [MaxValue(4294967295)]Uint32 x = 4294967295; /* ok */};", true);
1232 }
1233 NitsEndTest
1234
1235
1236 NitsTestWithSetup(TestInvalidMaxValueU32, TestMofSetup)
1237 {
1238 // u32 range is 0-4294967295
1239 AddQualifiersParseContentExpectToFail(
1240 krisbash 1.1 "class T { [MaxValue(4294967296)]Uint32 x = 4294967296; /* overflow */ };" );
1241 AddQualifiersParseContentExpectToFail(
1242 "class T { [MaxValue(0)]Uint32 x = 4294967296; /* overflow */ };" );
1243 AddQualifiersParseContentExpectToFail(
1244 "class T { [MaxValue(1)]Uint32 x = 100; /* value too large */ };" );
1245 AddQualifiersParseContentExpectToFail(
1246 "class T { [MaxValue(1)]Uint32 x = -1; /* underflow */ };" );
1247 }
1248 NitsEndTest
1249
1250
1251 NitsTestWithSetup(TestMaxValueU64, TestMofSetup)
1252 {
1253 AddQualifiersParseContentExpectToSucceed(
1254 "class T { [MaxValue(999)]Uint64 x = 997; /* ok */};", true);
1255 AddQualifiersParseContentExpectToSucceed(
1256 "class T { [MaxValue(9223372036854775807)]Uint64 x = 9223372036854775807; /* ok */};", true);
1257 #if 0
1258 //ATTN: values greater than sint64_max are not supported
1259 AddQualifiersParseContentExpectToSucceed(
1260 "class T { Uint64 x = 18446744073709551615; /* ok */};", true);
1261 krisbash 1.1 AddQualifiersParseContentExpectToSucceed(
1262 "class T { [MaxValue(NULL)]Uint64 x = 18446744073709551615; /* ok */};", true);
1263 #endif
1264 }
1265 NitsEndTest
1266
1267
1268 NitsTestWithSetup(TestInvalidMaxValueU64, TestMofSetup)
1269 {
1270 // u64 range is 0-18446744073709551615
1271 // practically, attributes are limitted by sint64:
1272 // -9223372036854775807 - 1 - 9223372036854775807
1273 // however, MaxValue is Sint64, so real max for Max value is 9223372036854775807
1274
1275 //ATTN: values greater than sint64_max are not supported
1276 //AddQualifiersParseContentExpectToFail(
1277 // "class T { [MaxValue(18446744073709551616)]Uint64 x = 0; /* overflow */ };" );
1278 AddQualifiersParseContentExpectToFail(
1279 "class T { [MaxValue(0)]Uint64 x = 18446744073709551616; /* overflow */ };" );
1280
1281 AddQualifiersParseContentExpectToFail(
1282 krisbash 1.1 "class T { [MaxValue(1)]Uint64 x = 10; /* value too large */ };" );
1283 // ATTN:
1284 // next line is waiting for some bigger then 64-bit integer
1285 // internal representaitons of integers in the parser
1286 AddQualifiersParseContentExpectToFail(
1287 "class T { [MaxValue(1)]Uint64 x = -1; /* underflow */ };" );
1288 }
1289 NitsEndTest
1290
1291
1292 NitsTestWithSetup(TestMaxValueS8, TestMofSetup)
1293 {
1294 AddQualifiersParseContentExpectToSucceed(
1295 "class T { [MaxValue(14)]Sint8 x = 13; /* ok */};", true);
1296 AddQualifiersParseContentExpectToSucceed(
1297 "class T { [MaxValue(-128)]Sint8 x = -128; /* ok */};", true);
1298 AddQualifiersParseContentExpectToSucceed(
1299 "class T { [MaxValue(127)]Sint8 x = 127; /* ok */};", true);
1300 }
1301 NitsEndTest
1302
1303 krisbash 1.1
1304 NitsTestWithSetup(TestInvalidMaxValueS8, TestMofSetup)
1305 {
1306 AddQualifiersParseContentExpectToFail(
1307 "class T { [MaxValue(1234)]Sint8 x = 1234; /* overflow */ };" );
1308 AddQualifiersParseContentExpectToFail(
1309 "class T { [MaxValue(1234)]Sint8 x = 256; /* overflow */ };" );
1310 AddQualifiersParseContentExpectToFail(
1311 "class T { [MaxValue(1)]Sint8 x = 2; /* value too large */ };" );
1312 AddQualifiersParseContentExpectToFail(
1313 "class T { [MaxValue(-11)]Sint8 x = -10; /* value too large */ };" );
1314 AddQualifiersParseContentExpectToFail(
1315 "class T { [MaxValue(1)]Sint8 x = -129; /* underflow */ };" );
1316 }
1317 NitsEndTest
1318
1319
1320 NitsTestWithSetup(TestMaxValueS16, TestMofSetup)
1321 {
1322 AddQualifiersParseContentExpectToSucceed(
1323 "class T { [MaxValue(1000)]Sint16 x = 0; /* ok */};", true);
1324 krisbash 1.1 AddQualifiersParseContentExpectToSucceed(
1325 "class T { [MaxValue(32767)]Sint16 x = 32767; /* ok */};", true);
1326 AddQualifiersParseContentExpectToSucceed(
1327 "class T { [MaxValue(-32768)]Sint16 x = -32768; /* ok */};", true);
1328 AddQualifiersParseContentExpectToSucceed(
1329 "class T { [MaxValue(null)]Sint16 x = -32768; /* ok */};", true);
1330 }
1331 NitsEndTest
1332
1333
1334 NitsTestWithSetup(TestInvalidMaxValueS16, TestMofSetup)
1335 {
1336 // s16 range is -32768 - 32767
1337 AddQualifiersParseContentExpectToFail(
1338 "class T { [MaxValue(32768)]Sint16 x = 32768; /* overflow */ };" );
1339 AddQualifiersParseContentExpectToFail(
1340 "class T { [MaxValue(0)]Sint16 x = 32768; /* overflow */ };" );
1341 AddQualifiersParseContentExpectToFail(
1342 "class T { [MaxValue(1)]Sint16 x = 2; /* value too large */ };" );
1343 AddQualifiersParseContentExpectToFail(
1344 "class T { [MaxValue(1)]Sint16 x = -32769; /* underflow */ };" );
1345 krisbash 1.1 AddQualifiersParseContentExpectToFail(
1346 "class T { Sint16 x = -32769; /* underflow */ };" );
1347 }
1348 NitsEndTest
1349
1350
1351 NitsTestWithSetup(TestMaxValueS32, TestMofSetup)
1352
1353 {
1354 AddQualifiersParseContentExpectToSucceed(
1355 "class T { [MaxValue(1001)]Sint32 x = 1000; /* ok */};", true);
1356 AddQualifiersParseContentExpectToSucceed(
1357 "class T { [MaxValue(-2147483648)]Sint32 x = -2147483648; /* ok */};", true);
1358 AddQualifiersParseContentExpectToSucceed(
1359 "class T { [MaxValue(-2147483647)]Sint32 x = -2147483648; /* ok */};", true);
1360 AddQualifiersParseContentExpectToSucceed(
1361 "class T { [MaxValue(2147483647)]Sint32 x = 2147483647; /* ok */};", true);
1362 }
1363 NitsEndTest
1364
1365
1366 krisbash 1.1 NitsTestWithSetup(TestInvalidMaxValueS32, TestMofSetup)
1367 {
1368 // s32 range is -2147483648 - 2147483647
1369 AddQualifiersParseContentExpectToFail(
1370 "class T { [MaxValue(2147483648)]Sint32 x = 2147483648; /* overflow */ };" );
1371 AddQualifiersParseContentExpectToFail(
1372 "class T { [MaxValue(0)]Sint32 x = 2147483648; /* overflow */ };" );
1373 AddQualifiersParseContentExpectToFail(
1374 "class T { [MaxValue(1)]Sint32 x = 10; /* value too large */ };" );
1375 AddQualifiersParseContentExpectToFail(
1376 "class T { Sint32 x = -2147483649; /* underflow */ };" );
1377 }
1378 NitsEndTest
1379
1380
1381 NitsTestWithSetup(TestMaxValueS64, TestMofSetup)
1382 {
1383 AddQualifiersParseContentExpectToSucceed(
1384 "class T { [MaxValue(1010)]Sint64 x = 1000; /* ok */};", true);
1385 AddQualifiersParseContentExpectToSucceed(
1386 "class T { [MaxValue(9223372036854775807)]Sint64 x = 9223372036854775807; /* ok */};", true);
1387 krisbash 1.1 AddQualifiersParseContentExpectToSucceed(
1388 "class T { [MaxValue(-9223372036854775808)]Sint64 x = -9223372036854775808; /* ok */};", true);
1389 AddQualifiersParseContentExpectToSucceed(
1390 "class T { [MaxValue(-9223372036854775807)]Sint64 x = -9223372036854775808; /* ok */};", true);
1391 }
1392 NitsEndTest
1393
1394
1395 NitsTestWithSetup(TestInvalidMaxValueS64, TestMofSetup)
1396 {
1397 // u64 range is 0-18446744073709551615
1398 // practically, attributes are limitted by sint64:
1399 // -9223372036854775807 - 1 - 9223372036854775807
1400 //ATTN! int64 errors are not processed correctly yet
1401 #if 0
1402 AddQualifiersParseContentExpectToFail(
1403 "class T { [MaxValue(9223372036854775808)]Sint64 x = 0; /* overflow */ };" );
1404 AddQualifiersParseContentExpectToFail(
1405 "class T { [MaxValue(0)]Sint64 x = 9223372036854775808; /* overflow */ };" );
1406 AddQualifiersParseContentExpectToFail(
1407 "class T { Sint64 x = -9223372036854775809; /* underflow */ };" );
1408 krisbash 1.1 #endif
1409 AddQualifiersParseContentExpectToFail(
1410 "class T { [MaxValue(-9223372036854775808)]Sint64 x = -9223372036854775807; /* too large */};");
1411 AddQualifiersParseContentExpectToFail(
1412 "class T { [MaxValue(1)]Sint64 x = 10; /* value too large */ };" );
1413 }
1414 NitsEndTest
1415
1416
1417 NitsTestWithSetup(TestMaxValueR32, TestMofSetup)
1418 {
1419 AddQualifiersParseContentExpectToSucceed(
1420 "class T { [MaxValue(999)]Real32 x = 998.9; /* ok */};", true);
1421 AddQualifiersParseContentExpectToSucceed(
1422 "class T { [MaxValue(0)]Real32 x = -0.1e-99; /* ok */};", true);
1423 AddQualifiersParseContentExpectToSucceed(
1424 "class T { [MaxValue(9223372036854775807)]Real32 x = 9.222e+18; /* ok */};", true);
1425 AddQualifiersParseContentExpectToSucceed(
1426 "class T { [MaxValue(-9223372036854775808)]Real32 x = -9.224e18; /* ok */};", true);
1427 }
1428 NitsEndTest
1429 krisbash 1.1
1430
1431 NitsTestWithSetup(TestInvalidMaxValueR32, TestMofSetup)
1432 {
1433 AddQualifiersParseContentExpectToFail(
1434 "class T { [MaxValue(999)]Real32 x = 999.0001; /* too big */};");
1435 AddQualifiersParseContentExpectToFail(
1436 "class T { [MaxValue(0)]Real32 x = 0.1e+0; /* too big */};");
1437 AddQualifiersParseContentExpectToFail(
1438 "class T { [MaxValue(9223372036854775807)]Real32 x = 9.23e18; /* too big */};");
1439 AddQualifiersParseContentExpectToFail(
1440 "class T { [MaxValue(9223372036854775807)]Real32 x = 1.0e38; /* too big */};");
1441 AddQualifiersParseContentExpectToFail(
1442 "class T { [MaxValue(-9223372036854775808)]Real32 x = -9.21e18; /* too big */};");
1443 }
1444 NitsEndTest
1445
1446
1447 NitsTestWithSetup(TestMaxValueR64, TestMofSetup)
1448 {
1449 AddQualifiersParseContentExpectToSucceed(
1450 krisbash 1.1 "class T { [MaxValue(999)]Real64 x = 998.9; /* ok */};", true);
1451 AddQualifiersParseContentExpectToSucceed(
1452 "class T { [MaxValue(0)]Real64 x = -0.1e-99; /* ok */};", true);
1453 AddQualifiersParseContentExpectToSucceed(
1454 "class T { [MaxValue(9223372036854775807)]Real64 x = 9.222e+18; /* ok */};", true);
1455 AddQualifiersParseContentExpectToSucceed(
1456 "class T { [MaxValue(-9223372036854775808)]Real64 x = -9.224e18; /* ok */};", true);
1457 }
1458 NitsEndTest
1459
1460
1461 NitsTestWithSetup(TestInvalidMaxValueR64, TestMofSetup)
1462 {
1463 AddQualifiersParseContentExpectToFail(
1464 "class T { [MaxValue(999)]Real64 x = 999.00001; /* too big */};");
1465 AddQualifiersParseContentExpectToFail(
1466 "class T { [MaxValue(0)]Real64 x = 0.1e+0; /* too big */};");
1467 AddQualifiersParseContentExpectToFail(
1468 "class T { [MaxValue(9223372036854775807)]Real64 x = 9.23e18; /* too big */};");
1469 AddQualifiersParseContentExpectToFail(
1470 "class T { [MaxValue(9223372036854775807)]Real64 x = 1.0e38; /* too big */};");
1471 krisbash 1.1 AddQualifiersParseContentExpectToFail(
1472 "class T { [MaxValue(-9223372036854775808)]Real64 x = -9.21e18; /* too big */};");
1473 }
1474 NitsEndTest
1475
1476
1477 NitsTestWithSetup(TestUint64_Bug741436, TestMofSetup)
1478 {
1479 AddQualifiersParseContentExpectToSucceed(
1480 "class T { uint64 p_uint64 = 0xFFFFFFFFFFFFFFAA; /* ok */};", true);
1481 }
1482 NitsEndTest
1483
1484
1485 NitsTestWithSetup(TestMaxLenAttribute, TestMofSetup)
1486 {
1487 AddQualifiersParseContentExpectToSucceed(
1488 "class T { [MaxLen(3)] string s = \"123\"; /* ok */};", true);
1489 AddQualifiersParseContentExpectToSucceed(
1490 "class T { [MaxLen(3)] string s[] = {\"123\",\"ab\"}; /* ok */};", true);
1491 }
1492 krisbash 1.1 NitsEndTest
1493
1494
1495 NitsTestWithSetup(TestInvalidMaxLenAttribute, TestMofSetup)
1496 {
1497 AddQualifiersParseContentExpectToFail(
1498 "class T { [MaxLen(3)] string s = \"12345\"; /* string too long */};");
1499 AddQualifiersParseContentExpectToFail(
1500 "class T { [MaxLen(3)] string s[] = {\"ab\",\"12345\"}; /* string too long */};");
1501 }
1502 NitsEndTest
1503
1504
1505 NitsTestWithSetup(TestIncompatibleTypeMaxLenAttribute, TestMofSetup)
1506 {
1507 AddQualifiersParseContentExpectToFail(
1508 "class T { [MaxLen(3)] uint32 u = 12345; /* n/a for ints */};");
1509 }
1510 NitsEndTest
1511
1512
1513 krisbash 1.1 NitsTestWithSetup(TestMinLenAttribute, TestMofSetup)
1514 {
1515 AddQualifiersParseContentExpectToSucceed(
1516 "class T { [MinLen(3)] string s = \"123\"; /* ok */};", true);
1517 AddQualifiersParseContentExpectToSucceed(
1518 "class T { [MinLen(3)] string s[] = {\"123\",\"abcd\"}; /* ok */};", true);
1519 }
1520 NitsEndTest
1521
1522
1523 NitsTestWithSetup(TestInvalidMinLenAttribute, TestMofSetup)
1524 {
1525 AddQualifiersParseContentExpectToFail(
1526 "class T { [MinLen(3)] string s = \"12\"; /* string too short */};");
1527 AddQualifiersParseContentExpectToFail(
1528 "class T { [MinLen(3)] string s[] = {\"ab\",\"12345\"}; /* string too short */};");
1529 }
1530 NitsEndTest
1531
1532
1533 NitsTestWithSetup(TestIncompatibleTypeMinLenAttribute, TestMofSetup)
1534 krisbash 1.1 {
1535 AddQualifiersParseContentExpectToFail(
1536 "class T { [MinLen(3)] uint32 u = 12345; /* n/a for ints */};");
1537 }
1538 NitsEndTest
1539
1540
1541 NitsTestWithSetup(TestFindingIncludeFile, TestMofSetup)
1542 {
1543 // test include pragma with relative path
1544 string data = "\
1545 #pragma include (\"qualifiers.mof\")\n\
1546 #pragma include (\"qualifiers_optional.mof\")\n\
1547 class T { [MinValue(0)] uint32 u = 12345; };\
1548 ";
1549
1550 const char* content = data.c_str();
1551 ut::writeFileContent( TEMP_FILE, vector<unsigned char>( reinterpret_cast<const unsigned char*>(content),
1552 reinterpret_cast<const unsigned char*>(content)+strlen(content)));
1553
1554 const char* paths[] = {
1555 krisbash 1.1 "/some-invalid-path/",
1556 #if defined(_MSC_VER)
1557 "../../share/omischema/" CONFIG_CIMSCHEMA "/"
1558 #else
1559 "./share/omischema/" CONFIG_CIMSCHEMA "/"
1560 #endif
1561 };
1562
1563 MOF_Parser* parser;
1564 parser = MOF_Parser_New(paths,MI_COUNT(paths));
1565
1566 MOF_Parser_SetErrorCallback(parser, ErrorCallback, NULL);
1567 MOF_Parser_SetWarningCallback(parser, WarningCallback, NULL);
1568
1569 /* clear results from previous run */
1570 s_results.clear();
1571
1572 /* Parse the file */
1573 int res = MOF_Parser_Parse(parser, TEMP_FILE);
1574
1575 /* Delete the parser */
1576 krisbash 1.1 MOF_Parser_Delete(parser);
1577
1578 UT_ASSERT( 0 == res );
1579
1580 // expect no errors
1581 UT_ASSERT( s_results.m_error.empty() );
1582 }
1583 NitsEndTest
1584
1585
1586 NitsTestWithSetup(TestDifferentKeyInDerivedClass, TestMofSetup)
1587 {
1588 // test different key in derived class
1589 // Note: this MOF is invalid and MOF parser should catch the error
1590 string data = "\
1591 Class A { [key] uint32 kv1; };\n\
1592 Class B: A { [key] uint32 kv2; };\n\
1593 ";
1594
1595 AddQualifiersParseContentExpectToFail( data.c_str(), true, true );
1596 }
1597 krisbash 1.1 NitsEndTest
1598
1599
1600 NitsTestWithSetup(TestDifferentKeyInSkipLevelClass, TestMofSetup)
1601 {
1602 // test different key in skip-level derived class
1603 // Note: this MOF is invalid and MOF parser should catch the error
1604 string data = "\
1605 Class A { [key] uint32 kv1; };\n\
1606 class b : A {};\n\
1607 Class C: B { [key] uint32 kv2; };\n\
1608 ";
1609
1610 AddQualifiersParseContentExpectToFail( data.c_str(), true, true );
1611 }
1612 NitsEndTest
1613
1614
1615 NitsTestWithSetup(TestDifferentKeyTypeInDerivedClass, TestMofSetup)
1616 {
1617 // test different key type in derived class
1618 krisbash 1.1 // Note: this MOF is invalid and MOF parser should catch the error
1619 string data = "\
1620 Class A { [key] uint32 kv1; };\n\
1621 class b : A {};\n\
1622 Class C: B { [key] uint16 kv1; };\n\
1623 ";
1624
1625 AddQualifiersParseContentExpectToFail( data.c_str(), true, true );
1626 }
1627 NitsEndTest
1628
1629
1630 NitsTestWithSetup(TestEmbeddedInstanceUndefinedClass, TestMofSetup)
1631 {
1632 // test undefined class referred from embedded instance
1633 // Note: this MOF is invalid and MOF parser should catch the error
1634 string data = "\
1635 Class A { [embeddedInstance(\"DoesNotExists\")] string s; };\n\
1636 ";
1637
1638 AddQualifiersParseContentExpectToFail( data.c_str(), true, true );
1639 krisbash 1.1 }
1640 NitsEndTest
1641
1642
1643 NitsTestWithSetup(TestEmbeddedInstanceDifferentCase, TestMofSetup)
1644 {
1645 // test undefined class referred from embedded instance
1646 // Note: this MOF is invalid and MOF parser should catch the error
1647 string data = "\
1648 class emb { string s;};\n\
1649 Class A { [embeddedInstance(\"eMB\")] string s; };\n\
1650 ";
1651
1652 AddQualifiersParseContentExpectToSucceed( data.c_str(), true, false );
1653 }
1654 NitsEndTest
1655
1656
1657 NitsTestWithSetup(TestIntConstantOverflow, TestMofSetup)
1658 {
1659 // test different key type in derived class
1660 krisbash 1.1 // Note: this MOF is invalid and MOF parser should catch the error
1661 string data = "\
1662 Class TestSP_Value\n\
1663 {\n\
1664 uint64 p_uint64 = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;\n\
1665 };\n\
1666 ";
1667
1668 //AddQualifiersParseContentExpectToFail( data.c_str(), true, false );
1669 ParseContentExpectToFail(data.c_str(), true, true);
1670 }
1671 NitsEndTest
1672
1673
1674 BEGIN_EXTERNC
1675 void _Uint64ValueVerificationCallback(const MI_ClassDecl* decl,void*)
1676 {
1677 UT_ASSERT( ut::String(MI_T("T")) == decl->name );
1678 UT_ASSERT( decl->numProperties == 1 );
1679 UT_ASSERT( ut::String(MI_T("p_uint64")) == decl->properties[0]->name );
1680 UT_ASSERT( MI_UINT64 == decl->properties[0]->type );
1681 krisbash 1.1 UT_ASSERT( MI_LL(0xFFFFFFFFFFFFFFAA) == *(MI_Uint64*)decl->properties[0]->value );
1682 }
1683 END_EXTERNC
1684
1685 NitsTestWithSetup(TestUint64ConstantValue, TestMofSetup)
1686 {
1687 // verify that parser correctly interprets vlaue greater than LLONG_MAX
1688 const unsigned char content [] =
1689 "class T { uint64 p_uint64 = 0xFFFFFFFFFFFFFFAA; /* ok */};";
1690 ut::writeFileContent( TEMP_FILE, vector<unsigned char>( content, (content)+ sizeof(content) ));
1691
1692 MOF_Parser* parser;
1693
1694 parser = MOF_Parser_New(0,0);
1695
1696 MOF_Parser_SetErrorCallback(parser, ErrorCallback, NULL);
1697 MOF_Parser_SetWarningCallback(parser, WarningCallback, NULL);
1698 MOF_Parser_SetClassDeclCallback(parser, _Uint64ValueVerificationCallback, NULL);
1699
1700 /* clear results from previous run */
1701 s_results.clear();
1702 krisbash 1.1
1703 /* Parse the file */
1704 int res = MOF_Parser_Parse(parser, TEMP_FILE);
1705
1706 /* Delete the parser */
1707 MOF_Parser_Delete(parser);
1708
1709 UT_ASSERT( 0 == res );
1710
1711 // expect no errors
1712 UT_ASSERT( s_results.m_error.empty() );
1713 }
1714 NitsEndTest
1715
1716
1717 BEGIN_EXTERNC
1718 void _Int64ValueVerificationCallback(
1719 const MI_ClassDecl* decl, void*)
1720 {
1721 UT_ASSERT( ut::String(MI_T("T")) == decl->name );
1722 UT_ASSERT( decl->numProperties == 1 );
1723 krisbash 1.1 UT_ASSERT( ut::String(MI_T("p_int64")) == decl->properties[0]->name );
1724 UT_ASSERT( MI_SINT64 == decl->properties[0]->type );
1725 UT_ASSERT( (-MI_LL(9223372036854775807)-0) == *(MI_Sint64*)decl->properties[0]->value );
1726 }
1727 END_EXTERNC
1728
1729 NitsTestWithSetup(TestInt64ConstantValue, TestMofSetup)
1730 {
1731 // verify that parser correctly interprets vlaue greater than LLONG_MAX
1732 const unsigned char content [] =
1733 "class T { sint64 p_int64 = -9223372036854775807; /* ok */};";
1734 ut::writeFileContent( TEMP_FILE, vector<unsigned char>( content, (content)+ sizeof(content) ));
1735
1736 MOF_Parser* parser;
1737
1738 parser = MOF_Parser_New(0,0);
1739
1740 MOF_Parser_SetErrorCallback(parser, ErrorCallback, NULL);
1741 MOF_Parser_SetWarningCallback(parser, WarningCallback, NULL);
1742 MOF_Parser_SetClassDeclCallback(parser, _Int64ValueVerificationCallback, NULL);
1743
1744 krisbash 1.1 /* clear results from previous run */
1745 s_results.clear();
1746
1747 /* Parse the file */
1748 int res = MOF_Parser_Parse(parser, TEMP_FILE);
1749
1750 /* Delete the parser */
1751 MOF_Parser_Delete(parser);
1752
1753 UT_ASSERT( 0 == res );
1754
1755 // expect no errors
1756 UT_ASSERT( s_results.m_error.empty() );
1757 }
1758 NitsEndTest
1759
1760
1761 BEGIN_EXTERNC
1762 void _HexInt64ValueVerificationCallback(
1763 const MI_ClassDecl* decl, void*)
1764 {
1765 krisbash 1.1 UT_ASSERT( ut::String(MI_T("T")) == decl->name );
1766 UT_ASSERT( decl->numProperties == 1 );
1767 UT_ASSERT( ut::String(MI_T("p_int64")) == decl->properties[0]->name );
1768 UT_ASSERT( MI_SINT64 == decl->properties[0]->type );
1769 UT_ASSERT( -MI_LL(0x7FFFFFFFFFFFFFAA) == *(MI_Sint64*)decl->properties[0]->value );
1770 }
1771 END_EXTERNC
1772
1773 NitsTestWithSetup(TestHexInt64ConstantValue, TestMofSetup)
1774 {
1775 // verify that parser correctly interprets vlaue greater than LLONG_MAX
1776 const unsigned char content [] =
1777 "class T { sint64 p_int64 = -0x7FFFFFFFFFFFFFAA; /* ok */};";
1778 ut::writeFileContent( TEMP_FILE, vector<unsigned char>( content, (content)+ sizeof(content) ));
1779
1780 MOF_Parser* parser;
1781
1782 parser = MOF_Parser_New(0,0);
1783
1784 MOF_Parser_SetErrorCallback(parser, ErrorCallback, NULL);
1785 MOF_Parser_SetWarningCallback(parser, WarningCallback, NULL);
1786 krisbash 1.1 MOF_Parser_SetClassDeclCallback(parser, _HexInt64ValueVerificationCallback, NULL);
1787
1788 /* clear results from previous run */
1789 s_results.clear();
1790
1791 /* Parse the file */
1792 int res = MOF_Parser_Parse(parser, TEMP_FILE);
1793
1794 /* Delete the parser */
1795 MOF_Parser_Delete(parser);
1796
1797 UT_ASSERT( 0 == res );
1798
1799 // expect no errors
1800 UT_ASSERT( s_results.m_error.empty() );
1801 }
1802 NitsEndTest
1803
1804
1805 BEGIN_EXTERNC
1806 void _BinInt64ValueVerificationCallback(
1807 krisbash 1.1 const MI_ClassDecl* decl, void*)
1808 {
1809 UT_ASSERT( ut::String(MI_T("T")) == decl->name );
1810 UT_ASSERT( decl->numProperties == 1 );
1811 UT_ASSERT( ut::String(MI_T("p_int64")) == decl->properties[0]->name );
1812 UT_ASSERT( MI_SINT64 == decl->properties[0]->type );
1813 UT_ASSERT( -MI_LL(0x7FFFFFFFFFFFFFFD) == *(MI_Sint64*)decl->properties[0]->value );
1814 }
1815 END_EXTERNC
1816
1817 NitsTestWithSetup(TestBinInt64ConstantValue, TestMofSetup)
1818 {
1819 // verify that parser correctly interprets vlaue greater than LLONG_MAX
1820 const unsigned char content [] =
1821 "class T { sint64 p_int64 = -111111111111111111111111111111111111111111111111111111111111101b; /* ok dec*/};";
1822 ut::writeFileContent( TEMP_FILE, vector<unsigned char>( content, (content)+ sizeof(content) ));
1823
1824 MOF_Parser* parser;
1825
1826 parser = MOF_Parser_New(0,0);
1827
1828 krisbash 1.1 MOF_Parser_SetErrorCallback(parser, ErrorCallback, NULL);
1829 MOF_Parser_SetWarningCallback(parser, WarningCallback, NULL);
1830 MOF_Parser_SetClassDeclCallback(parser, _BinInt64ValueVerificationCallback, NULL);
1831
1832 /* clear results from previous run */
1833 s_results.clear();
1834
1835 /* Parse the file */
1836 int res = MOF_Parser_Parse(parser, TEMP_FILE);
1837
1838 /* Delete the parser */
1839 MOF_Parser_Delete(parser);
1840
1841 UT_ASSERT( 0 == res );
1842
1843 // expect no errors
1844 UT_ASSERT( s_results.m_error.empty() );
1845 }
1846 NitsEndTest
1847
1848
|
Return to
test_mof.cpp
CVS log
Up to [OMI] / omi / tests / mof