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