1 mike 1.1 /*
2 **==============================================================================
3 **
4 ** Open Management Infrastructure (OMI)
5 **
6 ** Copyright (c) Microsoft Corporation
7 **
8 ** Licensed under the Apache License, Version 2.0 (the "License"); you may not
9 ** use this file except in compliance with the License. You may obtain a copy
10 ** of the License at
11 **
12 ** http://www.apache.org/licenses/LICENSE-2.0
13 **
14 ** THIS CODE IS PROVIDED *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15 ** KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
16 ** WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
17 ** MERCHANTABLITY OR NON-INFRINGEMENT.
18 **
19 ** See the Apache 2 License for the specific language governing permissions
20 ** and limitations under the License.
21 **
22 mike 1.1 **==============================================================================
23 */
24
25 #include <ut/ut.h>
26 #include <provreg/provreg.h>
27 #include <provreg/regfile.h>
28 #include <base/strings.h>
29 #include <base/dir.h>
30 #include <unittest/utils.h>
31 #include <base/paths.h>
32 #include <algorithm>
33 #include <base/io.h>
34
35 //#define ENABLE_PRINT
36
37 static char TEMP_FILE[MAX_PATH_SIZE];
38
39 using namespace std;
40
41 static FILE* outStream = NULL;
42
43 mike 1.1 static void setUp()
44 {
45 Strlcpy(TEMP_FILE, GetPath(ID_TMPDIR), sizeof(TEMP_FILE));
46 Strlcat(TEMP_FILE, "/test_temp.tmp", sizeof(TEMP_FILE));
47
48 #if defined(CONFIG_POSIX)
49 // Change directory to PREFIX/unittest.
50 char path[MAX_PATH_SIZE];
51 Strlcpy(path, CONFIG_PREFIX, sizeof(path));
52 Strlcat(path, "/unittest", sizeof(path));
53 Chdir(path);
54 #endif
55
56 #if defined(ENABLE_PRINT)
57 outStream = stdout;
58 #else
59 outStream = Fopen(NULL_FILE, "w");
60 #endif
61 }
62
63 static void cleanup()
64 mike 1.1 {
65 #if defined(ENABLE_PRINT)
66 outStream = NULL;
67 #else
68 fclose(outStream);
69 outStream = NULL;
70 #endif
71 ut::removeIfExist( TEMP_FILE );
72 }
73
74 #if 0
75 static void TestProvReg()
76 {
77 /* Relative to 'unittest' directory */
78 std::string path = ut::findSampleFile(0,"","../provreg/tests/omiregister.conf");
79 ProvReg reg;
80 MI_Result r;
81 ProvRegEntry* p;
82 size_t index = 0;
83
84 /* Load the registrations */
85 mike 1.1 r = ProvReg_Init(®, path.c_str());
86
87 if (r != MI_RESULT_OK)
88 {
89 fprintf(stdout, "failed to open: %s\n", path.c_str());
90 UT_ASSERT_FAILED_MSG("failed to open register.conf");
91 }
92
93 /* Check the registrations */
94 for (p = reg.head; p; p = p->next, index++)
95 {
96 switch (index)
97 {
98 case 0:
99 {
100 UT_ASSERT(p->provInterface == PROV_INTERFACE_STATIK);
101 UT_ASSERT(Zcmp(p->nameSpace, T("root/test")) == 0);
102 UT_ASSERT(Zcmp(p->className, T("Dog")) == 0);
103 UT_ASSERT(strcmp(p->libraryName, "MyProvider") == 0);
104 break;
105 }
106 mike 1.1 case 1:
107 {
108 UT_ASSERT(p->provInterface == PROV_INTERFACE_STATIK);
109 UT_ASSERT(Zcmp(p->nameSpace, T("root/test")) == 0);
110 UT_ASSERT(Zcmp(p->className, T("Cat")) == 0);
111 UT_ASSERT(strcmp(p->libraryName, "MyProvider") == 0);
112 break;
113 }
114 case 2:
115 {
116 UT_ASSERT(p->provInterface == PROV_INTERFACE_STATIK);
117 UT_ASSERT(Zcmp(p->nameSpace, T("root/test")) == 0);
118 UT_ASSERT(Zcmp(p->className, T("Bird")) == 0);
119 UT_ASSERT(strcmp(p->libraryName, "MyProvider") == 0);
120 break;
121 }
122 default:
123 UT_ASSERT_FAILED_MSG("unexpected branch");
124 }
125 }
126
127 mike 1.1 ProvReg_Dump(®, outStream);
128
129 // Find a provider for the given class.
130 {
131 const ProvRegEntry* entry;
132
133 entry = ProvReg_FindProviderForClass(®, T("root/test"),
134 T("Bird"));
135 UT_ASSERT(entry != NULL);
136
137 entry = ProvReg_FindProviderForClass(®, T("blah"), T("blah"));
138 UT_ASSERT(entry == NULL);
139 }
140
141 // check derived classes
142 vector<ut::String> res;
143 ProvRegPosition pos;
144 MI_ConstString derived = 0;
145
146 r = ProvReg_BeginClasses( ®, T("root/test"), T("Animal"), MI_TRUE, &pos );
147
148 mike 1.1 UT_ASSERT (MI_RESULT_OK == r);
149
150 for (;;)
151 {
152 MI_Boolean done;
153 r = ProvReg_NextClass( &pos, &derived, &done);
154
155 if (done)
156 break;
157
158 UT_ASSERT (MI_RESULT_OK == r);
159 res.push_back( derived );
160 }
161
162 r = ProvReg_EndClasses(&pos);
163 UT_ASSERT(MI_RESULT_OK == r);
164
165
166 std::sort< vector< ut::String >::iterator >(res.begin(), res.end());
167
168 vector<ut::String> expected_res;
169 mike 1.1 expected_res.push_back(T("Bird"));
170 expected_res.push_back(T("Cat"));
171 expected_res.push_back(T("Dog"));
172
173 UT_ASSERT(expected_res == res);
174
175 ProvReg_Destroy(®);
176 }
177 #endif
178
179 #if 0
180 static void TestProvRegInvalidConfigFile()
181 {
182 ProvReg reg;
183 MI_Result r;
184
185 /* Load the registrations */
186 r = ProvReg_Init(®, "non-exisiting-file");
187
188 UT_ASSERT (MI_RESULT_OPEN_FAILED == r);
189 }
190 mike 1.1 #endif
191
192 #if 0
193 static void VerifyInheritanceChain(ProvReg* reg, MI_ConstString ns, MI_ConstString base, MI_Boolean deep, MI_ConstString expected)
194 {
195 // check derived classes
196 vector<ut::String> res;
197 ProvRegPosition pos;
198 MI_ConstString derived = 0;
199
200 MI_Result r = ProvReg_BeginClasses( reg, ns, base, deep, &pos );
201
202 UT_ASSERT (MI_RESULT_OK == r);
203
204 for (;;)
205 {
206 MI_Boolean done;
207 r = ProvReg_NextClass( &pos, &derived, &done);
208
209 if (done)
210 break;
211 mike 1.1
212 UT_ASSERT (MI_RESULT_OK == r);
213 res.push_back( derived );
214 }
215
216 r = ProvReg_EndClasses(&pos);
217 UT_ASSERT(MI_RESULT_OK == r);
218
219 std::sort< vector< ut::String >::iterator >(res.begin(), res.end());
220
221 vector<ut::String> expected_res;
222 ut::StringToArray(expected, expected_res);
223 std::sort< vector< ut::String >::iterator >(expected_res.begin(), expected_res.end());
224
225 if(expected_res != res)
226 {
227 UT_ASSERT_FAILED_MSG(string(string("actual result is different from expected: expected {") +
228 ut::StrToChar(ut::ArrayToString(expected_res)) +
229 "} but actual is {" +
230 ut::StrToChar(ut::ArrayToString(res)) +
231 "}").c_str() );
232 mike 1.1 }
233 }
234 #endif
235
236 #if 0
237 static void VerifyAssociationChain(ProvReg* reg, MI_ConstString ns, MI_ConstString cn, MI_ConstString assocClass, MI_ConstString resultClass, MI_ConstString expected)
238 {
239 // check derived classes
240 vector<ut::String> res;
241 ProvRegAssocPosition pos;
242 MI_ConstString nextClass = 0;
243
244 MI_Result r = ProvReg_BeginAssocClasses( reg, ns, cn, assocClass, resultClass, &pos );
245
246 UT_ASSERT (MI_RESULT_OK == r);
247
248 for (;;)
249 {
250 MI_Boolean done;
251 r = ProvReg_NextAssocClass( &pos, &nextClass, &done);
252
253 mike 1.1 if (done)
254 break;
255
256 UT_ASSERT (MI_RESULT_OK == r);
257 res.push_back( nextClass );
258 }
259
260 r = ProvReg_EndAssocClasses(&pos);
261 UT_ASSERT(MI_RESULT_OK == r);
262
263 std::sort< vector< ut::String >::iterator >(res.begin(), res.end());
264
265 vector<ut::String> expected_res;
266 ut::StringToArray(expected, expected_res);
267 std::sort< vector< ut::String >::iterator >(expected_res.begin(), expected_res.end());
268
269 if(expected_res != res)
270 {
271 UT_ASSERT_FAILED_MSG(string(string("actual result is different from expected: expected {") +
272 ut::StrToChar(ut::ArrayToString(expected_res)) +
273 "} but actual is {" +
274 mike 1.1 ut::StrToChar(ut::ArrayToString(res)) +
275 "}").c_str() );
276 }
277 }
278 #endif
279
280 #if 0
281 static void TestClassInheritanceTreeMultipleDerived()
282 {
283 const char* content = "# sample config entry\n"
284 "statik:namespace :Dog,Animal,Base :provider_name\n"
285 "statik:another_namespace :Dog,Animal,Base :provider_name\n"
286 "statik:another_namespace :Programmer,Person,Base :software_provider_name\n"
287 "statik:another_namespace :CEO,Manager,Person,Base :executive_provider_name\n"
288 "statik:another_namespace :stand_alone_Base :one_more_provider_name\n"
289 ;
290
291 // verify inheritance chains:
292 // Base -> Dog,Animal,Person,Programmer,Manager,CEO
293 // Animal -> Dog
294 // Person -> Programmer, Manager, CEO
295 mike 1.1 // Manager-> CEO
296 // CEO, Programmer, Dog ->
297
298 ut::writeFileContent( TEMP_FILE, vector<unsigned char>( reinterpret_cast<const unsigned char*>(content),
299 reinterpret_cast<const unsigned char*>(content)+strlen(content)));
300
301 ProvReg reg;
302
303 UT_ASSERT (MI_RESULT_OK == ProvReg_Init(®, TEMP_FILE));
304
305 /////////////////////////////////////////////////////////////////////////////////////////////////
306 // another_namespace
307 // deep == true
308 VerifyInheritanceChain(®, T("another_namespace"), T("Base"), MI_TRUE, T("Dog,Animal,Person,Programmer,Manager,CEO"));
309 VerifyInheritanceChain(®, T("another_namespace"), T("Animal"), MI_TRUE, T("Dog"));
310 VerifyInheritanceChain(®, T("another_namespace"), T("Person"), MI_TRUE, T("Programmer,Manager,CEO"));
311 VerifyInheritanceChain(®, T("another_namespace"), T("Manager"), MI_TRUE, T("CEO"));
312 VerifyInheritanceChain(®, T("another_namespace"), T("CEO"), MI_TRUE, T(""));
313 VerifyInheritanceChain(®, T("another_namespace"), T("Programmer"), MI_TRUE, T(""));
314 VerifyInheritanceChain(®, T("another_namespace"), T("Dog"), MI_TRUE, T(""));
315
316 mike 1.1 // deep == false
317 VerifyInheritanceChain(®, T("another_namespace"), T("Base"), MI_FALSE, T("Animal,Person"));
318 VerifyInheritanceChain(®, T("another_namespace"), T("Animal"), MI_FALSE, T("Dog"));
319 VerifyInheritanceChain(®, T("another_namespace"), T("Person"), MI_FALSE, T("Programmer,Manager"));
320 VerifyInheritanceChain(®, T("another_namespace"), T("Manager"), MI_FALSE, T("CEO"));
321 VerifyInheritanceChain(®, T("another_namespace"), T("CEO"), MI_FALSE, T(""));
322 VerifyInheritanceChain(®, T("another_namespace"), T("Programmer"), MI_FALSE, T(""));
323 VerifyInheritanceChain(®, T("another_namespace"), T("Dog"), MI_FALSE, T(""));
324
325 // ALL CLASSES, deep == true
326 VerifyInheritanceChain(®, T("another_namespace"), 0, MI_TRUE, T("Dog,Base,Animal,Person,Programmer,Manager,CEO,stand_alone_Base"));
327
328 // ALL CLASSES, deep == false
329 VerifyInheritanceChain(®, T("another_namespace"), 0, MI_FALSE, T("Base,stand_alone_Base"));
330
331 /////////////////////////////////////////////////////////////////////////////////////////////////
332 // namespace
333 // deep == true
334 VerifyInheritanceChain(®, T("namespace"), T("Base"), MI_TRUE, T("Dog,Animal"));
335 VerifyInheritanceChain(®, T("namespace"), T("Animal"), MI_TRUE, T("Dog"));
336 VerifyInheritanceChain(®, T("namespace"), T("Dog"), MI_TRUE, T(""));
337 mike 1.1
338 // deep == false
339 VerifyInheritanceChain(®, T("namespace"), T("Base"), MI_FALSE, T("Animal"));
340 VerifyInheritanceChain(®, T("namespace"), T("Animal"), MI_FALSE, T("Dog"));
341 VerifyInheritanceChain(®, T("namespace"), T("Dog"), MI_FALSE, T(""));
342
343 // ALL CLASSES, deep == true
344 VerifyInheritanceChain(®, T("namespace"), 0, MI_TRUE, T("Dog,Base,Animal"));
345
346 // ALL CLASSES, deep == false
347 VerifyInheritanceChain(®, T("namespace"), 0, MI_FALSE, T("Base"));
348
349 /////////////////////////////////////////////////////////////////////////////////////////////////
350 // base classes
351 const MI_Char* res = 0;
352 UT_ASSERT( MI_RESULT_OK == ProvReg_GetDirectBaseClass(®, T("another_namespace"), T("Base"), &res) &&
353 0 == res );
354 UT_ASSERT( MI_RESULT_OK == ProvReg_GetDirectBaseClass(®, T("another_namespace"), T("Animal"), &res) &&
355 ut::String(T("Base")) == res );
356 UT_ASSERT( MI_RESULT_OK == ProvReg_GetDirectBaseClass(®, T("another_namespace"), T("Dog"), &res) &&
357 ut::String(T("Animal")) == res );
358 mike 1.1 UT_ASSERT( MI_RESULT_OK == ProvReg_GetDirectBaseClass(®, T("another_namespace"), T("Programmer"), &res) &&
359 ut::String(T("Person")) == res );
360
361 // different case
362 UT_ASSERT( MI_RESULT_OK == ProvReg_GetDirectBaseClass(®, T("another_namespace"), T("mAnAger"), &res) &&
363 ut::String(T("Person")) == res );
364
365 UT_ASSERT( MI_RESULT_OK == ProvReg_GetDirectBaseClass(®, T("Another_Namespace"), T("ceo"), &res) &&
366 ut::String(T("Manager")) == res );
367
368 // invalid class
369 UT_ASSERT( MI_RESULT_INVALID_CLASS == ProvReg_GetDirectBaseClass(®, T("another_namespace"), T("not-existing-class"), &res) );
370
371 // invalid namespace
372 UT_ASSERT( MI_RESULT_INVALID_NAMESPACE == ProvReg_GetDirectBaseClass(®, T("not-existing-namespace"), T("Base"), &res) );
373
374 ProvReg_Destroy(®);
375 }
376 #endif
377
378 #if 0
379 mike 1.1 static void TestInvalidClassInheritanceTree()
380 {
381 const char* content = "# sample config entry\n"
382 "statik:namespace :Dog,Animal,Base :provider_name\n"
383 "statik: namespace :Base,Animal,Dog :provider_name\n"
384 ;
385
386 // entry is invalid - expect error back
387
388 ut::writeFileContent( TEMP_FILE, vector<unsigned char>( reinterpret_cast<const unsigned char*>(content),
389 reinterpret_cast<const unsigned char*>(content)+strlen(content)));
390
391 ProvReg reg;
392
393 UT_ASSERT (MI_RESULT_INVALID_CLASS_HIERARCHY == ProvReg_Init(®, TEMP_FILE));
394 }
395 #endif
396
397 #if 0
398 static void TestInvalidNamespace()
399 {
400 mike 1.1 const char* content = "# sample config entry\n"
401 "statik:namespace :Dog,Animal,Base :provider_name\n"
402 ;
403
404 // entry is invalid - expect error back
405
406 ut::writeFileContent( TEMP_FILE, vector<unsigned char>( reinterpret_cast<const unsigned char*>(content),
407 reinterpret_cast<const unsigned char*>(content)+strlen(content)));
408
409 ProvReg reg;
410
411 UT_ASSERT (MI_RESULT_OK == ProvReg_Init(®, TEMP_FILE));
412
413
414 ProvReg_Destroy(®);
415 }
416 #endif
417
418 #if 0
419 static void TestAssociations()
420 {
421 mike 1.1 const char* content = "# sample config entry\n"
422 "# interop namespace\n"
423 "statik:interop: Prov_Profile,CIM_RegisteredProfile,CIM_ManagedElement + "
424 "Prov_ElementConformsToProfile,CIM_ElementConformsToProfile + "
425 "Prov_CS,CIM_ComputerSystem,CIM_ManagedElement:provider_lib\n"
426 "statik:interop: Prov_Profile,CIM_RegisteredProfile,CIM_ManagedElement:provider_lib\n"
427 "# provider impl namespace\n"
428 "statik:provider/impl: Prov_Profile,CIM_RegisteredProfile,CIM_ManagedElement + "
429 "Prov_ElementConformsToProfile,CIM_ElementConformsToProfile +"
430 "Prov_CS,CIM_ComputerSystem,CIM_ManagedElement:provider_lib\n"
431
432 "statik:provider/impl:Prov_CS,CIM_ComputerSystem,CIM_ManagedElement:provider_lib\n"
433 "statik:provider/impl:Prov_CustomCS,Prov_CS,CIM_ComputerSystem,CIM_ManagedElement:provider_lib\n"
434 ;
435
436 // verify inheritance chains:
437 // CIM_ManagedElement -> CIM_RegisteredProfile, Prov_Profile, CIM_ComputerSystem, Prov_CS
438 // CIM_ElementConformsToProfile -> Prov_ElementConformsToProfile
439 // CIM_RegisteredProfile -> Prov_Profile
440 // CIM_ComputerSystem -> Prov_CS
441
442 mike 1.1 ut::writeFileContent( TEMP_FILE, vector<unsigned char>( reinterpret_cast<const unsigned char*>(content),
443 reinterpret_cast<const unsigned char*>(content)+strlen(content)));
444
445 ProvReg reg;
446
447 UT_ASSERT (MI_RESULT_OK == ProvReg_Init(®, TEMP_FILE));
448
449 /////////////////////////////////////////////////////////////////////////////////////////////////
450 // interop
451 // deep == true
452 VerifyInheritanceChain(®, T("interop"), T("CIM_ManagedElement"), MI_TRUE, T("CIM_RegisteredProfile,Prov_Profile,CIM_ComputerSystem,Prov_CS"));
453 VerifyInheritanceChain(®, T("interop"), T("CIM_ElementConformsToProfile"), MI_TRUE, T("Prov_ElementConformsToProfile"));
454 VerifyInheritanceChain(®, T("interop"), T("CIM_RegisteredProfile"), MI_TRUE, T("Prov_Profile"));
455 VerifyInheritanceChain(®, T("interop"), T("CIM_ComputerSystem"), MI_TRUE, T("Prov_CS"));
456
457 // deep == false
458 VerifyInheritanceChain(®, T("interop"), T("CIM_ManagedElement"), MI_FALSE, T("CIM_RegisteredProfile,CIM_ComputerSystem"));
459 VerifyInheritanceChain(®, T("interop"), T("CIM_ElementConformsToProfile"), MI_FALSE, T("Prov_ElementConformsToProfile"));
460 VerifyInheritanceChain(®, T("interop"), T("CIM_RegisteredProfile"), MI_FALSE, T("Prov_Profile"));
461 VerifyInheritanceChain(®, T("interop"), T("CIM_ComputerSystem"), MI_FALSE, T("Prov_CS"));
462
463 mike 1.1 // associations
464 VerifyAssociationChain(®, T("provider/impl"), T("Prov_CustomCS"), 0, 0, T("Prov_ElementConformsToProfile"));
465 VerifyAssociationChain(®, T("provider/impl"), T("Prov_CustomCS"), T("CIM_ElementConformsToProfile"), 0, T("Prov_ElementConformsToProfile"));
466 VerifyAssociationChain(®, T("provider/impl"), T("Prov_CustomCS"), T("CIM_ElementConformsToProfile"), T("CIM_RegisteredProfile"), T("Prov_ElementConformsToProfile"));
467 VerifyAssociationChain(®, T("provider/impl"), T("Prov_CustomCS"), 0, T("CIM_ManagedElement"), T("Prov_ElementConformsToProfile"));
468
469 VerifyAssociationChain(®, T("interop"), T("Prov_Profile"), 0, 0, T("Prov_ElementConformsToProfile"));
470
471 ProvReg_Destroy(®);
472 }
473 #endif
474
475 #if 0
476 static void TestMultipleAssociations()
477 {
478 const char* content = "# sample config entry\n"
479 "statik:ns:B,C+xb+X,Z:provider_lib\n"
480 "statik:ns:B,C+bx+X,Z:provider_lib\n"
481 "statik:ns:B,C+bz+Z:provider_lib\n"
482 "statik:ns:A,B,C:provider_lib\n"
483 "statik:ns:AA,B,C:provider_lib\n"
484 mike 1.1 "statik:ns:AAA,B,C:provider_lib\n"
485 "statik:ns:X,Z + mx,zn + M,N:provider_lib\n"
486 "statik:ns:Z + zn + N:provider_lib\n"
487 ;
488
489 ut::writeFileContent( TEMP_FILE, vector<unsigned char>( reinterpret_cast<const unsigned char*>(content),
490 reinterpret_cast<const unsigned char*>(content)+strlen(content)));
491
492 ProvReg reg;
493
494 UT_ASSERT (MI_RESULT_OK == ProvReg_Init(®, TEMP_FILE));
495
496 // associations
497 VerifyAssociationChain(®, T("ns"), T("AAA"), 0, 0, T("xb,bx,bz"));
498 VerifyAssociationChain(®, T("ns"), T("AAA"), T("bz"), 0, T("bz"));
499 VerifyAssociationChain(®, T("ns"), T("AAA"), 0, T("X"), T("xb,bx,bz"));
500 VerifyAssociationChain(®, T("ns"), T("AAA"), 0, T("Z"), T("xb,bx,bz"));
501
502 VerifyAssociationChain(®, T("ns"), T("X"), 0, 0, T("xb,bx,bz,mx,zn"));
503 VerifyAssociationChain(®, T("ns"), T("Z"), 0, 0, T("bz,zn"));
504 VerifyAssociationChain(®, T("ns"), T("X"), T("zn"), 0, T("mx,zn"));
505 mike 1.1 VerifyAssociationChain(®, T("ns"), T("X"), T("bz"), 0, T("bz"));
506 VerifyAssociationChain(®, T("ns"), T("X"), T("bz"), T("A"), T("bz"));
507
508 VerifyAssociationChain(®, T("ns"), T("C"), 0, 0, T(""));
509 VerifyAssociationChain(®, T("ns"), T("AAA"), T("mx"), 0, T(""));
510
511 ProvReg_Destroy(®);
512 }
513 #endif
514
515 #if 0
516 static void TestAssociationsInvalidClass()
517 {
518 const char* content = "# sample config entry\n"
519 "statik:ns:B,C+xb+X,Z:provider_lib\n"
520 "statik:ns:B,C+bx+X,Z:provider_lib\n"
521 "statik:ns:B,C+bz+Z:provider_lib\n"
522 "statik:ns:A,B,C:provider_lib\n"
523 "statik:ns:AA,B,C:provider_lib\n"
524 "statik:ns:AAA,B,C:provider_lib\n"
525 "statik:ns:X,Z + mx,zn + M,N:provider_lib\n"
526 mike 1.1 "statik:ns:Z + zn + N:provider_lib\n"
527 ;
528
529 ut::writeFileContent( TEMP_FILE, vector<unsigned char>( reinterpret_cast<const unsigned char*>(content),
530 reinterpret_cast<const unsigned char*>(content)+strlen(content)));
531
532 ProvReg reg;
533
534 UT_ASSERT (MI_RESULT_OK == ProvReg_Init(®, TEMP_FILE));
535
536 ProvRegAssocPosition pos;
537
538 UT_ASSERT (MI_RESULT_INVALID_NAMESPACE == ProvReg_BeginAssocClasses( ®, T("notExistingNamespace"), T("X"), 0, 0, &pos ));
539 UT_ASSERT (MI_RESULT_INVALID_CLASS == ProvReg_BeginAssocClasses( ®, T("ns"), T("noExisitingClass"), 0, 0, &pos ));
540 UT_ASSERT (MI_RESULT_INVALID_CLASS == ProvReg_BeginAssocClasses( ®, T("ns"), T("AA"), T("noExisitingClass"), 0, &pos ));
541 UT_ASSERT (MI_RESULT_INVALID_CLASS == ProvReg_BeginAssocClasses( ®, T("ns"), T("AA"), 0, T("noExisitingClass"), &pos ));
542
543 ProvReg_Destroy(®);
544 }
545 #endif
546
547 mike 1.1 #if 0
548 static void TestAssociationsToTheSameClass()
549 {
550 const char* content = "# sample config entry\n"
551 "statik:ns:X+a+X:provider_lib\n"
552 ;
553
554 ut::writeFileContent( TEMP_FILE, vector<unsigned char>( reinterpret_cast<const unsigned char*>(content),
555 reinterpret_cast<const unsigned char*>(content)+strlen(content)));
556
557 ProvReg reg;
558
559 UT_ASSERT (MI_RESULT_OK == ProvReg_Init(®, TEMP_FILE));
560
561 // associations
562 VerifyAssociationChain(®, T("ns"), T("X"), 0, 0, T("a"));
563
564 ProvReg_Destroy(®);
565 }
566 #endif
567
568 mike 1.1 #if 0
569 static void TestProvRegHosting()
570 {
571 const char* content = "# sample config entry\n"
572 "statik:ns:Default:provider_lib\n"
573 "statik:ns:Inproc:provider_lib:@inproc@\t \n"
574 "statik:ns:Requestor:provider_lib:\t@requestor@\n"
575 "statik:ns:User:provider_lib:a_user \n"
576 ;
577
578 ut::writeFileContent( TEMP_FILE, vector<unsigned char>( reinterpret_cast<const unsigned char*>(content),
579 reinterpret_cast<const unsigned char*>(content)+strlen(content)));
580
581 ProvReg reg;
582
583 UT_ASSERT (MI_RESULT_OK == ProvReg_Init(®, TEMP_FILE));
584
585 // verify hosting types are set correctly
586 const ProvRegEntry* regItem;
587
588 regItem = ProvReg_FindProviderForClass(®, T("ns"), T("Default"));
589 mike 1.1 UT_ASSERT(regItem);
590 UT_ASSERT(regItem->hosting == PROV_HOSTING_INPROC);
591 UT_ASSERT(regItem->user == 0);
592
593 regItem = ProvReg_FindProviderForClass(®, T("ns"), T("Inproc"));
594 UT_ASSERT(regItem);
595 UT_ASSERT(regItem->hosting == PROV_HOSTING_INPROC);
596 UT_ASSERT(regItem->user == 0);
597
598 regItem = ProvReg_FindProviderForClass(®, T("ns"), T("Requestor"));
599 UT_ASSERT(regItem);
600 UT_ASSERT(regItem->hosting == PROV_HOSTING_REQUESTOR);
601 UT_ASSERT(regItem->user == 0);
602
603 regItem = ProvReg_FindProviderForClass(®, T("ns"), T("user"));
604 UT_ASSERT(regItem);
605 UT_ASSERT(regItem->hosting == PROV_HOSTING_USER);
606 UT_ASSERT(regItem->user != 0);
607 UT_ASSERT(string(regItem->user) == "a_user");
608
609 ProvReg_Destroy(®);
610 mike 1.1 }
611 #endif
612
613 static void TestRegFile()
614 {
615 RegFile* rf = RegFile_New(
616 "./provreg/omiregister/root#cimv2/ConnectorProviderCXX.reg");
617 UT_ASSERT(rf != NULL);
618
619 #if 0
620 RegFile_Print(rf, stdout);
621 #endif
622
623 RegFile_Delete(rf);
624 }
625
626 static void TestRegNameSpaces()
627 {
628 vector<string> expected;
629 vector<string> names;
630
631 mike 1.1 Dir* dir = Dir_Open("./provreg/omiregister");
632 UT_ASSERT(dir != NULL);
633
634 for (;;)
635 {
636 DirEnt *ent = Dir_Read(dir);
637 if (!ent)
638 break;
639
640 if (strcmp(ent->name, "..") == 0 || strcmp(ent->name, ".") == 0)
641 continue;
642
643 if (strcmp(ent->name, "CVS") == 0)
644 continue;
645
646 names.push_back(ent->name);
647 }
648
649 Dir_Close(dir);
650
651 expected.push_back("interop");
652 mike 1.1 expected.push_back("root");
653 expected.push_back("root#cimv2");
654
655 UT_ASSERT(names.size() == 3);
656 UT_ASSERT(expected.size() == 3);
657
658 sort(names.begin(), names.end());
659 sort(expected.begin(), expected.end());
660 UT_ASSERT(names == expected);
661 }
662
663 #if defined(CONFIG_POSIX)
664 static void TestProvReg2()
665 {
666 ProvReg provReg;
667 MI_Result r = ProvReg_Init2(&provReg);
668 UT_ASSERT(r == MI_RESULT_OK);
669
670 ProvReg_Destroy(&provReg);
671 }
672 #endif
673 mike 1.1
674 static void RunTests()
675 {
676 // ATTN: These tests tested the now obsolete omiregister.conf.
677 #if 0
678 UT_TEST(TestProvReg);
679 UT_TEST(TestProvRegInvalidConfigFile);
680 UT_TEST(TestClassInheritanceTreeMultipleDerived);
681 UT_TEST(TestInvalidClassInheritanceTree);
682 UT_TEST(TestInvalidNamespace);
683 UT_TEST(TestAssociations);
684 UT_TEST(TestMultipleAssociations);
685 UT_TEST(TestAssociationsInvalidClass);
686 UT_TEST(TestAssociationsToTheSameClass);
687 UT_TEST(TestProvRegHosting);
688 #endif
689 UT_TEST(TestRegFile);
690 UT_TEST(TestRegNameSpaces);
691 #if defined(CONFIG_POSIX)
692 UT_TEST(TestProvReg2);
693 #endif
694 mike 1.1 }
695
696 UT_ENTRY_POINT(RunTests);
|
Return to
test_provreg.cpp
CVS log
Up to [OMI] / omi / provreg / tests