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