1 krisbash 1.1 /*============================================================================
2 * Copyright (C) Microsoft Corporation, All rights reserved.
3 *============================================================================
4 */
5 #include <ut/ut.h>
6 #include <MI.h>
7 #include <miapi/Application.h>
8 #include <pal/lock.h>
9 #include <pal/atomic.h>
10 #include <pal/sem.h>
11 #include <miapi/Options.h>
12 #include <tests/util/util.h>
13
14 extern "C"
15 {
16 MI_Result OperationOptions_MigrateOptions(
17 _In_opt_ MI_OperationOptions *sourceOperation,
18 _Out_ MI_OperationOptions *destination);
19 }
20
21 struct _TestProtocolHandler
22 krisbash 1.1 {
23 const char *protocolHandlerName;
24 const MI_Char *protocolHandlerName_w;
25 const char *protocolHandlerDll;
26 const char *protocolHandlerEntryPoint;
27 };
28
29 const struct _TestProtocolHandler g_test1Transport =
30 {
31 "Test1",
32 PAL_T("Test1"),
33 #if defined(_MSC_VER)
34 "test_miapi.dll",
35 #else
36 "libtest_miapi."CONFIG_SHLIBEXT,
37 #endif
38 "Test1_Application_Initialize"
39 } ;
40
41 const struct _TestProtocolHandler g_test2Transport =
42 {
43 krisbash 1.1 "Test2",
44 PAL_T("Test2"),
45 #if defined(_MSC_VER)
46 "test_miapi.dll",
47 #else
48 "libtest_miapi."CONFIG_SHLIBEXT,
49 #endif
50 "Test2_Application_Initialize"
51 } ;
52
53
54 MI_OperationCallback_ResponseType g_WriteErrorResponseType = MI_OperationCallback_ResponseType_Yes;
55 MI_OperationCallback_ResponseType g_PromptUserResponseType = MI_OperationCallback_ResponseType_Yes;
56
57 extern "C" MI_CONST MI_ClassDecl MyClass_rtti;
58
59 /* in order to link to test_util.lib */
60 Batch* g_batch;
61 FILE* g_logfile;
62 char* g_dirpath;
63
64 krisbash 1.1 MI_Instance *TestCreateInstance(_Inout_ MI_Application *application, _In_z_ const MI_Char *className)
65 {
66 MI_Instance *instance = NULL;
67 if (NitsAssert(MI_Application_NewInstance(application, className, NULL, &instance) == MI_RESULT_OK, PAL_T("failed to create instance")))
68 {
69 MI_Value value;
70 value.uint32 = 1;
71
72 NitsAssert(MI_Instance_AddElement(instance, PAL_T("key"), &value, MI_UINT32, MI_FLAG_KEY)==MI_RESULT_OK, PAL_T("Failed to add property to instance"));
73 }
74 return instance;
75 }
76
77 extern "C" MI_Module* MI_MAIN_CALL MyProvFunction(MI_Server* server)
78 {
79 return NULL;
80 }
81
82 struct RuntimeTestData
83 {
84 const struct _TestProtocolHandler *transport;
85 krisbash 1.1
86 MI_Application application;
87 MI_Session session;
88 MI_Instance *testInstance;
89
90 ptrdiff_t sessionCloseFinished;
91 volatile ptrdiff_t operationFinished;
92 MI_Result finialResult;
93
94 ptrdiff_t session_writeErrorCount;
95 ptrdiff_t session_writeMessageCount;
96
97 ptrdiff_t instanceCount;
98 ptrdiff_t classCount;
99 ptrdiff_t indicationCount;
100 ptrdiff_t methodCount;
101 ptrdiff_t promptUserCount;
102 ptrdiff_t writeErrorCount;
103 ptrdiff_t writeMessageCount;
104 ptrdiff_t writeProgressCount;
105 ptrdiff_t streamedParameterCount;
106 krisbash 1.1 };
107
108 // This function resets all counters/flags inside runtime test data
109 // it is called from beginning of test body for every test which uses this data
110 // Ideally it should not be required but since nits does not run setup fixtures during fault injection
111 // we need to initialize this data ourselves again in the body
112 // supporting running entire test including setup's is a TODO feature request for nits
113 extern "C" void ResetRuntimeTestData(struct RuntimeTestData *data)
114 {
115 data->sessionCloseFinished = 0;
116 data->operationFinished = 0;
117 data->finialResult = MI_RESULT_OK;
118 data->session_writeErrorCount = 0;
119 data->session_writeMessageCount = 0;
120 data->instanceCount = 0;
121 data->classCount = 0;
122 data->indicationCount = 0;
123 data->methodCount = 0;
124 data->promptUserCount = 0;
125 data->writeErrorCount = 0;
126 data->writeMessageCount = 0;
127 krisbash 1.1 data->writeProgressCount = 0;
128 data->streamedParameterCount = 0;
129 }
130
131 NitsSetup0(BaseSetup, RuntimeTestData)
132 {
133 }
134 NitsEndSetup
135
136 struct RuntimeApplicationSetup
137 {
138 const struct _TestProtocolHandler *transport;
139 };
140 struct RuntimeApplicationSetup g_RuntimeApplicationSetup_Test1 = { &g_test1Transport };
141 struct RuntimeApplicationSetup g_RuntimeApplicationSetup_Test2 = { &g_test2Transport };
142
143 NitsSetup1(SetupDefaultApplication, RuntimeApplicationSetup,
144 BaseSetup, BaseSetupDefaults)
145 {
146 MI_Application *application = &NitsContext()->_BaseSetup->_RuntimeTestData->application;
147 const struct _TestProtocolHandler *transport = NitsContext()->_RuntimeApplicationSetup->transport;
148 krisbash 1.1
149 NitsContext()->_BaseSetup->_RuntimeTestData->transport = transport;
150
151 if (NitsCompare(MI_Application_Initialize(0, NULL, NULL, application), MI_RESULT_OK, PAL_T("MI_Application_Initialize returns OK")))
152 {
153 if (NitsAssert(application->ft != NULL, PAL_T("MI_Application_Initialize returns object with function table")))
154 {
155 NitsCompare(Application_SetTestTransport(application, transport->protocolHandlerName, transport->protocolHandlerDll, transport->protocolHandlerEntryPoint, 1, 1, MI_TRUE, MI_TRUE), MI_RESULT_OK, PAL_T("Failed to set test transport"));
156 }
157 }
158 }
159 NitsEndSetup
160
161 NitsCleanup(SetupDefaultApplication)
162 {
163 MI_Application *application = &NitsContext()->_BaseSetup->_RuntimeTestData->application;
164 NitsCompare(MI_Application_Close(application), MI_RESULT_OK, PAL_T("Failed to close MI_Application"));
165 }
166 NitsEndCleanup
167
168
169 krisbash 1.1 NitsSetup1(SetupDefaultSession, NitsEmptyStruct,
170 BaseSetup, BaseSetupDefaults)
171 {
172 MI_Application *application = &NitsContext()->_BaseSetup->_RuntimeTestData->application;
173 MI_Session *session = &NitsContext()->_BaseSetup->_RuntimeTestData->session;
174 const struct _TestProtocolHandler *transport = NitsContext()->_BaseSetup->_RuntimeTestData->transport;
175
176 if (NitsCompare(MI_Application_NewSession(application, transport->protocolHandlerName_w, NULL, NULL, NULL, NULL, session), MI_RESULT_OK, PAL_T("MI_Application_NewSession returns OK")) &&
177 NitsAssert(session->ft != NULL, PAL_T("MI_Session function table should not be NULL")))
178 {
179 }
180 }
181 NitsEndSetup
182
183 NitsCleanup(SetupDefaultSession)
184 {
185 MI_Session *session = &NitsContext()->_BaseSetup->_RuntimeTestData->session;
186 NitsCompare(MI_Session_Close(session, NULL, NULL), MI_RESULT_OK, PAL_T("Failed to close MI_Session"));
187 }
188 NitsEndCleanup
189
190 krisbash 1.1
191 struct SetupTestInstance_Data
192 {
193 const MI_Char *className;
194 };
195
196 SetupTestInstance_Data g_SetupTestInstance_test = { PAL_T("test") };
197 SetupTestInstance_Data g_SetupTestInstance_DeliverResultDifferentThread = { PAL_T("DeliverResultDifferentThread") };
198 SetupTestInstance_Data g_SetupTestInstance_NoResult = { PAL_T("NoResult") };
199
200 NitsSetup1(SetupTestInstance, SetupTestInstance_Data,
201 BaseSetup, BaseSetupDefaults)
202 {
203 MI_Application *application = &NitsContext()->_BaseSetup->_RuntimeTestData->application;
204 const MI_Char *className = NitsContext()->_SetupTestInstance_Data->className;
205 NitsContext()->_BaseSetup->_RuntimeTestData->testInstance = TestCreateInstance(application, className);
206 }
207 NitsEndSetup
208
209 NitsCleanup(SetupTestInstance)
210 {
211 krisbash 1.1 MI_Instance *instance = NitsContext()->_BaseSetup->_RuntimeTestData->testInstance;
212 NitsCompare(MI_Instance_Delete(instance), MI_RESULT_OK, PAL_T("Failed to delete instace"));
213 }
214 NitsEndCleanup
215
216 /*==========================================================================================*/
217 /*==========================================================================================*/
218 /*==========================================================================================*/
219 /*============================= MI_Application tests =======================================*/
220 /*==========================================================================================*/
221 /*==========================================================================================*/
222 /*==========================================================================================*/
223
224 /* Manually test successful MI_Application_Initialize and then close it */
225 NitsTest(MI_Application_Initialize_Success)
226 {
227 MI_Application application = MI_APPLICATION_NULL;
228 NitsCompare(MI_Application_Initialize(0, NULL, NULL, &application), MI_RESULT_OK, PAL_T("MI_Application_Initialize returns OK"));
229 NitsAssert(application.ft != NULL, PAL_T("MI_Application function table should not be NULL"));
230 MI_Application_Close(&application);
231
232 krisbash 1.1 NitsCompare(MI_Application_Initialize(0, PAL_T("My application ID"), NULL, &application), MI_RESULT_OK, PAL_T("MI_Application_Initialize returns OK"));
233 NitsAssert(application.ft != NULL, PAL_T("MI_Application function table should not be NULL"));
234 MI_Application_Close(&application);
235 }
236 NitsEndTest
237
238 /* Test invalid parameters for MI_Application_Initialize */
239 NitsTest(MI_Application_Initialize_InvalidParameters)
240 {
241 MI_Application application = MI_APPLICATION_NULL;
242 MI_Instance *extendedError = NULL;
243
244 #if defined (_MSC_VER)
245 #pragma prefast(push)
246 #pragma prefast(disable: 6309)
247 #endif
248 NitsCompare(MI_Application_Initialize(0, NULL, NULL, NULL), MI_RESULT_INVALID_PARAMETER, PAL_T("MI_Application_Initialize returns INVALID_PARAMETER"));
249 NitsCompare(MI_Application_Initialize(25, NULL, NULL, &application), MI_RESULT_INVALID_PARAMETER, PAL_T("MI_Application_Initialize returns INVALID_PARAMETER"));
250 MI_Application_Close(&application);
251 NitsCompare(MI_Application_InitializeV1(25, NULL, &extendedError, &application), MI_RESULT_INVALID_PARAMETER, PAL_T("MI_Application_Initialize returns INVALID_PARAMETER"));
252 #if defined (_MSC_VER)
253 krisbash 1.1 #pragma prefast(pop)
254 #endif
255 if (extendedError)
256 {
257 MI_Instance_Delete(extendedError);
258 }
259 MI_Application_Close(&application);
260 }
261 NitsEndTest
262
263 /* Test invalid parameters for MI_Application_Close */
264 NitsTest(MI_Application_Close_InvalidParameters)
265 {
266 MI_Application application = MI_APPLICATION_NULL;
267 NitsCompare(MI_Application_Initialize(0, NULL, NULL, &application), MI_RESULT_OK, PAL_T("MI_Application_Initialize returns OK"));
268 NitsAssert(application.ft != NULL, PAL_T("MI_Application function table should not be NULL"));
269
270 if (application.ft == NULL)
271 NitsReturn;
272
273 const MI_ApplicationFT * const copyFT = application.ft;
274 krisbash 1.1
275 #if defined (_MSC_VER)
276 #pragma prefast(push)
277 #pragma prefast(disable: 6309)
278 #endif
279 MI_Application_Close(NULL);
280 application.ft->Close(NULL);
281 #if defined (_MSC_VER)
282 #pragma prefast(pop)
283 #endif
284
285 MI_Application_Close(&application);
286
287 NitsAssert(application.ft == NULL, PAL_T("MI_Application function table should be NULL"));
288
289 #if defined (_MSC_VER)
290 #pragma prefast(push)
291 #pragma prefast(disable: 6309)
292 #endif
293 copyFT->Close(&application);
294 #if defined (_MSC_VER)
295 krisbash 1.1 #pragma prefast(pop)
296 #endif
297 }
298 NitsEndTest
299
300 /*==========================================================================================*/
301 /*==========================================================================================*/
302 /*==========================================================================================*/
303 /*===================== MI_Application_NewHostedProvider tests =============================*/
304 /*==========================================================================================*/
305 /*==========================================================================================*/
306 /*==========================================================================================*/
307
308 /* Test success case for MI_Application_NewHostedProvider */
309 NitsTest1(MI_Application_NewHostedProvider_Success,
310 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1)
311 {
312 MI_Application *application = &NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData->application;
313 MI_HostedProvider hostedProvider = MI_HOSTEDPROVIDER_NULL;
314 MI_Application parentApplication = MI_APPLICATION_NULL;
315
316 krisbash 1.1 if (NitsCompare(MI_Application_NewHostedProvider(application, PAL_T("root\\cimv2"), PAL_T("MyProvider"), MyProvFunction, NULL, &hostedProvider), MI_RESULT_OK, PAL_T("MI_Application_NewHostedProvider returns OK")))
317 {
318 MI_HostedProvider_GetApplication(&hostedProvider, &parentApplication);
319 NitsAssert(application->ft == parentApplication.ft, PAL_T("function tables should be same"));
320 NitsAssert(application->reserved1 == parentApplication.reserved1, PAL_T("reserved1 should be same"));
321 NitsAssert(application->reserved2 == parentApplication.reserved2, PAL_T("reserved2 should be same"));
322 MI_HostedProvider_Close(&hostedProvider);
323 }
324 }
325 NitsEndTest
326
327 /* Test invalid parameter cases for MI_Application_NewHostedProvider */
328 NitsTest1(MI_Application_NewHostedProvider_InvalidParameters,
329 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1)
330 {
331 MI_Application *application = &NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData->application;
332 MI_HostedProvider hostedProvider = MI_HOSTEDPROVIDER_NULL;
333 MI_Application parentApplication = MI_APPLICATION_NULL;
334
335 NitsCompare(application->ft->NewHostedProvider(NULL, PAL_T("root\\cimv2"), PAL_T("MyProvider"), MyProvFunction, NULL, &hostedProvider), MI_RESULT_INVALID_PARAMETER, PAL_T("MI_Application_NewHostedProvider invalid parameter"));
336 NitsCompare(application->ft->NewHostedProvider(application, NULL, PAL_T("MyProvider"), MyProvFunction, NULL, &hostedProvider), MI_RESULT_INVALID_PARAMETER, PAL_T("MI_Application_NewHostedProvider invalid parameter"));
337 krisbash 1.1 NitsCompare(application->ft->NewHostedProvider(application, PAL_T("root\\cimv2"), NULL, MyProvFunction, NULL, &hostedProvider), MI_RESULT_INVALID_PARAMETER, PAL_T("MI_Application_NewHostedProvider invalid parameter"));
338 NitsCompare(application->ft->NewHostedProvider(application, PAL_T("root\\cimv2"), PAL_T("MyProvider"), NULL, NULL, &hostedProvider), MI_RESULT_INVALID_PARAMETER, PAL_T("MI_Application_NewHostedProvider invalid parameter"));
339 NitsCompare(application->ft->NewHostedProvider(application, PAL_T("root\\cimv2"), PAL_T("MyProvider"), MyProvFunction, NULL, NULL), MI_RESULT_INVALID_PARAMETER, PAL_T("MI_Application_NewHostedProvider invalid parameter"));
340
341
342 if (NitsCompare(application->ft->NewHostedProvider(application, PAL_T("root\\cimv2"), PAL_T("MyProvider"), MyProvFunction, NULL, &hostedProvider), MI_RESULT_OK, PAL_T("MI_Application_NewHostedProvider Succeeds")) &&
343 NitsAssert(hostedProvider.ft != NULL, PAL_T("Failed to get function table")))
344 {
345 #if defined (_MSC_VER)
346 #pragma prefast(push)
347 #pragma prefast(disable: 6011)
348 #endif
349 hostedProvider.ft->GetApplication(NULL, &parentApplication);
350 hostedProvider.ft->GetApplication(&hostedProvider, NULL);
351 hostedProvider.ft->Close(&hostedProvider);
352 hostedProvider.ft->Close(NULL);
353 #if defined (_MSC_VER)
354 #pragma prefast(pop)
355 #endif
356 }
357 }
358 krisbash 1.1 NitsEndTest
359
360 /*==========================================================================================*/
361 /*==========================================================================================*/
362 /*==========================================================================================*/
363 /*================================= MI_Session tests =======================================*/
364 /*==========================================================================================*/
365 /*==========================================================================================*/
366 /*==========================================================================================*/
367
368 /* Test creation of a session, then close it synchronously */
369 NitsTest1(MI_Application_NewSession_Success_CloseSync,
370 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1)
371 {
372 MI_Application *application = &NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData->application;
373 MI_Session session = MI_SESSION_NULL;
374
375 NitsCompare(MI_Application_NewSession(application, PAL_T("Test1"), NULL, NULL, NULL, NULL, &session), MI_RESULT_OK, PAL_T("MI_Application_NewSession returns OK"));
376 NitsAssert(session.ft != NULL, PAL_T("MI_Session function table should not be NULL"));
377
378 MI_Session_Close(&session, NULL, NULL);
379 krisbash 1.1 }
380 NitsEndTest
381
382 /* Test creation of session, then close asynchronously */
383 extern "C" void MI_CALL Test_Sesson_CloseAync_Callback(void *context)
384 {
385 ptrdiff_t *wait = (ptrdiff_t*) context;
386 *wait = 1;
387 CondLock_Broadcast((ptrdiff_t) &wait);
388 }
389
390 NitsTest1(MI_Application_NewSession_Success_CloseAsync,
391 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1)
392 {
393 MI_Application *application = &NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData->application;
394 MI_Session session = MI_SESSION_NULL;
395 volatile ptrdiff_t wait = 0;
396
397 NitsCompare(MI_Application_NewSession(application, PAL_T("Test1"), NULL, NULL, NULL, NULL, &session), MI_RESULT_OK, PAL_T("MI_Application_NewSession returns OK"));
398 NitsAssert(session.ft != NULL, PAL_T("MI_Session function table should not be NULL"));
399
400 krisbash 1.1 MI_Session_Close(&session, (void*) &wait, Test_Sesson_CloseAync_Callback);
401
402 ptrdiff_t currentWait = wait;
403 while (!currentWait)
404 {
405 CondLock_Wait((ptrdiff_t)&wait, &wait, currentWait, CONDLOCK_DEFAULT_SPINCOUNT);
406 currentWait = wait;
407 }
408 }
409 NitsEndTest
410
411 /* Test creation of session with destination options */
412 NitsTest1(MI_Application_NewSession_Success_Options,
413 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1)
414 {
415 MI_Application *application = &NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData->application;
416 MI_Session session = MI_SESSION_NULL;
417 MI_DestinationOptions options = MI_DESTINATIONOPTIONS_NULL;
418
419 if (NitsCompare(MI_Application_NewDestinationOptions(application, &options), MI_RESULT_OK, PAL_T("NewDestinationOptions should succeed")))
420 {
421 krisbash 1.1 if (NitsAssert(options.ft != NULL, PAL_T("Should have options function table")))
422 {
423 MI_UserCredentials creds = { 0 };
424 creds.authenticationType = MI_AUTH_TYPE_BASIC;
425 creds.credentials.usernamePassword.username = PAL_T("username");
426 creds.credentials.usernamePassword.domain = PAL_T("domain");
427 creds.credentials.usernamePassword.password = PAL_T("password");
428
429 NitsCompare(options.ft->SetString(&options, PAL_T("option1"), PAL_T("value1"), 0), MI_RESULT_OK, PAL_T("SetString should work"));
430 NitsCompare(options.ft->SetNumber(&options, PAL_T("option2"), 22, 0), MI_RESULT_OK, PAL_T("SetNumber should work"));
431 NitsCompare(options.ft->AddCredentials(&options, PAL_T("option3"), &creds, 0), MI_RESULT_OK, PAL_T("AddCredentials should work"));
432
433 NitsCompare(MI_Application_NewSession(application, PAL_T("Test1"), NULL, &options, NULL, NULL, &session), MI_RESULT_OK, PAL_T("MI_Application_NewSession returns OK"));
434 NitsAssert(session.ft != NULL, PAL_T("MI_Session function table should not be NULL"));
435
436 MI_Session_Close(&session, NULL, NULL);
437 }
438 MI_DestinationOptions_Delete(&options);
439 }
440 }
441 NitsEndTest
442 krisbash 1.1
443 /* test session creation with a destination machine name */
444 NitsTest1(MI_Application_NewSession_WithRemoteMachine,
445 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1)
446 {
447 MI_Application *application = &NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData->application;
448 MI_Session session = MI_SESSION_NULL;
449
450 NitsCompare(MI_Application_NewSession(application, PAL_T("Test1"), PAL_T("destination"), NULL, NULL, NULL, &session), MI_RESULT_OK, PAL_T("MI_Application_NewSession returns OK"));
451 NitsAssert(session.ft != NULL, PAL_T("MI_Session function table should not be NULL"));
452
453 MI_Session_Close(&session, NULL, NULL);
454 }
455 NitsEndTest
456
457 /* test session creation with invalid parameters */
458 NitsTest1(MI_Application_NewSession_InvalidParameters,
459 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1)
460 {
461 MI_Application *application = &NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData->application;
462 MI_Session session = MI_SESSION_NULL;
463 krisbash 1.1
464 NitsCompare(application->ft->NewSession(NULL, NULL, NULL, NULL, NULL, NULL, &session), MI_RESULT_INVALID_PARAMETER, PAL_T("NewSession should fail due to null application"));
465 MI_Session_Close(&session, NULL, NULL);
466
467 NitsCompare(application->ft->NewSession(application, NULL, NULL, NULL, NULL, NULL, NULL), MI_RESULT_INVALID_PARAMETER, PAL_T("NewSession should fail due to null session"));
468 }
469 NitsEndTest
470
471 extern "C" void MI_CALL Application_NewSession_PSSemantics_writeMessage(
472 _In_ MI_Application *application,
473 _In_opt_ void *callbackContext,
474 MI_Uint32 channel,
475 _In_z_ const MI_Char * message)
476 {
477 NitsAssert(application != NULL, PAL_T("session_writeMessage: application null"));
478 NitsAssert(message != NULL, PAL_T("session_writeMessage: message null"));
479 }
480
481 extern "C" void MI_CALL Application_NewSession_PSSemantics_writeError(
482 _In_ MI_Application *application,
483 _In_opt_ void *callbackContext,
484 krisbash 1.1 _In_ MI_Instance *instance)
485 {
486 NitsAssert(application != NULL, PAL_T("session_writeMessage: application null"));
487 }
488
489 NitsTest1(Application_NewSession_PSSemantics,
490 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1)
491 {
492 MI_Application *application = &NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData->application;
493 MI_Session session = MI_SESSION_NULL;
494 MI_SessionCallbacks callbacks = MI_SESSIONCALLBACKS_NULL;
495 callbacks.writeError = Application_NewSession_PSSemantics_writeError;
496 callbacks.writeMessage = Application_NewSession_PSSemantics_writeMessage;
497
498
499 if(NitsCompare(application->ft->NewSession(application, PAL_T("Test1"), NULL, NULL, &callbacks, NULL, &session), MI_RESULT_OK, PAL_T("NewSession should succeed")))
500 {
501 MI_Session_Close(&session, NULL, NULL);
502 }
503 }
504 NitsEndTest
505 krisbash 1.1
506 NitsTest1(MI_Session_GetParent,
507 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1)
508 {
509 MI_Application *application = &NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData->application;
510 MI_Application testApplication = MI_APPLICATION_NULL;
511 MI_Session session = MI_SESSION_NULL;
512
513 if (NitsCompare(MI_Application_NewSession(application, PAL_T("Test1"), NULL, NULL, NULL, NULL, &session), MI_RESULT_OK, PAL_T("MI_Application_NewSession returns OK")))
514 {
515 NitsAssert(session.ft != NULL, PAL_T("MI_Session function table should not be NULL"));
516
517 MI_Session_GetApplication(&session, &testApplication);
518
519 NitsAssert(memcmp(application, &testApplication, sizeof(MI_Application))==0, PAL_T("applications should be same"));
520
521 MI_Session_Close(&session, NULL, NULL);
522 }
523 }
524 NitsEndTest
525
526 krisbash 1.1 /*==========================================================================================*/
527 /*==========================================================================================*/
528 /*==========================================================================================*/
529 /*======================= MI_Application_NewInstance tests =================================*/
530 /*==========================================================================================*/
531 /*==========================================================================================*/
532 /*==========================================================================================*/
533
534 NitsTest1(MI_Application_NewInstance_Success,
535 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1)
536 {
537 MI_Application *application = &NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData->application;
538 MI_Instance *instance;
539
540 instance = TestCreateInstance(application, PAL_T("MyClass"));
541 if (NitsAssert(instance!=NULL, PAL_T("MI_Application_NewInstance should succeed")))
542 {
543 NitsAssert(instance->ft != NULL, PAL_T("MI_instance function table should not be NULL"));
544
545 MI_Instance_Delete(instance);
546 }
547 krisbash 1.1 }
548 NitsEndTest
549
550 NitsTest1(MI_Application_NewInstance_WithRTTI_Success,
551 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1)
552 {
553 MI_Application *application = &NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData->application;
554 MI_Instance *instance = NULL;
555
556 if (NitsCompare(MI_Application_NewInstance(application, PAL_T("MyClass"), &MyClass_rtti, &instance), MI_RESULT_OK, PAL_T("MI_Application_NewInstance returns OK")))
557 {
558 NitsAssert(instance->ft != NULL, PAL_T("MI_instance function table should not be NULL"));
559
560 MI_Instance_Delete(instance);
561 }
562 }
563 NitsEndTest
564
565 NitsTest1(MI_Application_NewInstance_InvalidParameters,
566 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1)
567 {
568 krisbash 1.1 MI_Application *application = &NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData->application;
569 MI_Instance *instance;
570
571 NitsCompare(application->ft->NewInstance(NULL, PAL_T("MyClass"), NULL, &instance), MI_RESULT_INVALID_PARAMETER, PAL_T("NewInstance should fail due to null application"));
572 NitsCompare(application->ft->NewInstance(application, NULL, NULL, &instance), MI_RESULT_INVALID_PARAMETER, PAL_T("NewInstance should fail due to null class name"));
573 NitsCompare(application->ft->NewInstance(application, PAL_T("MyClass"), NULL, NULL), MI_RESULT_INVALID_PARAMETER, PAL_T("NewInstance should fail due to null instance"));
574 }
575 NitsEndTest
576
577
578 /*==========================================================================================*/
579 /*==========================================================================================*/
580 /*==========================================================================================*/
581 /*================== MI_Application_NewDestinationOptions tests ============================*/
582 /*==========================================================================================*/
583 /*==========================================================================================*/
584 /*==========================================================================================*/
585
586 NitsTest1(MI_Application_NewDestinationOptions_All,
587 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1)
588 {
589 krisbash 1.1 MI_Application *application = &NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData->application;
590 MI_DestinationOptions options = MI_DESTINATIONOPTIONS_NULL;
591
592 #if defined (_MSC_VER)
593 #pragma prefast(push)
594 #pragma prefast(disable: 6309)
595 #endif
596 NitsCompare(MI_Application_NewDestinationOptions(NULL, &options), MI_RESULT_INVALID_PARAMETER, PAL_T("NewDestinationOptions invalid parameter"));
597 NitsCompare(MI_Application_NewDestinationOptions(application, NULL), MI_RESULT_INVALID_PARAMETER, PAL_T("NewDestinationOptions invalid parameter"));
598 #if defined (_MSC_VER)
599 #pragma prefast(pop)
600 #endif
601
602 if (NitsCompare(MI_Application_NewDestinationOptions(application, &options), MI_RESULT_OK, PAL_T("NewDestinationOptions should succeed")))
603 {
604 NitsAssert(options.ft != NULL, PAL_T("Should have options function table"));
605 if (options.ft != NULL)
606 {
607 NitsCompare(options.ft->SetString(&options, PAL_T("option1"), PAL_T("value1"), 0), MI_RESULT_OK, PAL_T("SetString should work"));
608 NitsCompare(options.ft->SetString(&options, PAL_T("option1"), PAL_T("value1"), 0), MI_RESULT_OK, PAL_T("SetString should work"));
609 NitsCompare(options.ft->SetString(&options, PAL_T("option1"), PAL_T("value1"), 0), MI_RESULT_OK, PAL_T("SetString should work"));
610 krisbash 1.1 NitsCompare(options.ft->SetString(&options, PAL_T("option1"), PAL_T("value22"), 0), MI_RESULT_OK, PAL_T("SetString should work"));
611 NitsCompare(options.ft->SetString(&options, PAL_T("option1"), PAL_T("value1"), 22), MI_RESULT_INVALID_PARAMETER, PAL_T("SetString invalid parameter"));
612 NitsCompare(options.ft->SetString(&options, PAL_T("option1"), NULL, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("SetString invalid parameter"));
613 NitsCompare(options.ft->SetString(&options, NULL, PAL_T("value1"), 0), MI_RESULT_INVALID_PARAMETER, PAL_T("SetString invalid parameter"));
614
615 NitsCompare(options.ft->SetNumber(&options, PAL_T("option2"), 33, 0), MI_RESULT_OK, PAL_T("SetNumber should work"));
616 NitsCompare(options.ft->SetNumber(&options, PAL_T("option2"), 22, 0), MI_RESULT_OK, PAL_T("SetNumber should work"));
617 NitsCompare(options.ft->SetNumber(&options, NULL, 22, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("SetNumber invalid parameter"));
618 NitsCompare(options.ft->SetNumber(&options, PAL_T("option2"), 22, 22), MI_RESULT_INVALID_PARAMETER, PAL_T("SetNumber invalid parameter"));
619
620 {
621 NitsCompare(options.ft->AddCredentials(&options, PAL_T("option3"), NULL, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("AddCredentials should fail"));
622 }
623 {
624 MI_UserCredentials creds = { MI_AUTH_TYPE_BASIC, {{ PAL_T("domain"), NULL, PAL_T("password") } }};
625 NitsCompare(options.ft->AddCredentials(&options, PAL_T("option3"), &creds, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("AddCredentials invalid parameter"));
626 }
627 {
628 MI_UserCredentials creds = { MI_AUTH_TYPE_BASIC, { { PAL_T("domain"), PAL_T("username"), PAL_T("password") } } };
629 NitsCompare(options.ft->AddCredentials(&options, PAL_T("option3"), &creds, 0), MI_RESULT_OK, PAL_T("AddCredentials should work"));
630 }
631 krisbash 1.1 {
632 MI_UserCredentials creds = { MI_AUTH_TYPE_BASIC, {{ PAL_T("domain2"), PAL_T("username2"), PAL_T("password2") }} };
633 NitsCompare(options.ft->AddCredentials(&options, PAL_T("option3"), &creds, 0), MI_RESULT_FAILED, PAL_T("AddCredentials should fail because namne and type already exist"));
634 }
635 {
636 MI_UserCredentials creds = { MI_AUTH_TYPE_BASIC, {{ PAL_T("domain"), PAL_T("username"), PAL_T("password") }} };
637 NitsCompare(options.ft->AddCredentials(&options, NULL, &creds, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("AddCredentials invalid parameter"));
638 }
639 {
640 MI_UserCredentials creds = { NULL, {{ PAL_T("domain"), PAL_T("username"), PAL_T("password") } }};
641 NitsCompare(options.ft->AddCredentials(&options, PAL_T("option3"), &creds, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("AddCredentials invalid parameter"));
642 }
643 {
644 MI_UserCredentials creds = { MI_AUTH_TYPE_BASIC, {{ NULL, PAL_T("username"), PAL_T("password") }} };
645 NitsCompare(options.ft->AddCredentials(&options, PAL_T("option5"), &creds, 0), MI_RESULT_OK, PAL_T("AddCredentials should work"));
646 }
647 {
648 MI_UserCredentials creds = { MI_AUTH_TYPE_BASIC, {{ PAL_T("domain"), PAL_T("username"), NULL }} };
649 NitsCompare(options.ft->AddCredentials(&options, PAL_T("option4"), &creds, 0), MI_RESULT_OK, PAL_T("AddCredentials should work"));
650 }
651 {
652 krisbash 1.1 MI_UserCredentials creds = { MI_AUTH_TYPE_BASIC, {{ PAL_T("domain"), PAL_T("username"), PAL_T("password") } }};
653 NitsCompare(options.ft->AddCredentials(&options, PAL_T("option3"), &creds, 22), MI_RESULT_INVALID_PARAMETER, PAL_T("AddCredentials invalid parameter"));
654 }
655 options.ft->Delete(NULL);
656
657 MI_DestinationOptions_Delete(&options);
658 }
659 }
660 }
661 NitsEndTest
662
663 /*==========================================================================================*/
664 /*==========================================================================================*/
665 /*==========================================================================================*/
666 /*==================== MI_Application_NewOperationOptions tests ============================*/
667 /*==========================================================================================*/
668 /*==========================================================================================*/
669 /*==========================================================================================*/
670
671 NitsTest1(MI_Application_NewOperationOptions_All,
672 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1)
673 krisbash 1.1 {
674 MI_Application *application = &NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData->application;
675 MI_OperationOptions options = MI_DESTINATIONOPTIONS_NULL;
676 MI_OperationOptions newOptions = MI_DESTINATIONOPTIONS_NULL;
677
678 #if defined (_MSC_VER)
679 #pragma prefast(push)
680 #pragma prefast(disable: 6309)
681 #endif
682 NitsCompare(MI_Application_NewOperationOptions(NULL, MI_FALSE, &options), MI_RESULT_INVALID_PARAMETER, PAL_T("NewOperationOptions invalid parameter"));
683 NitsCompare(MI_Application_NewOperationOptions(application, MI_FALSE, NULL), MI_RESULT_INVALID_PARAMETER, PAL_T("NewOperationOptions invalid parameter"));
684 #if defined (_MSC_VER)
685 #pragma prefast(pop)
686 #endif
687
688 if (NitsCompare(MI_Application_NewOperationOptions(application, MI_FALSE, &options), MI_RESULT_OK, PAL_T("NewOperationOptions should succeed")))
689 {
690 NitsAssert(options.ft != NULL, PAL_T("Should have options function table"));
691 if (options.ft != NULL)
692 {
693 NitsCompare(options.ft->SetString(&options, PAL_T("option1"), PAL_T("value1"), 0), MI_RESULT_OK, PAL_T("SetString should work"));
694 krisbash 1.1 NitsCompare(options.ft->SetString(&options, PAL_T("option1"), PAL_T("value2"), 0), MI_RESULT_OK, PAL_T("SetString should work"));
695 NitsCompare(options.ft->SetString(&options, NULL, PAL_T("value1"), 0), MI_RESULT_INVALID_PARAMETER, PAL_T("SetString invalid parameter"));
696 NitsCompare(options.ft->SetString(&options, PAL_T("option1"), NULL, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("SetString invalid parameter"));
697 NitsCompare(options.ft->SetString(&options, PAL_T("option1"), PAL_T("value1"), 22), MI_RESULT_INVALID_PARAMETER, PAL_T("SetString invalid parameter"));
698
699 NitsCompare(options.ft->SetNumber(&options, PAL_T("option2"), 22, 0), MI_RESULT_OK, PAL_T("SetNumber should work"));
700 NitsCompare(options.ft->SetNumber(&options, PAL_T("option2"), 33, 0), MI_RESULT_OK, PAL_T("SetNumber should work"));
701 NitsCompare(options.ft->SetNumber(&options, NULL, 22, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("SetNumber invalid parameter"));
702 NitsCompare(options.ft->SetNumber(&options, PAL_T("option2"), 22, 22), MI_RESULT_INVALID_PARAMETER, PAL_T("SetNumber invalid parameter"));
703
704 {
705 MI_Uint8 valueArray[2];
706 MI_Value value;
707 value.uint8 = 10;
708 NitsCompare(options.ft->SetCustomOption(&options, PAL_T("uint8"), MI_UINT8, &value, MI_FALSE, 0), MI_RESULT_OK, PAL_T("SetCustomOption(uint8) should work"));
709
710 valueArray[0] = 10;
711 valueArray[1] = 20;
712 value.uint8a.data = valueArray;
713 value.uint8a.size = 2;
714 NitsCompare(options.ft->SetCustomOption(&options, PAL_T("uint8a"), MI_UINT8A, &value, MI_FALSE, 0), MI_RESULT_OK, PAL_T("SetCustomOption(uint8a) should work"));
715 krisbash 1.1 }
716 {
717 MI_Sint8 valueArray[2];
718 MI_Value value;
719 value.sint8 = -10;
720 NitsCompare(options.ft->SetCustomOption(&options, PAL_T("sint8"), MI_SINT8, &value, MI_FALSE, 0), MI_RESULT_OK, PAL_T("SetCustomOption(sint8) should work"));
721
722 valueArray[0] = -10;
723 valueArray[1] = -20;
724 value.sint8a.data = valueArray;
725 value.sint8a.size = 2;
726 NitsCompare(options.ft->SetCustomOption(&options, PAL_T("sint8a"), MI_SINT8A, &value, MI_FALSE, 0), MI_RESULT_OK, PAL_T("SetCustomOption(sint8a) should work"));
727 }
728 {
729 MI_Boolean valueArray[2];
730 MI_Value value;
731 value.boolean = MI_TRUE;
732 NitsCompare(options.ft->SetCustomOption(&options, PAL_T("boolean"), MI_BOOLEAN, &value, MI_FALSE, 0), MI_RESULT_OK, PAL_T("SetCustomOption(boolean) should work"));
733
734 valueArray[0] = MI_TRUE;
735 valueArray[1] = MI_FALSE;
736 krisbash 1.1 value.booleana.data = valueArray;
737 value.booleana.size = 2;
738 NitsCompare(options.ft->SetCustomOption(&options, PAL_T("booleana"), MI_BOOLEANA, &value, MI_FALSE, 0), MI_RESULT_OK, PAL_T("SetCustomOption(booleana) should work"));
739 }
740 {
741 MI_Uint16 valueArray[2];
742 MI_Value value;
743 value.uint16 = 20;
744 NitsCompare(options.ft->SetCustomOption(&options, PAL_T("uint16"), MI_UINT16, &value, MI_FALSE, 0), MI_RESULT_OK, PAL_T("SetCustomOption(uint16) should work"));
745
746 valueArray[0] = 20;
747 valueArray[1] = 40;
748 value.uint16a.data = valueArray;
749 value.uint16a.size = 2;
750 NitsCompare(options.ft->SetCustomOption(&options, PAL_T("uint16a"), MI_UINT16A, &value, MI_FALSE, 0), MI_RESULT_OK, PAL_T("SetCustomOption(uint16a) should work"));
751 }
752 {
753 MI_Sint16 valueArray[2];
754 MI_Value value;
755 value.sint16 = -20;
756 NitsCompare(options.ft->SetCustomOption(&options, PAL_T("sint16"), MI_SINT16, &value, MI_FALSE, 0), MI_RESULT_OK, PAL_T("SetCustomOption(sint16) should work"));
757 krisbash 1.1
758 valueArray[0] = -20;
759 valueArray[1] = -40;
760 value.sint16a.data = valueArray;
761 value.sint16a.size = 2;
762 NitsCompare(options.ft->SetCustomOption(&options, PAL_T("sint16a"), MI_SINT16A, &value, MI_FALSE, 0), MI_RESULT_OK, PAL_T("SetCustomOption(sint16a) should work"));
763 }
764 {
765 MI_Char16 valueArray[2];
766 MI_Value value;
767 value.char16 = L'a';
768 NitsCompare(options.ft->SetCustomOption(&options, PAL_T("char16"), MI_CHAR16, &value, MI_FALSE, 0), MI_RESULT_OK, PAL_T("SetCustomOption(char16) should work"));
769
770 valueArray[0] = L'a';
771 valueArray[1] = L'b';
772 value.char16a.data = valueArray;
773 value.char16a.size = 2;
774 NitsCompare(options.ft->SetCustomOption(&options, PAL_T("char16a"), MI_CHAR16A, &value, MI_FALSE, 0), MI_RESULT_OK, PAL_T("SetCustomOption(char16a) should work"));
775 }
776 {
777 MI_Uint32 valueArray[2];
778 krisbash 1.1 MI_Value value;
779 value.uint32 = 32;
780 NitsCompare(options.ft->SetCustomOption(&options, PAL_T("uint32"), MI_UINT32, &value, MI_FALSE, 0), MI_RESULT_OK, PAL_T("SetCustomOption(uint32) should work"));
781
782 valueArray[0] = 32;
783 valueArray[1] = 54;
784 value.uint32a.data = valueArray;
785 value.uint32a.size = 2;
786 NitsCompare(options.ft->SetCustomOption(&options, PAL_T("uint32a"), MI_UINT32A, &value, MI_FALSE, 0), MI_RESULT_OK, PAL_T("SetCustomOption(uint32a) should work"));
787 }
788 {
789 MI_Sint32 valueArray[2];
790 MI_Value value;
791 value.sint32 = -32;
792 NitsCompare(options.ft->SetCustomOption(&options, PAL_T("sint32"), MI_SINT32, &value, MI_FALSE, 0), MI_RESULT_OK, PAL_T("SetCustomOption(sint32) should work"));
793
794 valueArray[0] = -32;
795 valueArray[1] = -54;
796 value.sint32a.data = valueArray;
797 value.sint32a.size = 2;
798 NitsCompare(options.ft->SetCustomOption(&options, PAL_T("sint32a"), MI_SINT32A, &value, MI_FALSE, 0), MI_RESULT_OK, PAL_T("SetCustomOption(sint32a) should work"));
799 krisbash 1.1 }
800 {
801 MI_Real32 valueArray[2];
802 MI_Value value;
803 value.real32 = 32.32f;
804 NitsCompare(options.ft->SetCustomOption(&options, PAL_T("real32"), MI_REAL32, &value, MI_FALSE, 0), MI_RESULT_OK, PAL_T("SetCustomOption(real32) should work"));
805
806 valueArray[0] = 32.32f;
807 valueArray[1] = -32.32f;
808 value.real32a.data = valueArray;
809 value.real32a.size = 2;
810 NitsCompare(options.ft->SetCustomOption(&options, PAL_T("real32a"), MI_REAL32A, &value, MI_FALSE, 0), MI_RESULT_OK, PAL_T("SetCustomOption(real32a) should work"));
811 }
812 {
813 MI_Real64 valueArray[2];
814 MI_Value value;
815 value.real64 = 64.64;
816 NitsCompare(options.ft->SetCustomOption(&options, PAL_T("real64"), MI_REAL64, &value, MI_FALSE, 0), MI_RESULT_OK, PAL_T("SetCustomOption(real64) should work"));
817
818 valueArray[0] = 64.64;
819 valueArray[1] = -64.64;
820 krisbash 1.1 value.real64a.data = valueArray;
821 value.real64a.size = 2;
822 NitsCompare(options.ft->SetCustomOption(&options, PAL_T("real64a"), MI_REAL64A, &value, MI_FALSE, 0), MI_RESULT_OK, PAL_T("SetCustomOption(real64a) should work"));
823 }
824 {
825 MI_Uint64 valueArray[2];
826 MI_Value value;
827 value.uint64 = 64;
828 NitsCompare(options.ft->SetCustomOption(&options, PAL_T("uint64"), MI_UINT64, &value, MI_FALSE, 0), MI_RESULT_OK, PAL_T("SetCustomOption(uint64) should work"));
829
830 valueArray[0] = 64;
831 valueArray[1] = 64;
832 value.uint64a.data = valueArray;
833 value.uint64a.size = 2;
834 NitsCompare(options.ft->SetCustomOption(&options, PAL_T("uint64a"), MI_UINT64A, &value, MI_FALSE, 0), MI_RESULT_OK, PAL_T("SetCustomOption(uint64a) should work"));
835 }
836 {
837 MI_Sint64 valueArray[2];
838 MI_Value value;
839 value.sint64 = -64;
840 NitsCompare(options.ft->SetCustomOption(&options, PAL_T("sint64"), MI_SINT64, &value, MI_FALSE, 0), MI_RESULT_OK, PAL_T("SetCustomOption(sint64) should work"));
841 krisbash 1.1
842 valueArray[0] = 64;
843 valueArray[1] = -64;
844 value.sint64a.data = valueArray;
845 value.sint64a.size = 2;
846 NitsCompare(options.ft->SetCustomOption(&options, PAL_T("sint64a"), MI_SINT64A, &value, MI_FALSE, 0), MI_RESULT_OK, PAL_T("SetCustomOption(sint64a) should work"));
847 }
848 {
849 MI_Datetime valueArray[2];
850 MI_Value value;
851 value.datetime.isTimestamp = MI_TRUE;
852 value.datetime.u.timestamp.day = 11;
853 value.datetime.u.timestamp.hour = 13;
854 value.datetime.u.timestamp.microseconds = 323;
855 value.datetime.u.timestamp.minute = 55;
856 value.datetime.u.timestamp.month = 10;
857 value.datetime.u.timestamp.second = 43;
858 value.datetime.u.timestamp.utc = 8;
859 value.datetime.u.timestamp.year = 2010;
860 NitsCompare(options.ft->SetCustomOption(&options, PAL_T("datetime"), MI_DATETIME, &value, MI_FALSE, 0), MI_RESULT_OK, PAL_T("SetCustomOption(datetime) should work"));
861
862 krisbash 1.1 valueArray[0].isTimestamp = MI_TRUE;
863 valueArray[0].u.timestamp.day = 11;
864 valueArray[0].u.timestamp.hour = 13;
865 valueArray[0].u.timestamp.microseconds = 323;
866 valueArray[0].u.timestamp.minute = 55;
867 valueArray[0].u.timestamp.month = 10;
868 valueArray[0].u.timestamp.second = 43;
869 valueArray[0].u.timestamp.utc = 8;
870 valueArray[0].u.timestamp.year = 2010;
871 valueArray[1].isTimestamp = MI_TRUE;
872 valueArray[1].u.timestamp.day = 11;
873 valueArray[1].u.timestamp.hour = 13;
874 valueArray[1].u.timestamp.microseconds = 323;
875 valueArray[1].u.timestamp.minute = 55;
876 valueArray[1].u.timestamp.month = 10;
877 valueArray[1].u.timestamp.second = 43;
878 valueArray[1].u.timestamp.utc = 8;
879 valueArray[1].u.timestamp.year = 2010;
880 value.datetimea.data = valueArray;
881 value.datetimea.size = 2;
882 NitsCompare(options.ft->SetCustomOption(&options, PAL_T("datetimea"), MI_DATETIMEA, &value, MI_FALSE, 0), MI_RESULT_OK, PAL_T("SetCustomOption(datetimea) should work"));
883 krisbash 1.1 }
884 {
885 const MI_Char *valueArray[3];
886 MI_Value value;
887 value.string = (MI_Char*) PAL_T("Hello world");
888 NitsCompare(options.ft->SetCustomOption(&options, PAL_T("string"), MI_STRING, &value, MI_FALSE, 0), MI_RESULT_OK, PAL_T("SetCustomOption(string) should work"));
889
890 valueArray[0] = PAL_T("Hello world");
891 valueArray[1] = PAL_T("Goodbye");
892 valueArray[2] = PAL_T("Good night");
893 value.stringa.data = (MI_Char**)valueArray;
894 value.stringa.size = 3;
895 NitsCompare(options.ft->SetCustomOption(&options, PAL_T("stringa"), MI_STRINGA, &value, MI_FALSE, 0), MI_RESULT_OK, PAL_T("SetCustomOption(stringa) should work"));
896 }
897
898 /*============================================*/
899
900 {
901 MI_Value value;
902 value.string = (MI_Char*)PAL_T("Hello world");
903 NitsCompare(options.ft->SetCustomOption(&options, NULL, MI_STRING, &value, MI_FALSE, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("SetCustomOption(string ) should fail due to invalid parameter"));
904 krisbash 1.1 }
905 NitsCompare(options.ft->SetCustomOption(&options, PAL_T("option3_invalid1"), MI_STRING, NULL, MI_FALSE, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("SetCustomString invalid parameter"));
906 {
907 MI_Value value;
908 value.string = (MI_Char*)PAL_T("Hello world");
909 NitsCompare(options.ft->SetCustomOption(&options, PAL_T("string_invalid2 "), MI_STRING, &value, MI_FALSE, 22), MI_RESULT_INVALID_PARAMETER, PAL_T("SetCustomOption(string ) should fail due to invalid flags"));
910 }
911 {
912 MI_Value value;
913 value.string = (MI_Char*)PAL_T("Hello world");
914 NitsCompare(options.ft->SetCustomOption(&options, PAL_T("uint8"), MI_STRING, &value, MI_FALSE, 0), MI_RESULT_TYPE_MISMATCH, PAL_T("SetCustomOption(string ) should fail due to duplicate item existing with different type"));
915 }
916 {
917 MI_Value value;
918 value.uint8 = 10;
919 NitsCompare(options.ft->SetCustomOption(&options, PAL_T("uint8"), MI_UINT8, &value, MI_FALSE, 0), MI_RESULT_OK, PAL_T("SetCustomOption(uint8) should succeed even when option already exists"));
920 }
921
922 NitsCompare(options.ft->SetNumber(&options, PAL_T("option1"), 22, 0), MI_RESULT_TYPE_MISMATCH, PAL_T("SetNumber should fail due to changing type of option"));
923 NitsCompare(options.ft->SetString(&options, PAL_T("option2"), PAL_T("value2"), 0), MI_RESULT_TYPE_MISMATCH, PAL_T("SetString should fail due to changing type of option"));
924
925 krisbash 1.1 if (NitsCompare(MI_Application_NewOperationOptions(application, MI_FALSE, &newOptions), MI_RESULT_OK, PAL_T("NewOperationOptions should succeed")))
926 {
927 NitsCompare(OperationOptions_MigrateOptions(&options, &newOptions), MI_RESULT_OK, PAL_T("Migration should succeed"));
928 MI_OperationOptions_Delete(&newOptions);
929 }
930 options.ft->Delete(NULL);
931
932 MI_OperationOptions_Delete(&options);
933 }
934 }
935 }
936 NitsEndTest
937
938 extern "C" void MI_CALL GetInstanceResult_Fail(
939 _In_ MI_Operation *operation,
940 _In_ void *callbackContext,
941 _In_opt_ const MI_Instance *instance,
942 MI_Boolean moreResults,
943 _In_ MI_Result resultCode,
944 _In_opt_z_ const MI_Char * errorString,
945 _In_opt_ const MI_Instance *errorDetails,
946 krisbash 1.1 _In_opt_ MI_Result (MI_CALL * resultAcknowledgement)(_In_ MI_Operation *operation))
947 {
948 RuntimeTestData *runtimeData = (RuntimeTestData *)callbackContext;
949 NitsAssert(resultCode!= MI_RESULT_OK, PAL_T("should get error"));
950 NitsAssert(instance==NULL, PAL_T("Should not have result instance"));
951 if (resultAcknowledgement)
952 {
953 resultAcknowledgement(operation);
954 }
955 if (!moreResults)
956 {
957 MI_Operation_Close(operation);
958
959 runtimeData->finialResult = resultCode;
960 runtimeData->operationFinished = MI_TRUE;
961
962 CondLock_Broadcast((ptrdiff_t) callbackContext);
963 }
964 }
965 extern "C" void MI_CALL GetClassResult_Fail(
966 _In_ MI_Operation *operation,
967 krisbash 1.1 _In_ void *callbackContext,
968 _In_opt_ const MI_Class *className,
969 MI_Boolean moreResults,
970 _In_ MI_Result resultCode,
971 _In_opt_z_ const MI_Char * errorString,
972 _In_opt_ const MI_Instance *errorDetails,
973 _In_opt_ MI_Result (MI_CALL * resultAcknowledgement)(_In_ MI_Operation *operation))
974 {
975 RuntimeTestData *runtimeData = (RuntimeTestData *)callbackContext;
976 NitsAssert(resultCode!= MI_RESULT_OK, PAL_T("should get error"));
977 NitsAssert(className==NULL, PAL_T("Should not have result instance"));
978 if (resultAcknowledgement)
979 {
980 resultAcknowledgement(operation);
981 }
982 if (!moreResults)
983 {
984 MI_Operation_Close(operation);
985
986 runtimeData->finialResult = resultCode;
987 runtimeData->operationFinished = MI_TRUE;
988 krisbash 1.1
989 CondLock_Broadcast((ptrdiff_t) callbackContext);
990 }
991 }
992
993 ptrdiff_t g_maximumInstanceCount = 1;
994
995 extern "C" void MI_CALL GetInstanceResult(
996 _In_ MI_Operation *operation,
997 _In_ void *callbackContext,
998 _In_opt_ const MI_Instance *instance,
999 MI_Boolean moreResults,
1000 _In_ MI_Result resultCode,
1001 _In_opt_z_ const MI_Char * errorString,
1002 _In_opt_ const MI_Instance *errorDetails,
1003 _In_opt_ MI_Result (MI_CALL * resultAcknowledgement)(_In_ MI_Operation *operation))
1004 {
1005 RuntimeTestData *runtimeData = (RuntimeTestData *)callbackContext;
1006 MI_Session session = MI_SESSION_NULL;
1007 NitsCompare(resultCode, MI_RESULT_OK, PAL_T("Error instance returned to client"));
1008
1009 krisbash 1.1 if (instance)
1010 Atomic_Inc(&runtimeData->instanceCount);
1011
1012 if (g_maximumInstanceCount)
1013 {
1014 NitsAssert(instance!=NULL, PAL_T("Should have result instance"));
1015 if (!NitsAssert(runtimeData->instanceCount <= g_maximumInstanceCount, PAL_T("too many results")))
1016 {
1017 /* try and kill the request early */
1018 moreResults = FALSE;
1019 }
1020 }
1021
1022 if (resultAcknowledgement)
1023 {
1024 resultAcknowledgement(NULL);
1025 resultAcknowledgement(operation);
1026 }
1027
1028 if (!moreResults)
1029 {
1030 krisbash 1.1 /* Get parent session */
1031 MI_Operation_GetSession(operation, &session);
1032
1033 /* Some invalid parameter validation */
1034 operation->ft->Cancel(NULL, MI_REASON_NONE);
1035 operation->ft->Close(NULL);
1036
1037 MI_Operation_Close(operation);
1038
1039 /* Cancel after close */
1040 MI_Operation_Cancel(operation, MI_REASON_NONE);
1041
1042 /* Get results after closed */
1043 MI_Operation_GetInstance(operation, &instance, &moreResults, &resultCode, &errorString, &errorDetails);
1044
1045 /* Get parent session after closed */
1046 MI_Operation_GetSession(operation, &session);
1047
1048 runtimeData->finialResult = resultCode;
1049 runtimeData->operationFinished = MI_TRUE;
1050
1051 krisbash 1.1 CondLock_Broadcast((ptrdiff_t) callbackContext);
1052
1053 }
1054 }
1055
1056 extern "C" void MI_CALL GetIndicationResult(
1057 _In_ MI_Operation *operation,
1058 _In_ void *callbackContext,
1059 _In_opt_ const MI_Instance *instance,
1060 _In_opt_ const MI_Char *bookmark,
1061 _In_opt_ const MI_Char *machineID,
1062 MI_Boolean moreResults,
1063 _In_ MI_Result resultCode,
1064 _In_opt_z_ const MI_Char * errorString,
1065 _In_opt_ const MI_Instance *errorDetails,
1066 _In_opt_ MI_Result (MI_CALL * resultAcknowledgement)(_In_ MI_Operation *operation))
1067 {
1068 RuntimeTestData *runtimeData = (RuntimeTestData *)callbackContext;
1069 MI_Session session = MI_SESSION_NULL;
1070 NitsCompare(resultCode, MI_RESULT_OK, PAL_T("Error instance returned to client"));
1071 NitsAssert(instance!=NULL, PAL_T("Should have result instance"));
1072 krisbash 1.1
1073 if (resultAcknowledgement)
1074 {
1075 resultAcknowledgement(NULL);
1076 resultAcknowledgement(operation);
1077 }
1078 if (instance)
1079 Atomic_Inc(&runtimeData->indicationCount);
1080
1081 if (!NitsAssert(runtimeData->indicationCount <= g_maximumInstanceCount, PAL_T("too many results")))
1082 {
1083 /* try and kill the request early */
1084 moreResults = FALSE;
1085 }
1086
1087 if (!moreResults)
1088 {
1089 /* Get parent session */
1090 MI_Operation_GetSession(operation, &session);
1091
1092 /* Some invalid parameter validation */
1093 krisbash 1.1 operation->ft->Cancel(NULL, MI_REASON_NONE);
1094 operation->ft->Close(NULL);
1095
1096 MI_Operation_Close(operation);
1097
1098 /* Cancel after close */
1099 MI_Operation_Cancel(operation, MI_REASON_NONE);
1100
1101 /* Get results after closed */
1102 MI_Operation_GetIndication(operation, &instance, &bookmark, &machineID, &moreResults, &resultCode, &errorString, &errorDetails);
1103
1104 /* Get parent session after closed */
1105 MI_Operation_GetSession(operation, &session);
1106
1107 runtimeData->finialResult = resultCode;
1108 runtimeData->operationFinished = MI_TRUE;
1109
1110 CondLock_Broadcast((ptrdiff_t) callbackContext);
1111 }
1112 }
1113 extern "C" void MI_CALL GetClassResult(
1114 krisbash 1.1 _In_ MI_Operation *operation,
1115 _In_ void *callbackContext,
1116 _In_opt_ const MI_Class *classResult,
1117 MI_Boolean moreResults,
1118 _In_ MI_Result resultCode,
1119 _In_opt_z_ const MI_Char * errorString,
1120 _In_opt_ const MI_Instance *errorDetails,
1121 _In_opt_ MI_Result (MI_CALL * resultAcknowledgement)(_In_ MI_Operation *operation))
1122 {
1123 RuntimeTestData *runtimeData = (RuntimeTestData *)callbackContext;
1124 MI_Session session = MI_SESSION_NULL;
1125 NitsCompare(resultCode, MI_RESULT_OK, PAL_T("Error instance returned to client"));
1126 NitsAssert(classResult!=NULL, PAL_T("Should have result class"));
1127
1128 if (resultAcknowledgement)
1129 {
1130 resultAcknowledgement(NULL);
1131 resultAcknowledgement(operation);
1132 }
1133 if (classResult)
1134 Atomic_Inc(&runtimeData->classCount);
1135 krisbash 1.1
1136 if (!NitsAssert(runtimeData->classCount <= g_maximumInstanceCount, PAL_T("too many results")))
1137 {
1138 /* try and kill the request early */
1139 moreResults = FALSE;
1140 }
1141
1142 if (!moreResults)
1143 {
1144 /* Get parent session */
1145 MI_Operation_GetSession(operation, &session);
1146
1147 /* Some invalid parameter validation */
1148 operation->ft->Cancel(NULL, MI_REASON_NONE);
1149 operation->ft->Close(NULL);
1150
1151 MI_Operation_Close(operation);
1152
1153 /* Cancel after close */
1154 MI_Operation_Cancel(operation, MI_REASON_NONE);
1155
1156 krisbash 1.1 /* Get results after closed */
1157 MI_Operation_GetClass(operation, &classResult, &moreResults, &resultCode, &errorString, &errorDetails);
1158
1159 /* Get parent session after closed */
1160 MI_Operation_GetSession(operation, &session);
1161
1162 runtimeData->finialResult = resultCode;
1163 runtimeData->operationFinished = MI_TRUE;
1164
1165 CondLock_Broadcast((ptrdiff_t) callbackContext);
1166 }
1167 }
1168
1169 extern "C" void MI_CALL InvokeResult(
1170 _In_ MI_Operation *operation,
1171 _In_ void *callbackContext,
1172 _In_opt_ const MI_Instance *instance,
1173 MI_Boolean moreResults,
1174 _In_ MI_Result resultCode,
1175 _In_opt_z_ const MI_Char * errorString,
1176 _In_opt_ const MI_Instance *errorDetails,
1177 krisbash 1.1 _In_opt_ MI_Result (MI_CALL * resultAcknowledgement)(_In_ MI_Operation *operation))
1178 {
1179 RuntimeTestData *runtimeData = (RuntimeTestData *)callbackContext;
1180 MI_Session session = MI_SESSION_NULL;
1181 NitsCompare(resultCode, MI_RESULT_OK, PAL_T("Error instance returned to client"));
1182 if (resultAcknowledgement)
1183 {
1184 resultAcknowledgement(NULL);
1185 resultAcknowledgement(operation);
1186 }
1187
1188 if (instance)
1189 Atomic_Inc(&runtimeData->methodCount);
1190
1191 if (!moreResults)
1192 {
1193 /* Get parent session */
1194 MI_Operation_GetSession(operation, &session);
1195
1196 /* Some invalid parameter validation */
1197 operation->ft->Cancel(NULL, MI_REASON_NONE);
1198 krisbash 1.1 operation->ft->Close(NULL);
1199
1200 MI_Operation_Close(operation);
1201
1202 /* Cancel after close */
1203 MI_Operation_Cancel(operation, MI_REASON_NONE);
1204
1205 /* Get results after closed */
1206 MI_Operation_GetInstance(operation, &instance, &moreResults, &resultCode, &errorString, &errorDetails);
1207
1208 /* Get parent session after closed */
1209 MI_Operation_GetSession(operation, &session);
1210
1211 runtimeData->finialResult = resultCode;
1212 runtimeData->operationFinished = MI_TRUE;
1213
1214 CondLock_Broadcast((ptrdiff_t) callbackContext);
1215 }
1216 }
1217
1218 void WaitForOperationToComplete(RuntimeTestData *testData)
1219 krisbash 1.1 {
1220 ptrdiff_t operationFinished = testData->operationFinished;
1221 while (!operationFinished)
1222 {
1223 CondLock_Wait((ptrdiff_t)testData, &testData->operationFinished, operationFinished, CONDLOCK_DEFAULT_SPINCOUNT);
1224 operationFinished = testData->operationFinished;
1225 }
1226 }
1227
1228 NitsTest3(MI_Session_GetInstance_Async_AutoAck,
1229 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
1230 SetupDefaultSession, SetupDefaultSessionDefaults,
1231 SetupTestInstance, g_SetupTestInstance_test)
1232 {
1233 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
1234 ResetRuntimeTestData(testData);
1235 MI_Session *session = &testData->session;
1236 MI_Instance *testInstance = testData->testInstance;
1237 MI_Operation operation = MI_OPERATION_NULL;
1238 MI_OperationCallbacks callbacks = MI_OPERATIONCALLBACKS_NULL;
1239
1240 krisbash 1.1 g_maximumInstanceCount = 1;
1241 callbacks.callbackContext = testData;
1242 callbacks.instanceResult = GetInstanceResult;
1243
1244 MI_Session_GetInstance(session, 0, NULL, NULL, testInstance, &callbacks, &operation);
1245 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
1246
1247 WaitForOperationToComplete(testData);
1248
1249 NitsAssert(testData->instanceCount == g_maximumInstanceCount, PAL_T("Number of results callbacks received"));
1250 }
1251 NitsEndTest
1252
1253 NitsTest3(MI_Session_GetInstance_Async_ManualAck,
1254 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
1255 SetupDefaultSession, SetupDefaultSessionDefaults,
1256 SetupTestInstance, g_SetupTestInstance_test)
1257 {
1258 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
1259 ResetRuntimeTestData(testData);
1260 MI_Session *session = &testData->session;
1261 krisbash 1.1 MI_Instance *testInstance = testData->testInstance;
1262 MI_Operation operation = MI_OPERATION_NULL;
1263 MI_OperationCallbacks callbacks = MI_OPERATIONCALLBACKS_NULL;
1264
1265 g_maximumInstanceCount = 1;
1266 callbacks.callbackContext = testData;
1267 callbacks.instanceResult = GetInstanceResult;
1268
1269 MI_Session_GetInstance(session, MI_OPERATIONFLAGS_MANUAL_ACK_RESULTS, NULL, NULL, testInstance, &callbacks, &operation);
1270 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
1271
1272 WaitForOperationToComplete(testData);
1273
1274 NitsAssert(testData->instanceCount == g_maximumInstanceCount, PAL_T("Number of results callbacks received"));
1275 }
1276 NitsEndTest
1277
1278 NitsTest3(MI_Session_GetInstance_Sync,
1279 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
1280 SetupDefaultSession, SetupDefaultSessionDefaults,
1281 SetupTestInstance, g_SetupTestInstance_test)
1282 krisbash 1.1 {
1283 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
1284 ResetRuntimeTestData(testData);
1285 MI_Session *session = &testData->session;
1286 MI_Instance *testInstance = testData->testInstance;
1287 MI_Operation operation = MI_OPERATION_NULL;
1288 const MI_Instance *resultInstance;
1289 MI_Boolean moreResults;
1290 MI_Result result;
1291 const MI_Char *errorMessage;
1292 const MI_Instance *completionDetails;
1293
1294 MI_Session_GetInstance(session, 0, NULL, NULL, testInstance, NULL, &operation);
1295 NitsAssert(operation.ft != NULL, PAL_T("operation testInstance table null"));
1296
1297 MI_Operation_GetInstance(&operation, &resultInstance, &moreResults, &result, &errorMessage, &completionDetails);
1298 NitsCompare(result, MI_RESULT_OK, PAL_T("Operation should succeed"));
1299 NitsAssert(moreResults==MI_FALSE, PAL_T("Should be no more results"));
1300
1301 MI_Operation_Close(&operation);
1302 }
1303 krisbash 1.1 NitsEndTest
1304
1305 NitsTest2(MI_Session_GetInstance_Sync_WithOptions,
1306 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
1307 SetupTestInstance, g_SetupTestInstance_test)
1308 {
1309 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
1310 ResetRuntimeTestData(testData);
1311 MI_Application *application = &testData->application;
1312 MI_Instance *testInstance = testData->testInstance;
1313 MI_Session session = MI_SESSION_NULL;
1314 MI_Operation operation = MI_OPERATION_NULL;
1315
1316 MI_DestinationOptions destOptions = MI_DESTINATIONOPTIONS_NULL;
1317 if (NitsCompare(MI_Application_NewDestinationOptions(application, &destOptions), MI_RESULT_OK, PAL_T("create destoptions failed")))
1318 {
1319 MI_UserCredentials creds = { MI_AUTH_TYPE_BASIC, {{PAL_T("domain"), PAL_T("username"), PAL_T("password") }}};
1320
1321 NitsCompare(destOptions.ft->SetString(&destOptions, PAL_T("option111"), PAL_T("value111"), 0), MI_RESULT_OK, PAL_T("SetString should work"));
1322 NitsCompare(destOptions.ft->SetNumber(&destOptions, PAL_T("option222"), 22, 0), MI_RESULT_OK, PAL_T("SetNumber should work"));
1323 NitsCompare(destOptions.ft->AddCredentials(&destOptions, PAL_T("option333"), &creds, 0), MI_RESULT_OK, PAL_T("AddCredentials should work"));
1324 krisbash 1.1
1325 MI_OperationOptions options = MI_DESTINATIONOPTIONS_NULL;
1326 if (NitsCompare(MI_Application_NewOperationOptions(application, MI_FALSE, &options), MI_RESULT_OK, PAL_T("NewOperationOptions should succeed")))
1327 {
1328 NitsCompare(options.ft->SetString(&options, PAL_T("option1"), PAL_T("value1"), 0), MI_RESULT_OK, PAL_T("SetString should work"));
1329 NitsCompare(options.ft->SetNumber(&options, PAL_T("option2"), 22, 0), MI_RESULT_OK, PAL_T("SetNumber should work"));
1330 {
1331 MI_Value value;
1332 value.string = (MI_Char*) PAL_T("hello world");
1333 NitsCompare(options.ft->SetCustomOption(&options, PAL_T("option3"), MI_STRING, &value, MI_FALSE, 0), MI_RESULT_OK, PAL_T("SetCustomString should work"));
1334 }
1335
1336 if (NitsCompare(MI_Application_NewSession(application, PAL_T("Test1"), NULL, &destOptions, NULL, NULL, &session), MI_RESULT_OK, PAL_T("MI_Application_NewSession returns OK")) &&
1337 NitsAssert(session.ft != NULL, PAL_T("MI_Session function table should not be NULL")))
1338 {
1339 const MI_Instance *resultInstance;
1340 MI_Boolean moreResults;
1341 MI_Result result;
1342 const MI_Char *errorMessage;
1343 const MI_Instance *completionDetails;
1344
1345 krisbash 1.1 MI_Session_GetInstance(&session, 0, &options, NULL, testInstance, NULL, &operation);
1346 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
1347
1348 MI_Operation_GetInstance(&operation, &resultInstance, &moreResults, &result, &errorMessage, &completionDetails);
1349 NitsCompare(result, MI_RESULT_OK, PAL_T("Operation should succeed"));
1350 NitsAssert(moreResults==MI_FALSE, PAL_T("Should be no more results"));
1351
1352 MI_Operation_Close(&operation);
1353
1354 MI_Session_Close(&session, NULL, NULL);
1355 }
1356 MI_OperationOptions_Delete(&options);
1357 }
1358 MI_DestinationOptions_Delete(&destOptions);
1359 }
1360 }
1361 NitsEndTest
1362
1363 NitsTest3(MI_Session_GetInstance_Sync_ResultDeliverDifferentThread,
1364 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
1365 SetupDefaultSession, SetupDefaultSessionDefaults,
1366 krisbash 1.1 SetupTestInstance, g_SetupTestInstance_DeliverResultDifferentThread)
1367 {
1368 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
1369 ResetRuntimeTestData(testData);
1370 MI_Session *session = &testData->session;
1371 MI_Instance *testInstance = testData->testInstance;
1372 MI_Operation operation = MI_OPERATION_NULL;
1373
1374 const MI_Instance *resultInstance;
1375 MI_Boolean moreResults;
1376 MI_Result result;
1377 const MI_Char *errorMessage;
1378 const MI_Instance *completionDetails;
1379
1380 MI_Session_GetInstance(session, 0, NULL, NULL, testInstance, NULL, &operation);
1381 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
1382
1383 MI_Operation_GetInstance(&operation, &resultInstance, &moreResults, &result, &errorMessage, &completionDetails);
1384 NitsCompare(result, MI_RESULT_OK, PAL_T("Operation should succeed"));
1385 NitsAssert(moreResults==MI_FALSE, PAL_T("Should be no more results"));
1386
1387 krisbash 1.1 MI_Operation_Close(&operation);
1388 }
1389 NitsEndTest
1390
1391 extern "C" void MI_CALL MI_Session_GetInstance_Async_PS_Semantics_PromptUser(
1392 _In_ MI_Operation *operation,
1393 _In_opt_ void *callbackContext,
1394 _In_z_ const MI_Char *message,
1395 MI_PromptType promptType,
1396 _In_ MI_Result (MI_CALL * promptUserResult)(_In_ MI_Operation *operation,
1397 MI_OperationCallback_ResponseType response))
1398
1399 {
1400 /* Do an invalid handle version */
1401 MI_Operation tmpOp = *operation;
1402 tmpOp.reserved1=0;
1403 if( promptUserResult)
1404 {
1405 promptUserResult(&tmpOp, MI_OperationCallback_ResponseType_Yes);
1406 promptUserResult(NULL, MI_OperationCallback_ResponseType_Yes);
1407
1408 krisbash 1.1 /* do valid handle */
1409 promptUserResult(operation, g_PromptUserResponseType);
1410 }
1411
1412 RuntimeTestData *runtimeData = (RuntimeTestData *)callbackContext;
1413 Atomic_Inc(&runtimeData->promptUserCount);
1414 }
1415
1416 extern "C" void MI_CALL MI_Session_GetInstance_Async_PS_Semantics_WriteError(
1417 _In_ MI_Operation *operation,
1418 _In_opt_ void *callbackContext,
1419 _In_ MI_Instance *instance,
1420 _In_ MI_Result (MI_CALL * writeErrorResult)(_In_ MI_Operation *operation, MI_OperationCallback_ResponseType response))
1421 {
1422 /* Do an invalid handle version */
1423 MI_Operation tmpOp = *operation;
1424 tmpOp.reserved1=0;
1425 if(writeErrorResult)
1426 {
1427 writeErrorResult(&tmpOp, MI_OperationCallback_ResponseType_Yes);
1428 writeErrorResult(NULL, MI_OperationCallback_ResponseType_Yes);
1429 krisbash 1.1
1430 /* do valid handle */
1431 writeErrorResult(operation, g_WriteErrorResponseType);
1432 }
1433
1434 RuntimeTestData *runtimeData = (RuntimeTestData *)callbackContext;
1435 Atomic_Inc(&runtimeData->writeErrorCount);
1436 }
1437
1438 extern "C" void MI_CALL MI_Session_GetInstance_Async_PS_Semantics_WriteMessage(
1439 _In_ MI_Operation *operation,
1440 _In_opt_ void *callbackContext,
1441 MI_Uint32 channel,
1442 _In_z_ const MI_Char *message)
1443 {
1444 RuntimeTestData *runtimeData = (RuntimeTestData *)callbackContext;
1445 Atomic_Inc(&runtimeData->writeMessageCount);
1446 }
1447
1448 extern "C" void MI_CALL MI_Session_GetInstance_Async_PS_Semantics_WriteProgress(
1449 _In_ MI_Operation *operation,
1450 krisbash 1.1 _In_opt_ void *callbackContext,
1451 _In_z_ const MI_Char *activity,
1452 _In_z_ const MI_Char *currentOperation,
1453 _In_z_ const MI_Char *statusDescription,
1454 MI_Uint32 percentageComplete,
1455 MI_Uint32 secondsRemaining)
1456 {
1457 RuntimeTestData *runtimeData = (RuntimeTestData *)callbackContext;
1458 Atomic_Inc(&runtimeData->writeProgressCount);
1459 }
1460
1461 extern "C" void MI_CALL MI_Session_GetInstance_Async_PS_Semantics_Sesson_WriteMessage(
1462 _In_ MI_Application *application,
1463 _In_opt_ void *callbackContext,
1464 MI_Uint32 channel,
1465 _In_z_ const MI_Char * message)
1466 {
1467 RuntimeTestData *runtimeData = (RuntimeTestData *)callbackContext;
1468 Atomic_Inc(&runtimeData->session_writeMessageCount);
1469 }
1470
1471 krisbash 1.1 extern "C" void MI_CALL MI_Session_GetInstance_Async_PS_Semantics_Sesson_WriteError(
1472 _In_ MI_Application *application,
1473 _In_opt_ void *callbackContext,
1474 _In_ MI_Instance *instance)
1475 {
1476 RuntimeTestData *runtimeData = (RuntimeTestData *)callbackContext;
1477 Atomic_Inc(&runtimeData->session_writeErrorCount);
1478 }
1479
1480 extern "C" void MI_CALL _MI_OperationCallback_StreamedParameter(
1481 _In_ MI_Operation *operation,
1482 _In_ void *callbackContext,
1483 _In_z_ const MI_Char * parameterName,
1484 _In_ MI_Type resultType,
1485 _In_ const MI_Value *result,
1486 _In_ MI_Result (MI_CALL * resultAcknowledgement)(_In_ MI_Operation *operation))
1487 {
1488 if (resultAcknowledgement)
1489 {
1490 resultAcknowledgement(NULL);
1491 resultAcknowledgement(operation);
1492 krisbash 1.1 }
1493
1494 RuntimeTestData *runtimeData = (RuntimeTestData *)callbackContext;
1495 Atomic_Inc(&runtimeData->streamedParameterCount);
1496 }
1497
1498 NitsTest3(MI_Session_GetInstance_Async_PS_Semantics,
1499 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
1500 SetupDefaultSession, SetupDefaultSessionDefaults,
1501 SetupTestInstance, g_SetupTestInstance_test)
1502 {
1503 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
1504 ResetRuntimeTestData(testData);
1505 MI_Instance *testInstance = testData->testInstance;
1506 MI_Session *session = &testData->session;
1507 MI_Operation operation = MI_OPERATION_NULL;
1508 MI_OperationCallbacks callbacks = MI_OPERATIONCALLBACKS_NULL;
1509
1510 g_maximumInstanceCount = 1;
1511 callbacks.callbackContext = testData;
1512 callbacks.instanceResult = GetInstanceResult;
1513 krisbash 1.1 callbacks.promptUser = MI_Session_GetInstance_Async_PS_Semantics_PromptUser;
1514 callbacks.writeError = MI_Session_GetInstance_Async_PS_Semantics_WriteError;
1515 callbacks.writeMessage = MI_Session_GetInstance_Async_PS_Semantics_WriteMessage;
1516 callbacks.writeProgress = MI_Session_GetInstance_Async_PS_Semantics_WriteProgress;
1517
1518 MI_Session_GetInstance(session, MI_OPERATIONFLAGS_MANUAL_ACK_RESULTS, NULL, NULL, testInstance, &callbacks, &operation);
1519 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
1520
1521 NitsAssert(testData->instanceCount == g_maximumInstanceCount, PAL_T("Number of results callbacks received"));
1522 }
1523 NitsEndTest
1524
1525 NitsTest2(MI_Session_GetInstance_Sync_InvalidParameters,
1526 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
1527 SetupTestInstance, g_SetupTestInstance_test)
1528 {
1529 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
1530 ResetRuntimeTestData(testData);
1531 MI_Application *application = &testData->application;
1532 MI_Session session = MI_SESSION_NULL;
1533 MI_Instance *testInstance = testData->testInstance;
1534 krisbash 1.1 MI_Operation operation = MI_OPERATION_NULL;
1535 const MI_Instance *result;
1536 const MI_Instance *extendedInfo;
1537 MI_Boolean moreResults;
1538 MI_Result resultCode;
1539 MI_Result returnValue;
1540 const MI_Char *errorMessage;
1541 MI_OperationCallbacks callbacks = MI_OPERATIONCALLBACKS_NULL;
1542 callbacks.callbackContext = testData;
1543 callbacks.instanceResult = GetInstanceResult_Fail;
1544
1545 {
1546 if (NitsCompare(MI_Application_NewSession(application, PAL_T("Test1"), NULL, NULL, NULL, NULL, &session), MI_RESULT_OK, PAL_T("MI_Application_NewSession returns OK")) &&
1547 NitsAssert(session.ft != NULL, PAL_T("MI_Session function table should not be NULL")))
1548 {
1549 if (session.ft == NULL)
1550 NitsReturn;
1551
1552 {
1553 session.ft->GetInstance(&session, 0, NULL, NULL, testInstance, NULL, &operation);
1554 MI_Operation_GetInstance(&operation, &result, &moreResults, &resultCode, &errorMessage, &extendedInfo);
1555 krisbash 1.1 NitsCompare(resultCode, MI_RESULT_OK, PAL_T("GetInstance should succeed"));
1556
1557 returnValue = operation.ft->GetInstance(NULL, &result, NULL, &resultCode, NULL, NULL);
1558 NitsCompare(returnValue, MI_RESULT_INVALID_PARAMETER, PAL_T("Operation_GetInstance should fail due to NULL operation"));
1559
1560 returnValue = operation.ft->GetInstance(&operation, NULL, NULL, &resultCode, NULL, NULL);
1561 NitsCompare(returnValue, MI_RESULT_INVALID_PARAMETER, PAL_T("Operation_GetInstance should fail due to NULL instance"));
1562
1563 returnValue = operation.ft->GetInstance(&operation, NULL, NULL, NULL, NULL, NULL);
1564 NitsCompare(returnValue, MI_RESULT_INVALID_PARAMETER, PAL_T("Operation_GetInstance should fail due to NULL instance"));
1565
1566 MI_Operation_Close(&operation);
1567
1568 session.ft->GetInstance(NULL, 0, NULL, NULL, testInstance, NULL, &operation);
1569 MI_Operation_GetInstance(&operation, &result, &moreResults, &resultCode, &errorMessage, &extendedInfo);
1570 NitsCompare(resultCode, MI_RESULT_INVALID_PARAMETER, PAL_T("GetInstance should faul due to NULL session"));
1571 MI_Operation_Close(&operation);
1572
1573 session.ft->GetInstance(&session, 0, NULL, NULL, NULL, NULL, &operation);
1574 MI_Operation_GetInstance(&operation, &result, &moreResults, &resultCode, &errorMessage, &extendedInfo);
1575 NitsCompare(resultCode, MI_RESULT_INVALID_PARAMETER, PAL_T("GetInstance should fail due to NULL instance key"));
1576 krisbash 1.1 MI_Operation_Close(&operation);
1577
1578 session.ft->GetInstance(&session, 0, NULL, NULL, testInstance, &callbacks, NULL);
1579 MI_Operation_GetInstance(&operation, &result, &moreResults, &resultCode, &errorMessage, &extendedInfo);
1580 NitsCompare(resultCode, MI_RESULT_INVALID_PARAMETER, PAL_T("GetInstance should fail due to null operation, has callbacks"));
1581 MI_Operation_Close(&operation);
1582
1583 session.ft->GetInstance(&session, 0, NULL, NULL, testInstance, NULL, NULL);
1584 /* Validate it doesn't crash only as nowhere for failure to go */
1585 }
1586 MI_Session_Close(&session, NULL, NULL);
1587
1588 session.ft->GetInstance(&session, 0, NULL, NULL, testInstance, NULL, &operation);
1589 MI_Operation_GetInstance(&operation, &result, &moreResults, &resultCode, &errorMessage, &extendedInfo);
1590 NitsCompare(resultCode, MI_RESULT_INVALID_PARAMETER, PAL_T("GetInstance should fail because session is already closed"));
1591 MI_Operation_Close(&operation);
1592
1593 }
1594 }
1595 }
1596 NitsEndTest
1597 krisbash 1.1
1598 NitsTest3(MI_Session_GetInstance_TransportNotSupported,
1599 SetupDefaultApplication, g_RuntimeApplicationSetup_Test2,
1600 SetupDefaultSession, SetupDefaultSessionDefaults,
1601 SetupTestInstance, g_SetupTestInstance_test)
1602 {
1603 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
1604 ResetRuntimeTestData(testData);
1605 MI_Session *session = &testData->session;
1606 MI_Instance *testInstance = testData->testInstance;
1607 MI_Operation operation = MI_OPERATION_NULL;
1608 const MI_Instance *resultInstance;
1609 MI_Boolean moreResults;
1610 MI_Result result;
1611 const MI_Char *errorMessage;
1612 const MI_Instance *completionDetails;
1613
1614 MI_Session_GetInstance(session, 0, NULL, NULL, testInstance, NULL, &operation);
1615
1616 MI_Operation_GetInstance(&operation, &resultInstance, &moreResults, &result, &errorMessage, &completionDetails);
1617 NitsCompare(result, MI_RESULT_NOT_SUPPORTED, PAL_T("Operation should succeed"));
1618 krisbash 1.1 NitsAssert(moreResults==MI_FALSE, PAL_T("Should be no more results"));
1619
1620 MI_Operation_Close(&operation);
1621 }
1622 NitsEndTest
1623
1624 NitsTest3(MI_Session_Invoke_Async_NonStatic,
1625 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
1626 SetupDefaultSession, SetupDefaultSessionDefaults,
1627 SetupTestInstance, g_SetupTestInstance_test)
1628 {
1629 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
1630 ResetRuntimeTestData(testData);
1631 MI_Session *session = &testData->session;
1632 MI_Instance *testInstance = testData->testInstance;
1633 MI_Operation operation = MI_OPERATION_NULL;
1634 MI_OperationCallbacks callbacks = MI_OPERATIONCALLBACKS_NULL;
1635
1636 g_maximumInstanceCount = 1;
1637 callbacks.callbackContext = testData;
1638 callbacks.instanceResult = InvokeResult;
1639 krisbash 1.1
1640 MI_Session_Invoke(session, 0, NULL, NULL, PAL_T("testClass"), PAL_T("TestMethod"), testInstance, NULL, &callbacks, &operation);
1641 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
1642
1643 WaitForOperationToComplete(testData);
1644
1645 NitsCompare((MI_Uint32)testData->methodCount, (MI_Uint32)g_maximumInstanceCount, PAL_T("Number of results callbacks received"));
1646 }
1647 NitsEndTest
1648
1649 NitsTest2(MI_Session_Invoke_Async_Static,
1650 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
1651 SetupDefaultSession, SetupDefaultSessionDefaults)
1652 {
1653 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
1654 ResetRuntimeTestData(testData);
1655 MI_Session *session = &testData->session;
1656 MI_Operation operation = MI_OPERATION_NULL;
1657 MI_OperationCallbacks callbacks = MI_OPERATIONCALLBACKS_NULL;
1658
1659 g_maximumInstanceCount = 1;
1660 krisbash 1.1 callbacks.callbackContext = testData;
1661 callbacks.instanceResult = InvokeResult;
1662
1663 MI_Session_Invoke(session, 0, NULL, NULL, PAL_T("testClass"), PAL_T("TestMethod"), NULL, NULL, &callbacks, &operation);
1664 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
1665
1666 WaitForOperationToComplete(testData);
1667
1668 NitsCompare((MI_Uint32)testData->methodCount, (MI_Uint32)g_maximumInstanceCount, PAL_T("Number of results callbacks received"));
1669 }
1670 NitsEndTest
1671
1672 NitsTest2(MI_Session_Invoke_Async_Static_PsSemantics,
1673 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
1674 SetupDefaultSession, SetupDefaultSessionDefaults)
1675 {
1676 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
1677 ResetRuntimeTestData(testData);
1678 MI_Session *session = &testData->session;
1679 MI_Operation operation = MI_OPERATION_NULL;
1680 MI_OperationCallbacks callbacks = MI_OPERATIONCALLBACKS_NULL;
1681 krisbash 1.1
1682 g_maximumInstanceCount = 1;
1683 callbacks.callbackContext = testData;
1684 callbacks.instanceResult = InvokeResult;
1685 callbacks.promptUser = MI_Session_GetInstance_Async_PS_Semantics_PromptUser;
1686 callbacks.writeError = MI_Session_GetInstance_Async_PS_Semantics_WriteError;
1687 callbacks.writeMessage = MI_Session_GetInstance_Async_PS_Semantics_WriteMessage;
1688 callbacks.writeProgress = MI_Session_GetInstance_Async_PS_Semantics_WriteProgress;
1689
1690 MI_Session_Invoke(session, 0, NULL, NULL, PAL_T("testClass"), PAL_T("TestMethod"), NULL, NULL, &callbacks, &operation);
1691 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
1692
1693 WaitForOperationToComplete(testData);
1694
1695 NitsCompare((MI_Uint32)testData->methodCount, (MI_Uint32)g_maximumInstanceCount, PAL_T("Number of results callbacks received"));
1696 NitsCompare((MI_Uint32)testData->writeErrorCount, 2, PAL_T("Correct PS semantic count"));
1697 NitsCompare((MI_Uint32)testData->writeMessageCount, 1, PAL_T("Correct PS semantic count"));
1698 NitsCompare((MI_Uint32)testData->writeProgressCount, 1, PAL_T("Correct PS semantic count"));
1699 NitsCompare((MI_Uint32)testData->promptUserCount, 2, PAL_T("Correct PS semantic count"));
1700 }
1701 NitsEndTest
1702 krisbash 1.1
1703 NitsTest2(MI_Session_Invoke_Async_Static_StreamedParameter,
1704 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
1705 SetupDefaultSession, SetupDefaultSessionDefaults)
1706 {
1707 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
1708 ResetRuntimeTestData(testData);
1709 MI_Session *session = &testData->session;
1710 MI_Operation operation = MI_OPERATION_NULL;
1711 MI_OperationCallbacks callbacks = MI_OPERATIONCALLBACKS_NULL;
1712
1713 g_maximumInstanceCount = 1;
1714 callbacks.callbackContext = testData;
1715 callbacks.instanceResult = InvokeResult;
1716 callbacks.promptUser = MI_Session_GetInstance_Async_PS_Semantics_PromptUser;
1717 callbacks.writeError = MI_Session_GetInstance_Async_PS_Semantics_WriteError;
1718 callbacks.writeMessage = MI_Session_GetInstance_Async_PS_Semantics_WriteMessage;
1719 callbacks.writeProgress = MI_Session_GetInstance_Async_PS_Semantics_WriteProgress;
1720 callbacks.streamedParameterResult = _MI_OperationCallback_StreamedParameter;
1721
1722 MI_Session_Invoke(session, 0, NULL, NULL, PAL_T("testClass"), PAL_T("TestMethod"), NULL, NULL, &callbacks, &operation);
1723 krisbash 1.1 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
1724
1725 WaitForOperationToComplete(testData);
1726
1727 NitsCompare((MI_Uint32)testData->methodCount, 0, PAL_T("Number of results callbacks received"));
1728 NitsCompare((MI_Uint32)testData->writeErrorCount, 2, PAL_T("Correct PS semantic count"));
1729 NitsCompare((MI_Uint32)testData->writeMessageCount, 1, PAL_T("Correct PS semantic count"));
1730 NitsCompare((MI_Uint32)testData->writeProgressCount, 1, PAL_T("Correct PS semantic count"));
1731 NitsCompare((MI_Uint32)testData->promptUserCount, 2, PAL_T("Correct PS semantic count"));
1732 NitsCompare((MI_Uint32)testData->streamedParameterCount, 5, PAL_T("Correct PS semantic count"));
1733 }
1734 NitsEndTest
1735
1736 NitsTest2(MI_Session_Invoke_Async_Static_StreamedParameter_ManualAck,
1737 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
1738 SetupDefaultSession, SetupDefaultSessionDefaults)
1739 {
1740 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
1741 ResetRuntimeTestData(testData);
1742 MI_Session *session = &testData->session;
1743 MI_Operation operation = MI_OPERATION_NULL;
1744 krisbash 1.1 MI_OperationCallbacks callbacks = MI_OPERATIONCALLBACKS_NULL;
1745
1746 g_maximumInstanceCount = 1;
1747 callbacks.callbackContext = testData;
1748 callbacks.instanceResult = InvokeResult;
1749 callbacks.promptUser = MI_Session_GetInstance_Async_PS_Semantics_PromptUser;
1750 callbacks.writeError = MI_Session_GetInstance_Async_PS_Semantics_WriteError;
1751 callbacks.writeMessage = MI_Session_GetInstance_Async_PS_Semantics_WriteMessage;
1752 callbacks.writeProgress = MI_Session_GetInstance_Async_PS_Semantics_WriteProgress;
1753 callbacks.streamedParameterResult = _MI_OperationCallback_StreamedParameter;
1754
1755 MI_Session_Invoke(session, MI_OPERATIONFLAGS_MANUAL_ACK_RESULTS, NULL, NULL, PAL_T("testClass"), PAL_T("TestMethod"), NULL, NULL, &callbacks, &operation);
1756 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
1757
1758 WaitForOperationToComplete(testData);
1759
1760 NitsCompare((MI_Uint32)testData->methodCount, 0, PAL_T("Number of results callbacks received"));
1761 NitsCompare((MI_Uint32)testData->writeErrorCount, 2, PAL_T("Correct PS semantic count"));
1762 NitsCompare((MI_Uint32)testData->writeMessageCount, 1, PAL_T("Correct PS semantic count"));
1763 NitsCompare((MI_Uint32)testData->writeProgressCount, 1, PAL_T("Correct PS semantic count"));
1764 NitsCompare((MI_Uint32)testData->promptUserCount, 2, PAL_T("Correct PS semantic count"));
1765 krisbash 1.1 NitsCompare((MI_Uint32)testData->streamedParameterCount, 5, PAL_T("Correct PS semantic count"));
1766 }
1767 NitsEndTest
1768
1769 NitsTest3(MI_Session_Invoke_Sync_Success,
1770 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
1771 SetupDefaultSession, SetupDefaultSessionDefaults,
1772 SetupTestInstance, g_SetupTestInstance_test)
1773 {
1774 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
1775 ResetRuntimeTestData(testData);
1776 MI_Session *session = &testData->session;
1777 MI_Operation operation = MI_OPERATION_NULL;
1778 const MI_Instance *result;
1779 const MI_Instance *extendedInfo;
1780 MI_Boolean moreResults;
1781 MI_Result resultCode;
1782 const MI_Char *errorMessage;
1783
1784 session->ft->Invoke(session, 0, NULL, NULL, PAL_T("testClass"), PAL_T("TestMethod"), NULL, NULL, NULL, &operation);
1785 MI_Operation_GetInstance(&operation, &result, &moreResults, &resultCode, &errorMessage, &extendedInfo);
1786 krisbash 1.1 NitsCompare(resultCode, MI_RESULT_OK, PAL_T("Invoke should succeed"));
1787 MI_Operation_Close(&operation);
1788 }
1789 NitsEndTest
1790
1791 NitsTest3(MI_Session_Invoke_Sync_WithOptions,
1792 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
1793 SetupDefaultSession, SetupDefaultSessionDefaults,
1794 SetupTestInstance, g_SetupTestInstance_test)
1795 {
1796 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
1797 ResetRuntimeTestData(testData);
1798 MI_Application *application = &testData->application;
1799 MI_Session *session = &testData->session;
1800 MI_Operation operation = MI_OPERATION_NULL;
1801 const MI_Instance *result;
1802 const MI_Instance *extendedInfo;
1803 MI_Boolean moreResults;
1804 MI_Result resultCode;
1805 const MI_Char *errorMessage;
1806 MI_OperationOptions options = MI_DESTINATIONOPTIONS_NULL;
1807 krisbash 1.1
1808 if (NitsCompare(MI_Application_NewOperationOptions(application, MI_FALSE, &options), MI_RESULT_OK, PAL_T("NewOperationOptions should succeed")))
1809 {
1810 NitsCompare(options.ft->SetString(&options, PAL_T("option1"), PAL_T("value1"), 0), MI_RESULT_OK, PAL_T("SetString should work"));
1811 NitsCompare(options.ft->SetNumber(&options, PAL_T("option2"), 22, 0), MI_RESULT_OK, PAL_T("SetNumber should work"));
1812 {
1813 MI_Value value;
1814 value.string = (MI_Char*) PAL_T("hello world");
1815 NitsCompare(options.ft->SetCustomOption(&options, PAL_T("option3"), MI_STRING, &value, MI_FALSE, 0), MI_RESULT_OK, PAL_T("SetCustomString should work"));
1816 }
1817
1818 session->ft->Invoke(session, 0, &options, NULL, PAL_T("testClass"), PAL_T("TestMethod"), NULL, NULL, NULL, &operation);
1819 MI_Operation_GetInstance(&operation, &result, &moreResults, &resultCode, &errorMessage, &extendedInfo);
1820 NitsCompare(resultCode, MI_RESULT_OK, PAL_T("Invoke should succeed"));
1821 MI_Operation_Close(&operation);
1822
1823 MI_OperationOptions_Delete(&options);
1824 }
1825 }
1826 NitsEndTest
1827
1828 krisbash 1.1
1829 NitsTest2(MI_Session_Invoke_Sync_InvalidParameters,
1830 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
1831 SetupTestInstance, g_SetupTestInstance_test)
1832 {
1833 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
1834 ResetRuntimeTestData(testData);
1835 MI_Application *application = &testData->application;
1836 MI_Session session = MI_SESSION_NULL;
1837 MI_Operation operation = MI_OPERATION_NULL;
1838 const MI_Instance *result;
1839 const MI_Instance *extendedInfo;
1840 MI_Boolean moreResults;
1841 MI_Result resultCode;
1842 const MI_Char *errorMessage;
1843 MI_OperationCallbacks callbacks = MI_OPERATIONCALLBACKS_NULL;
1844
1845 callbacks.callbackContext = testData;
1846 callbacks.instanceResult = GetInstanceResult_Fail;
1847
1848 if (NitsCompare(MI_Application_NewSession(application, PAL_T("Test1"), NULL, NULL, NULL, NULL, &session), MI_RESULT_OK, PAL_T("MI_Application_NewSession returns OK")) &&
1849 krisbash 1.1 NitsAssert(session.ft != NULL, PAL_T("MI_Session function table should not be NULL")))
1850 {
1851 if (session.ft == NULL)
1852 NitsReturn;
1853
1854 session.ft->Invoke(&session, 0, NULL, NULL, PAL_T("testClass"), PAL_T("TestMethod"), NULL, NULL, NULL, &operation);
1855 MI_Operation_GetInstance(&operation, &result, &moreResults, &resultCode, &errorMessage, &extendedInfo);
1856 NitsCompare(resultCode, MI_RESULT_OK, PAL_T("Invoke should succeed"));
1857 MI_Operation_Close(&operation);
1858
1859 session.ft->Invoke(&session, 11, NULL, NULL, PAL_T("testClass"), PAL_T("TestMethod"), NULL, NULL, NULL, &operation);
1860 MI_Operation_GetInstance(&operation, &result, &moreResults, &resultCode, &errorMessage, &extendedInfo);
1861 NitsCompare(resultCode, MI_RESULT_OK, PAL_T("Invoke should fail due to invalid flag"));
1862 MI_Operation_Close(&operation);
1863
1864 session.ft->Invoke(NULL, 0, NULL, NULL, PAL_T("testClass"), PAL_T("TestMethod"), NULL, NULL, NULL, &operation);
1865 MI_Operation_GetInstance(&operation, &result, &moreResults, &resultCode, &errorMessage, &extendedInfo);
1866 NitsCompare(resultCode, MI_RESULT_INVALID_PARAMETER, PAL_T("Invoke should fail due to invalid session"));
1867 MI_Operation_Close(&operation);
1868
1869 session.ft->Invoke(&session, 0, NULL, NULL, PAL_T("testClass"), NULL, NULL, NULL, NULL, &operation);
1870 krisbash 1.1 MI_Operation_GetInstance(&operation, &result, &moreResults, &resultCode, &errorMessage, &extendedInfo);
1871 NitsCompare(resultCode, MI_RESULT_INVALID_PARAMETER, PAL_T("Invoke should fail due to invalid method name"));
1872
1873 operation.ft->GetInstance(NULL, &result, NULL, &resultCode, NULL, NULL);
1874 operation.ft->GetInstance(&operation, NULL, NULL, &resultCode, NULL, NULL);
1875
1876 operation.ft->Close(NULL);
1877 MI_Operation_Close(&operation);
1878
1879 session.ft->Invoke(&session, 0, NULL, NULL, PAL_T("testClass"), PAL_T("TestMethod"), NULL, NULL, &callbacks, NULL);
1880 MI_Operation_GetInstance(&operation, &result, &moreResults, &resultCode, &errorMessage, &extendedInfo);
1881 NitsCompare(resultCode, MI_RESULT_INVALID_PARAMETER, PAL_T("Invoke should fail due to null operation, has callbacks"));
1882 MI_Operation_Close(&operation);
1883
1884 session.ft->Invoke(&session, 0, NULL, NULL, PAL_T("testClass"), PAL_T("TestMethod"), NULL, NULL, NULL, NULL);
1885 /* Nothing to validate, just make sure it doesn't crash! */
1886
1887 MI_Session_Close(&session, NULL, NULL);
1888
1889 session.ft->Invoke(&session, 0, NULL, NULL, PAL_T("testClass"), PAL_T("TestMethod"), NULL, NULL, NULL, &operation);
1890 MI_Operation_GetInstance(&operation, &result, &moreResults, &resultCode, &errorMessage, &extendedInfo);
1891 krisbash 1.1 NitsCompare(resultCode, MI_RESULT_INVALID_PARAMETER, PAL_T("Invoke should fail because session is already closed"));
1892 MI_Operation_Close(&operation);
1893 }
1894
1895 }
1896 NitsEndTest
1897
1898 NitsTest3(MI_Session_Invoke_Sync_TransportNotSupported,
1899 SetupDefaultApplication, g_RuntimeApplicationSetup_Test2,
1900 SetupDefaultSession, SetupDefaultSessionDefaults,
1901 SetupTestInstance, g_SetupTestInstance_test)
1902 {
1903 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
1904 ResetRuntimeTestData(testData);
1905 MI_Session *session = &testData->session;
1906 MI_Operation operation = MI_OPERATION_NULL;
1907 const MI_Instance *result;
1908 const MI_Instance *extendedInfo;
1909 MI_Boolean moreResults;
1910 MI_Result resultCode;
1911 const MI_Char *errorMessage;
1912 krisbash 1.1
1913 session->ft->Invoke(session, 0, NULL, NULL, PAL_T("testClass"), PAL_T("TestMethod"), NULL, NULL, NULL, &operation);
1914 MI_Operation_GetInstance(&operation, &result, &moreResults, &resultCode, &errorMessage, &extendedInfo);
1915 NitsCompare(resultCode, MI_RESULT_NOT_SUPPORTED, PAL_T("Invoke should fail"));
1916 MI_Operation_Close(&operation);
1917 }
1918 NitsEndTest
1919
1920 NitsTest3(MI_Session_ModifyInstance_Async_AutoAck,
1921 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
1922 SetupDefaultSession, SetupDefaultSessionDefaults,
1923 SetupTestInstance, g_SetupTestInstance_test)
1924 {
1925 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
1926 ResetRuntimeTestData(testData);
1927 MI_Session *session = &testData->session;
1928 MI_Instance *testInstance = testData->testInstance;
1929 MI_Operation operation = MI_OPERATION_NULL;
1930 MI_OperationCallbacks callbacks = MI_OPERATIONCALLBACKS_NULL;
1931
1932 g_maximumInstanceCount = 1;
1933 krisbash 1.1 callbacks.callbackContext = testData;
1934 callbacks.instanceResult = GetInstanceResult;
1935
1936 MI_Session_ModifyInstance(session, 0, NULL, NULL, testInstance, &callbacks, &operation);
1937 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
1938
1939 WaitForOperationToComplete(testData);
1940
1941 NitsCompare((MI_Uint32)testData->instanceCount, (MI_Uint32)g_maximumInstanceCount, PAL_T("Number of results callbacks received"));
1942 }
1943 NitsEndTest
1944
1945 NitsTest3(MI_Session_ModifyInstance_Async_ManualAck,
1946 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
1947 SetupDefaultSession, SetupDefaultSessionDefaults,
1948 SetupTestInstance, g_SetupTestInstance_test)
1949 {
1950 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
1951 ResetRuntimeTestData(testData);
1952 MI_Session *session = &testData->session;
1953 MI_Instance *testInstance = testData->testInstance;
1954 krisbash 1.1 MI_Operation operation = MI_OPERATION_NULL;
1955 MI_OperationCallbacks callbacks = MI_OPERATIONCALLBACKS_NULL;
1956
1957 g_maximumInstanceCount = 1;
1958 callbacks.callbackContext = testData;
1959 callbacks.instanceResult = GetInstanceResult;
1960
1961 MI_Session_ModifyInstance(session, MI_OPERATIONFLAGS_MANUAL_ACK_RESULTS, NULL, NULL, testInstance, &callbacks, &operation);
1962 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
1963
1964 WaitForOperationToComplete(testData);
1965
1966 NitsCompare((MI_Uint32)testData->instanceCount, (MI_Uint32)g_maximumInstanceCount, PAL_T("Number of results callbacks received"));
1967 }
1968 NitsEndTest
1969
1970 NitsTest3(MI_Session_ModifyInstance_Sync,
1971 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
1972 SetupDefaultSession, SetupDefaultSessionDefaults,
1973 SetupTestInstance, g_SetupTestInstance_test)
1974 {
1975 krisbash 1.1 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
1976 ResetRuntimeTestData(testData);
1977 MI_Session *session = &testData->session;
1978 MI_Instance *testInstance = testData->testInstance;
1979 MI_Operation operation = MI_OPERATION_NULL;
1980
1981 const MI_Instance *resultInstance;
1982 MI_Boolean moreResults;
1983 MI_Result result;
1984 const MI_Char *errorMessage;
1985 const MI_Instance *completionDetails;
1986
1987 MI_Session_ModifyInstance(session, 0, NULL, NULL, testInstance, NULL, &operation);
1988 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
1989
1990 MI_Operation_GetInstance(&operation, &resultInstance, &moreResults, &result, &errorMessage, &completionDetails);
1991 NitsCompare(result, MI_RESULT_OK, PAL_T("Operation should succeed"));
1992 NitsAssert(moreResults==MI_FALSE, PAL_T("Should be no more results"));
1993
1994 MI_Operation_Close(&operation);
1995 }
1996 krisbash 1.1 NitsEndTest
1997
1998 NitsTest3(MI_Session_ModifyInstance_Sync_WithOptions,
1999 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
2000 SetupDefaultSession, SetupDefaultSessionDefaults,
2001 SetupTestInstance, g_SetupTestInstance_test)
2002 {
2003 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
2004 ResetRuntimeTestData(testData);
2005 MI_Application *application = &testData->application;
2006 MI_Session *session = &testData->session;
2007 MI_Instance *testInstance = testData->testInstance;
2008 MI_Operation operation = MI_OPERATION_NULL;
2009
2010 MI_OperationOptions options = MI_OPERATIONOPTIONS_NULL;
2011 if (NitsCompare(MI_Application_NewOperationOptions(application, MI_FALSE, &options), MI_RESULT_OK, PAL_T("NewOperationOptions should succeed")))
2012 {
2013 NitsCompare(options.ft->SetString(&options, PAL_T("option1"), PAL_T("value1"), 0), MI_RESULT_OK, PAL_T("SetString should work"));
2014 NitsCompare(options.ft->SetNumber(&options, PAL_T("option2"), 22, 0), MI_RESULT_OK, PAL_T("SetNumber should work"));
2015 {
2016 MI_Value value;
2017 krisbash 1.1 value.string = (MI_Char *)PAL_T("hello world");
2018 NitsCompare(options.ft->SetCustomOption(&options, PAL_T("option3"), MI_STRING, &value, MI_FALSE, 0), MI_RESULT_OK, PAL_T("SetCustomString should work"));
2019 }
2020
2021 {
2022 const MI_Instance *resultInstance;
2023 MI_Boolean moreResults;
2024 MI_Result result;
2025 const MI_Char *errorMessage;
2026 const MI_Instance *completionDetails;
2027
2028 MI_Session_ModifyInstance(session, 0, &options, NULL, testInstance, NULL, &operation);
2029 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
2030
2031 MI_Operation_GetInstance(&operation, &resultInstance, &moreResults, &result, &errorMessage, &completionDetails);
2032 NitsCompare(result, MI_RESULT_OK, PAL_T("Operation should succeed"));
2033 NitsAssert(moreResults==MI_FALSE, PAL_T("Should be no more results"));
2034
2035 MI_Operation_Close(&operation);
2036
2037 }
2038 krisbash 1.1 MI_OperationOptions_Delete(&options);
2039 }
2040 }
2041 NitsEndTest
2042
2043 NitsTest2(MI_Session_ModifyInstance_Sync_InvalidParameters,
2044 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
2045 SetupTestInstance, g_SetupTestInstance_test)
2046 {
2047 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
2048 ResetRuntimeTestData(testData);
2049 MI_Application *application = &testData->application;
2050 MI_Session session = MI_SESSION_NULL;
2051 MI_Instance *testInstance = testData->testInstance;
2052 MI_Operation operation = MI_OPERATION_NULL;
2053 const MI_Instance *result;
2054 const MI_Instance *extendedInfo;
2055 MI_Boolean moreResults;
2056 MI_Result resultCode;
2057 const MI_Char *errorMessage;
2058 MI_OperationCallbacks callbacks = MI_OPERATIONCALLBACKS_NULL;
2059 krisbash 1.1 MI_Result returnValue;
2060
2061 callbacks.callbackContext = testData;
2062 callbacks.instanceResult = GetInstanceResult_Fail;
2063
2064 if (NitsCompare(MI_Application_NewSession(application, PAL_T("Test1"), NULL, NULL, NULL, NULL, &session), MI_RESULT_OK, PAL_T("MI_Application_NewSession returns OK")) &&
2065 NitsAssert(session.ft != NULL, PAL_T("MI_Session function table should not be NULL")))
2066 {
2067 if (session.ft == NULL)
2068 NitsReturn;
2069
2070 session.ft->ModifyInstance(&session, 0, NULL, NULL, testInstance, NULL, &operation);
2071 MI_Operation_GetInstance(&operation, &result, &moreResults, &resultCode, &errorMessage, &extendedInfo);
2072 NitsCompare(resultCode, MI_RESULT_OK, PAL_T("GetInstance should succeed"));
2073
2074 returnValue = operation.ft->GetInstance(NULL, &result, NULL, &resultCode, NULL, NULL);
2075 NitsCompare(returnValue, MI_RESULT_INVALID_PARAMETER, PAL_T("Operation_GetInstance should fail due to NULL operation"));
2076
2077 returnValue = operation.ft->GetInstance(&operation, NULL, NULL, &resultCode, NULL, NULL);
2078 NitsCompare(returnValue, MI_RESULT_INVALID_PARAMETER, PAL_T("Operation_GetInstance should fail due to NULL instance"));
2079
2080 krisbash 1.1 operation.ft->GetInstance(&operation, NULL, NULL, NULL, NULL, NULL);
2081 /* no where for result to go but may add code coverage for scenario */
2082
2083 MI_Operation_Close(&operation);
2084
2085 session.ft->ModifyInstance(NULL, 0, NULL, NULL, testInstance, NULL, &operation);
2086 MI_Operation_GetInstance(&operation, &result, &moreResults, &resultCode, &errorMessage, &extendedInfo);
2087 NitsCompare(resultCode, MI_RESULT_INVALID_PARAMETER, PAL_T("GetInstance should faul due to NULL session"));
2088 MI_Operation_Close(&operation);
2089
2090 session.ft->ModifyInstance(&session, 0, NULL, NULL, NULL, NULL, &operation);
2091 MI_Operation_GetInstance(&operation, &result, &moreResults, &resultCode, &errorMessage, &extendedInfo);
2092 NitsCompare(resultCode, MI_RESULT_INVALID_PARAMETER, PAL_T("GetInstance should fail due to NULL instance key"));
2093 MI_Operation_Close(&operation);
2094
2095 session.ft->ModifyInstance(&session, 0, NULL, NULL, testInstance, NULL, NULL);
2096 /* Validate it doesn't crash only as nowhere for failure to go */
2097
2098 session.ft->ModifyInstance(&session, 0, NULL, NULL, testInstance, &callbacks, NULL);
2099 MI_Operation_GetInstance(&operation, &result, &moreResults, &resultCode, &errorMessage, &extendedInfo);
2100 NitsCompare(resultCode, MI_RESULT_INVALID_PARAMETER, PAL_T("GetInstance should fail due to null operation, has callbacks"));
2101 krisbash 1.1 MI_Operation_Close(&operation);
2102
2103 MI_Session_Close(&session, NULL, NULL);
2104
2105 session.ft->ModifyInstance(&session, 0, NULL, NULL, testInstance, NULL, &operation);
2106 MI_Operation_GetInstance(&operation, &result, &moreResults, &resultCode, &errorMessage, &extendedInfo);
2107 NitsCompare(resultCode, MI_RESULT_INVALID_PARAMETER, PAL_T("GetInstance should fail because session is already closed"));
2108 MI_Operation_Close(&operation);
2109 }
2110 }
2111 NitsEndTest
2112
2113 NitsTest3(MI_Session_ModifyInstance_TransportNotSupported,
2114 SetupDefaultApplication, g_RuntimeApplicationSetup_Test2,
2115 SetupDefaultSession, SetupDefaultSessionDefaults,
2116 SetupTestInstance, g_SetupTestInstance_test)
2117 {
2118 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
2119 ResetRuntimeTestData(testData);
2120 MI_Session *session = &testData->session;
2121 MI_Instance *testInstance = testData->testInstance;
2122 krisbash 1.1 MI_Operation operation = MI_OPERATION_NULL;
2123
2124 const MI_Instance *resultInstance;
2125 MI_Boolean moreResults;
2126 MI_Result result;
2127 const MI_Char *errorMessage;
2128 const MI_Instance *completionDetails;
2129
2130 MI_Session_ModifyInstance(session, 0, NULL, NULL, testInstance, NULL, &operation);
2131
2132 MI_Operation_GetInstance(&operation, &resultInstance, &moreResults, &result, &errorMessage, &completionDetails);
2133 NitsCompare(result, MI_RESULT_NOT_SUPPORTED, PAL_T("Operation should succeed"));
2134 NitsAssert(moreResults==MI_FALSE, PAL_T("Should be no more results"));
2135
2136 MI_Operation_Close(&operation);
2137 }
2138 NitsEndTest
2139
2140 NitsTest3(MI_Session_CreateInstance_Async_AutoAck,
2141 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
2142 SetupDefaultSession, SetupDefaultSessionDefaults,
2143 krisbash 1.1 SetupTestInstance, g_SetupTestInstance_test)
2144 {
2145 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
2146 ResetRuntimeTestData(testData);
2147 MI_Session *session = &testData->session;
2148 MI_Instance *testInstance = testData->testInstance;
2149 MI_Operation operation = MI_OPERATION_NULL;
2150 MI_OperationCallbacks callbacks = MI_OPERATIONCALLBACKS_NULL;
2151
2152 g_maximumInstanceCount = 1;
2153 callbacks.callbackContext = testData;
2154 callbacks.instanceResult = GetInstanceResult;
2155
2156 MI_Session_CreateInstance(session, 0, NULL, NULL, testInstance, &callbacks, &operation);
2157 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
2158
2159 WaitForOperationToComplete(testData);
2160
2161 NitsCompare((MI_Uint32)testData->instanceCount, (MI_Uint32)g_maximumInstanceCount, PAL_T("Number of results callbacks received"));
2162 }
2163 NitsEndTest
2164 krisbash 1.1
2165 NitsTest3(MI_Session_CreateInstance_Async_ManualAck,
2166 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
2167 SetupDefaultSession, SetupDefaultSessionDefaults,
2168 SetupTestInstance, g_SetupTestInstance_test)
2169 {
2170 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
2171 ResetRuntimeTestData(testData);
2172 MI_Session *session = &testData->session;
2173 MI_Instance *testInstance = testData->testInstance;
2174 MI_Operation operation = MI_OPERATION_NULL;
2175 MI_OperationCallbacks callbacks = MI_OPERATIONCALLBACKS_NULL;
2176
2177 g_maximumInstanceCount = 1;
2178 callbacks.callbackContext = testData;
2179 callbacks.instanceResult = GetInstanceResult;
2180
2181 MI_Session_CreateInstance(session, MI_OPERATIONFLAGS_MANUAL_ACK_RESULTS, NULL, NULL, testInstance, &callbacks, &operation);
2182 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
2183
2184 WaitForOperationToComplete(testData);
2185 krisbash 1.1
2186 NitsCompare((MI_Uint32)testData->instanceCount, (MI_Uint32)g_maximumInstanceCount, PAL_T("Number of results callbacks received"));
2187 }
2188 NitsEndTest
2189
2190 NitsTest3(MI_Session_CreateInstance_Sync,
2191 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
2192 SetupDefaultSession, SetupDefaultSessionDefaults,
2193 SetupTestInstance, g_SetupTestInstance_test)
2194 {
2195 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
2196 ResetRuntimeTestData(testData);
2197 MI_Session *session = &testData->session;
2198 MI_Instance *testInstance = testData->testInstance;
2199 MI_Operation operation = MI_OPERATION_NULL;
2200
2201 const MI_Instance *resultInstance;
2202 MI_Boolean moreResults;
2203 MI_Result result;
2204 const MI_Char *errorMessage;
2205 const MI_Instance *completionDetails;
2206 krisbash 1.1
2207 MI_Session_CreateInstance(session, 0, NULL, NULL, testInstance, NULL, &operation);
2208 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
2209
2210 MI_Operation_GetInstance(&operation, &resultInstance, &moreResults, &result, &errorMessage, &completionDetails);
2211 NitsCompare(result, MI_RESULT_OK, PAL_T("Operation should succeed"));
2212 NitsAssert(moreResults==MI_FALSE, PAL_T("Should be no more results"));
2213
2214 MI_Operation_Close(&operation);
2215 }
2216 NitsEndTest
2217
2218 NitsTest3(MI_Session_CreateInstance_Sync_WithOptions,
2219 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
2220 SetupDefaultSession, SetupDefaultSessionDefaults,
2221 SetupTestInstance, g_SetupTestInstance_test)
2222 {
2223 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
2224 ResetRuntimeTestData(testData);
2225 MI_Application *application = &testData->application;
2226 MI_Session *session = &testData->session;
2227 krisbash 1.1 MI_Instance *testInstance = testData->testInstance;
2228 MI_Operation operation = MI_OPERATION_NULL;
2229
2230 MI_OperationOptions options = MI_OPERATIONOPTIONS_NULL;
2231 if (NitsCompare(MI_Application_NewOperationOptions(application, MI_FALSE, &options), MI_RESULT_OK, PAL_T("NewOperationOptions should succeed")))
2232 {
2233 NitsCompare(options.ft->SetString(&options, PAL_T("option1"), PAL_T("value1"), 0), MI_RESULT_OK, PAL_T("SetString should work"));
2234 NitsCompare(options.ft->SetNumber(&options, PAL_T("option2"), 22, 0), MI_RESULT_OK, PAL_T("SetNumber should work"));
2235 {
2236 MI_Value value;
2237 value.string = (MI_Char*) PAL_T("hello world");
2238 NitsCompare(options.ft->SetCustomOption(&options, PAL_T("option3"), MI_STRING, &value, MI_FALSE, 0), MI_RESULT_OK, PAL_T("SetCustomString should work"));
2239 }
2240
2241 const MI_Instance *resultInstance;
2242 MI_Boolean moreResults;
2243 MI_Result result;
2244 const MI_Char *errorMessage;
2245 const MI_Instance *completionDetails;
2246
2247 MI_Session_CreateInstance(session, 0, &options, NULL, testInstance, NULL, &operation);
2248 krisbash 1.1 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
2249
2250 MI_Operation_GetInstance(&operation, &resultInstance, &moreResults, &result, &errorMessage, &completionDetails);
2251 NitsCompare(result, MI_RESULT_OK, PAL_T("Operation should succeed"));
2252 NitsAssert(moreResults==MI_FALSE, PAL_T("Should be no more results"));
2253
2254 MI_Operation_Close(&operation);
2255
2256 MI_OperationOptions_Delete(&options);
2257 }
2258 }
2259 NitsEndTest
2260
2261 NitsTest2(MI_Session_CreateInstance_Sync_InvalidParameters,
2262 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
2263 SetupTestInstance, g_SetupTestInstance_test)
2264 {
2265 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
2266 ResetRuntimeTestData(testData);
2267 MI_Application *application = &testData->application;
2268 MI_Session session = MI_SESSION_NULL;
2269 krisbash 1.1 MI_Instance *testInstance = testData->testInstance;
2270 MI_Operation operation = MI_OPERATION_NULL;
2271 const MI_Instance *result;
2272 const MI_Instance *extendedInfo;
2273 MI_Boolean moreResults;
2274 MI_Result resultCode;
2275 MI_Result returnValue;
2276 const MI_Char *errorMessage;
2277 MI_OperationCallbacks callbacks = MI_OPERATIONCALLBACKS_NULL;
2278
2279 callbacks.callbackContext = testData;
2280 callbacks.instanceResult = GetInstanceResult_Fail;
2281
2282 if (NitsCompare(MI_Application_NewSession(application, PAL_T("Test1"), NULL, NULL, NULL, NULL, &session), MI_RESULT_OK, PAL_T("MI_Application_NewSession returns OK")) &&
2283 NitsAssert(session.ft != NULL, PAL_T("MI_Session function table should not be NULL")))
2284 {
2285 if (session.ft == NULL)
2286 NitsReturn;
2287
2288 session.ft->CreateInstance(&session, 0, NULL, NULL, testInstance, NULL, &operation);
2289 MI_Operation_GetInstance(&operation, &result, &moreResults, &resultCode, &errorMessage, &extendedInfo);
2290 krisbash 1.1 NitsCompare(resultCode, MI_RESULT_OK, PAL_T("GetInstance should succeed"));
2291
2292 returnValue = operation.ft->GetInstance(NULL, &result, NULL, &resultCode, NULL, NULL);
2293 NitsCompare(returnValue, MI_RESULT_INVALID_PARAMETER, PAL_T("Operation_GetInstance should fail due to NULL operation"));
2294
2295 returnValue = operation.ft->GetInstance(&operation, NULL, NULL, &resultCode, NULL, NULL);
2296 NitsCompare(returnValue, MI_RESULT_INVALID_PARAMETER, PAL_T("Operation_GetInstance should fail due to NULL instance"));
2297
2298 operation.ft->GetInstance(&operation, NULL, NULL, NULL, NULL, NULL);
2299 /* no where for result to go but may add code coverage for scenario */
2300
2301 MI_Operation_Close(&operation);
2302
2303 session.ft->CreateInstance(NULL, 0, NULL, NULL, testInstance, NULL, &operation);
2304 MI_Operation_GetInstance(&operation, &result, &moreResults, &resultCode, &errorMessage, &extendedInfo);
2305 NitsCompare(resultCode, MI_RESULT_INVALID_PARAMETER, PAL_T("GetInstance should faul due to NULL session"));
2306 MI_Operation_Close(&operation);
2307
2308 session.ft->CreateInstance(&session, 0, NULL, NULL, NULL, NULL, &operation);
2309 MI_Operation_GetInstance(&operation, &result, &moreResults, &resultCode, &errorMessage, &extendedInfo);
2310 NitsCompare(resultCode, MI_RESULT_INVALID_PARAMETER, PAL_T("GetInstance should fail due to NULL instance key"));
2311 krisbash 1.1 MI_Operation_Close(&operation);
2312
2313 session.ft->CreateInstance(&session, 0, NULL, NULL, testInstance, NULL, NULL);
2314 /* Validate it doesn't crash only as nowhere for failure to go */
2315
2316 session.ft->CreateInstance(&session, 0, NULL, NULL, testInstance, &callbacks, NULL);
2317 MI_Operation_GetInstance(&operation, &result, &moreResults, &resultCode, &errorMessage, &extendedInfo);
2318 NitsCompare(resultCode, MI_RESULT_INVALID_PARAMETER, PAL_T("GetInstance should fail due to null operation, has callbacks"));
2319 MI_Operation_Close(&operation);
2320
2321 MI_Session_Close(&session, NULL, NULL);
2322
2323 session.ft->CreateInstance(&session, 0, NULL, NULL, testInstance, NULL, &operation);
2324 MI_Operation_GetInstance(&operation, &result, &moreResults, &resultCode, &errorMessage, &extendedInfo);
2325 NitsCompare(resultCode, MI_RESULT_INVALID_PARAMETER, PAL_T("GetInstance should fail because session is already closed"));
2326 MI_Operation_Close(&operation);
2327
2328 }
2329 }
2330 NitsEndTest
2331
2332 krisbash 1.1 NitsTest3(MI_Session_CreateInstance_TransportNotSupported,
2333 SetupDefaultApplication, g_RuntimeApplicationSetup_Test2,
2334 SetupDefaultSession, SetupDefaultSessionDefaults,
2335 SetupTestInstance, g_SetupTestInstance_test)
2336 {
2337 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
2338 ResetRuntimeTestData(testData);
2339 MI_Session *session = &testData->session;
2340 MI_Instance *testInstance = testData->testInstance;
2341 MI_Operation operation = MI_OPERATION_NULL;
2342
2343 const MI_Instance *resultInstance;
2344 MI_Boolean moreResults;
2345 MI_Result result;
2346 const MI_Char *errorMessage;
2347 const MI_Instance *completionDetails;
2348
2349 MI_Session_CreateInstance(session, 0, NULL, NULL, testInstance, NULL, &operation);
2350
2351 MI_Operation_GetInstance(&operation, &resultInstance, &moreResults, &result, &errorMessage, &completionDetails);
2352 NitsCompare(result, MI_RESULT_NOT_SUPPORTED, PAL_T("Operation should succeed"));
2353 krisbash 1.1 NitsAssert(moreResults==MI_FALSE, PAL_T("Should be no more results"));
2354
2355 MI_Operation_Close(&operation);
2356
2357 }
2358 NitsEndTest
2359
2360 NitsTest3(MI_Session_DeleteInstance_Async_AutoAck,
2361 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
2362 SetupDefaultSession, SetupDefaultSessionDefaults,
2363 SetupTestInstance, g_SetupTestInstance_test)
2364 {
2365 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
2366 ResetRuntimeTestData(testData);
2367 MI_Session *session = &testData->session;
2368 MI_Instance *testInstance = testData->testInstance;
2369 MI_Operation operation = MI_OPERATION_NULL;
2370 MI_OperationCallbacks callbacks = MI_OPERATIONCALLBACKS_NULL;
2371
2372 g_maximumInstanceCount = 1;
2373 callbacks.callbackContext = testData;
2374 krisbash 1.1 callbacks.instanceResult = GetInstanceResult;
2375
2376 MI_Session_DeleteInstance(session, 0, NULL, NULL, testInstance, &callbacks, &operation);
2377 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
2378
2379 WaitForOperationToComplete(testData);
2380
2381 NitsCompare((MI_Uint32)testData->instanceCount, (MI_Uint32)g_maximumInstanceCount, PAL_T("Number of results callbacks received"));
2382 }
2383 NitsEndTest
2384
2385 NitsTest3(MI_Session_DeleteInstance_Async_ManualAck,
2386 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
2387 SetupDefaultSession, SetupDefaultSessionDefaults,
2388 SetupTestInstance, g_SetupTestInstance_test)
2389 {
2390 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
2391 ResetRuntimeTestData(testData);
2392 MI_Session *session = &testData->session;
2393 MI_Instance *testInstance = testData->testInstance;
2394 MI_Operation operation = MI_OPERATION_NULL;
2395 krisbash 1.1 MI_OperationCallbacks callbacks = MI_OPERATIONCALLBACKS_NULL;
2396
2397 g_maximumInstanceCount = 1;
2398 callbacks.callbackContext = testData;
2399 callbacks.instanceResult = GetInstanceResult;
2400
2401 MI_Session_DeleteInstance(session, MI_OPERATIONFLAGS_MANUAL_ACK_RESULTS, NULL, NULL, testInstance, &callbacks, &operation);
2402 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
2403
2404 WaitForOperationToComplete(testData);
2405
2406 NitsCompare((MI_Uint32)testData->instanceCount, (MI_Uint32)g_maximumInstanceCount, PAL_T("Number of results callbacks received"));
2407 }
2408 NitsEndTest
2409
2410 NitsTest3(MI_Session_DeleteInstance_Sync,
2411 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
2412 SetupDefaultSession, SetupDefaultSessionDefaults,
2413 SetupTestInstance, g_SetupTestInstance_test)
2414 {
2415 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
2416 krisbash 1.1 ResetRuntimeTestData(testData);
2417 MI_Session *session = &testData->session;
2418 MI_Instance *testInstance = testData->testInstance;
2419 MI_Operation operation = MI_OPERATION_NULL;
2420
2421 const MI_Instance *resultInstance;
2422 MI_Boolean moreResults;
2423 MI_Result result;
2424 const MI_Char *errorMessage;
2425 const MI_Instance *completionDetails;
2426
2427 MI_Session_DeleteInstance(session, 0, NULL, NULL, testInstance, NULL, &operation);
2428 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
2429
2430 MI_Operation_GetInstance(&operation, &resultInstance, &moreResults, &result, &errorMessage, &completionDetails);
2431 NitsCompare(result, MI_RESULT_OK, PAL_T("Operation should succeed"));
2432 NitsAssert(moreResults==MI_FALSE, PAL_T("Should be no more results"));
2433
2434 MI_Operation_Close(&operation);
2435 }
2436 NitsEndTest
2437 krisbash 1.1
2438 NitsTest3(MI_Session_DeleteInstance_Sync_WithOptions,
2439 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
2440 SetupDefaultSession, SetupDefaultSessionDefaults,
2441 SetupTestInstance, g_SetupTestInstance_test)
2442 {
2443 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
2444 ResetRuntimeTestData(testData);
2445 MI_Application *application = &testData->application;
2446 MI_Session *session = &testData->session;
2447 MI_Instance *testInstance = testData->testInstance;
2448 MI_Operation operation = MI_OPERATION_NULL;
2449 MI_OperationOptions options = MI_OPERATIONOPTIONS_NULL;
2450
2451 if (NitsCompare(MI_Application_NewOperationOptions(application, MI_FALSE, &options), MI_RESULT_OK, PAL_T("NewOperationOptions should succeed")))
2452 {
2453 NitsCompare(options.ft->SetString(&options, PAL_T("option1"), PAL_T("value1"), 0), MI_RESULT_OK, PAL_T("SetString should work"));
2454 NitsCompare(options.ft->SetNumber(&options, PAL_T("option2"), 22, 0), MI_RESULT_OK, PAL_T("SetNumber should work"));
2455 {
2456 MI_Value value;
2457 value.string = (MI_Char*) PAL_T("hello world");
2458 krisbash 1.1 NitsCompare(options.ft->SetCustomOption(&options, PAL_T("option3"), MI_STRING, &value, MI_FALSE, 0), MI_RESULT_OK, PAL_T("SetCustomString should work"));
2459 }
2460
2461 const MI_Instance *resultInstance;
2462 MI_Boolean moreResults;
2463 MI_Result result;
2464 const MI_Char *errorMessage;
2465 const MI_Instance *completionDetails;
2466
2467 MI_Session_DeleteInstance(session, 0, &options, NULL, testInstance, NULL, &operation);
2468 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
2469
2470 MI_Operation_GetInstance(&operation, &resultInstance, &moreResults, &result, &errorMessage, &completionDetails);
2471 NitsCompare(result, MI_RESULT_OK, PAL_T("Operation should succeed"));
2472 NitsAssert(moreResults==MI_FALSE, PAL_T("Should be no more results"));
2473
2474 MI_Operation_Close(&operation);
2475 MI_OperationOptions_Delete(&options);
2476 }
2477 }
2478 NitsEndTest
2479 krisbash 1.1
2480 NitsTest3(MI_Session_DeleteInstance_Sync_InvalidParameters,
2481 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
2482 SetupDefaultSession, SetupDefaultSessionDefaults,
2483 SetupTestInstance, g_SetupTestInstance_test)
2484 {
2485 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
2486 ResetRuntimeTestData(testData);
2487 MI_Application *application = &testData->application;
2488 MI_Instance *testInstance = testData->testInstance;
2489 MI_Session session = MI_SESSION_NULL;
2490 MI_Operation operation = MI_OPERATION_NULL;
2491 const MI_Instance *result;
2492 const MI_Instance *extendedInfo;
2493 MI_Boolean moreResults;
2494 MI_Result resultCode;
2495 MI_Result returnValue;
2496 const MI_Char *errorMessage;
2497 MI_OperationCallbacks callbacks = MI_OPERATIONCALLBACKS_NULL;
2498
2499 callbacks.callbackContext = testData;
2500 krisbash 1.1 callbacks.instanceResult = GetInstanceResult_Fail;
2501
2502 if (NitsCompare(MI_Application_NewSession(application, PAL_T("Test1"), NULL, NULL, NULL, NULL, &session), MI_RESULT_OK, PAL_T("MI_Application_NewSession returns OK")) &&
2503 NitsAssert(session.ft != NULL, PAL_T("MI_Session function table should not be NULL")))
2504 {
2505 if (session.ft == NULL)
2506 NitsReturn;
2507
2508 session.ft->DeleteInstance(&session, 0, NULL, NULL, testInstance, NULL, &operation);
2509 MI_Operation_GetInstance(&operation, &result, &moreResults, &resultCode, &errorMessage, &extendedInfo);
2510 NitsCompare(resultCode, MI_RESULT_OK, PAL_T("GetInstance should succeed"));
2511
2512 returnValue = operation.ft->GetInstance(NULL, &result, NULL, &resultCode, NULL, NULL);
2513 NitsCompare(returnValue, MI_RESULT_INVALID_PARAMETER, PAL_T("Operation_GetInstance should fail due to NULL operation"));
2514
2515 returnValue = operation.ft->GetInstance(&operation, NULL, NULL, &resultCode, NULL, NULL);
2516 NitsCompare(returnValue, MI_RESULT_INVALID_PARAMETER, PAL_T("Operation_GetInstance should fail due to NULL instance"));
2517
2518 operation.ft->GetInstance(&operation, NULL, NULL, NULL, NULL, NULL);
2519 /* no where for result to go but may add code coverage for scenario */
2520
2521 krisbash 1.1 MI_Operation_Close(&operation);
2522
2523 session.ft->DeleteInstance(NULL, 0, NULL, NULL, testInstance, NULL, &operation);
2524 MI_Operation_GetInstance(&operation, &result, &moreResults, &resultCode, &errorMessage, &extendedInfo);
2525 NitsCompare(resultCode, MI_RESULT_INVALID_PARAMETER, PAL_T("GetInstance should faul due to NULL session"));
2526 MI_Operation_Close(&operation);
2527
2528 session.ft->DeleteInstance(&session, 0, NULL, NULL, NULL, NULL, &operation);
2529 MI_Operation_GetInstance(&operation, &result, &moreResults, &resultCode, &errorMessage, &extendedInfo);
2530 NitsCompare(resultCode, MI_RESULT_INVALID_PARAMETER, PAL_T("GetInstance should fail due to NULL instance key"));
2531 MI_Operation_Close(&operation);
2532
2533 session.ft->DeleteInstance(&session, 0, NULL, NULL, testInstance, NULL, NULL);
2534 /* Validate it doesn't crash only as nowhere for failure to go */
2535
2536 session.ft->DeleteInstance(&session, 0, NULL, NULL, testInstance, &callbacks, NULL);
2537 MI_Operation_GetInstance(&operation, &result, &moreResults, &resultCode, &errorMessage, &extendedInfo);
2538 NitsCompare(resultCode, MI_RESULT_INVALID_PARAMETER, PAL_T("GetInstance should fail due to null operation, has callbacks"));
2539 MI_Operation_Close(&operation);
2540
2541 MI_Session_Close(&session, NULL, NULL);
2542 krisbash 1.1
2543 session.ft->DeleteInstance(&session, 0, NULL, NULL, testInstance, NULL, &operation);
2544 MI_Operation_GetInstance(&operation, &result, &moreResults, &resultCode, &errorMessage, &extendedInfo);
2545 NitsCompare(resultCode, MI_RESULT_INVALID_PARAMETER, PAL_T("GetInstance should fail because session is already closed"));
2546 MI_Operation_Close(&operation);
2547
2548 }
2549 }
2550 NitsEndTest
2551
2552 NitsTest3(MI_Session_DeleteInstance_TransportNotSupported,
2553 SetupDefaultApplication, g_RuntimeApplicationSetup_Test2,
2554 SetupDefaultSession, SetupDefaultSessionDefaults,
2555 SetupTestInstance, g_SetupTestInstance_test)
2556 {
2557 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
2558 ResetRuntimeTestData(testData);
2559 MI_Session *session = &testData->session;
2560 MI_Instance *testInstance = testData->testInstance;
2561 MI_Operation operation = MI_OPERATION_NULL;
2562
2563 krisbash 1.1 const MI_Instance *resultInstance;
2564 MI_Boolean moreResults;
2565 MI_Result result;
2566 const MI_Char *errorMessage;
2567 const MI_Instance *completionDetails;
2568
2569 MI_Session_DeleteInstance(session, 0, NULL, NULL, testInstance, NULL, &operation);
2570
2571 MI_Operation_GetInstance(&operation, &resultInstance, &moreResults, &result, &errorMessage, &completionDetails);
2572 NitsCompare(result, MI_RESULT_NOT_SUPPORTED, PAL_T("Operation should succeed"));
2573 NitsAssert(moreResults==MI_FALSE, PAL_T("Should be no more results"));
2574
2575 MI_Operation_Close(&operation);
2576 }
2577 NitsEndTest
2578
2579 #if 0
2580 extern "C" void MI_CALL MI_Session_GetInstance_Async_CancelBeforeClose_Result(
2581 _In_ MI_Operation *operation,
2582 _In_ void *callbackContext,
2583 _In_opt_ const MI_Instance *instance,
2584 krisbash 1.1 MI_Boolean moreResults,
2585 _In_ MI_Result resultCode,
2586 _In_opt_z_ const MI_Char * errorString,
2587 _In_opt_ const MI_Instance *errorDetails,
2588 _In_opt_ MI_Result (MI_CALL * resultAcknowledgement)(_In_ MI_Operation *operation))
2589 {
2590 NitsCompare(resultCode, MI_RESULT_OK, PAL_T("Operation should have succeeded"));
2591
2592 MI_Operation_Cancel(operation, MI_REASON_NONE);
2593
2594 if (resultAcknowledgement)
2595 {
2596 resultAcknowledgement(operation);
2597 }
2598
2599 if (!moreResults)
2600 {
2601 MI_Operation_Close(operation);
2602 CondLock_Broadcast((ptrdiff_t) callbackContext);
2603 }
2604 }
2605 krisbash 1.1
2606
2607 NitsTest3(MI_Session_GetInstance_Async_CancelBeforeClose,
2608 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
2609 SetupDefaultSession, SetupDefaultSessionDefaults,
2610 SetupTestInstance, g_SetupTestInstance_test)
2611 {
2612 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
2613 ResetRuntimeTestData(testData);
2614 MI_Session *session = &testData->session;
2615 MI_Instance *testInstance = testData->testInstance;
2616 MI_Operation operation = MI_OPERATION_NULL;
2617 MI_OperationCallbacks callbacks = MI_OPERATIONCALLBACKS_NULL;
2618
2619 callbacks.callbackContext = testData;
2620 callbacks.instanceResult = MI_Session_GetInstance_Async_CancelBeforeClose_Result;
2621
2622 MI_Session_GetInstance(session, 0, NULL, NULL, testInstance, &callbacks, &operation);
2623 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
2624
2625 WaitForOperationToComplete(testData);
2626 krisbash 1.1
2627 }
2628 NitsEndTest
2629
2630 extern "C" void MI_CALL MI_Session_GetInstance_Async_CancelBeforeResult_Result(
2631 _In_ MI_Operation *operation,
2632 _In_ void *callbackContext,
2633 _In_opt_ const MI_Instance *instance,
2634 MI_Boolean moreResults,
2635 _In_ MI_Result resultCode,
2636 _In_opt_z_ const MI_Char * errorString,
2637 _In_opt_ const MI_Instance *errorDetails,
2638 _In_opt_ MI_Result (MI_CALL * resultAcknowledgement)(_In_ MI_Operation *operation))
2639 {
2640 NitsCompare(resultCode, MI_RESULT_FAILED, PAL_T("Operation should have failed"));
2641
2642 if (!moreResults)
2643 {
2644 MI_Operation_Close(operation);
2645 }
2646 if (resultAcknowledgement)
2647 krisbash 1.1 {
2648 resultAcknowledgement(operation);
2649 }
2650 if (!moreResults)
2651 {
2652 CondLock_Broadcast((ptrdiff_t) callbackContext);
2653 }
2654 }
2655
2656 NitsTest3(MI_Session_GetInstance_Async_CancelBeforeResult,
2657 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
2658 SetupDefaultSession, SetupDefaultSessionDefaults,
2659 SetupTestInstance, g_SetupTestInstance_NoResult)
2660 {
2661 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
2662 ResetRuntimeTestData(testData);
2663 MI_Session *session = &testData->session;
2664 MI_Instance *testInstance = testData->testInstance;
2665 MI_Operation operation = MI_OPERATION_NULL;
2666 MI_OperationCallbacks callbacks = MI_OPERATIONCALLBACKS_NULL;
2667
2668 krisbash 1.1 callbacks.callbackContext = testData;
2669 callbacks.instanceResult = MI_Session_GetInstance_Async_CancelBeforeResult_Result;
2670
2671 MI_Session_GetInstance(session, 0, NULL, NULL, testInstance, &callbacks, &operation);
2672 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
2673
2674 MI_Operation_Cancel(&operation, MI_REASON_NONE);
2675
2676 WaitForOperationToComplete(testData);
2677 }
2678 NitsEndTest
2679
2680 NitsTest(MI_Session_GetInstance_Async_CloseSessionBeforeResult)
2681 {
2682 MI_Application application = MI_APPLICATION_NULL;
2683 MI_Session session = MI_SESSION_NULL;
2684 MI_Operation operation = MI_OPERATION_NULL;
2685 MI_OperationCallbacks callbacks = MI_OPERATIONCALLBACKS_NULL;
2686
2687 callbacks.instanceResult = MI_Session_GetInstance_Async_CancelBeforeResult_Result;
2688
2689 krisbash 1.1 if (NitsCompare(MI_Application_Initialize(0, NULL, NULL, &application), MI_RESULT_OK, PAL_T("MI_Application_Initialize returns OK")) &&
2690 NitsAssert(application.ft != NULL, PAL_T("MI_Application function table should not be NULL")))
2691 {
2692 MI_Instance *instance = TestCreateInstance(&application, PAL_T("NoResult"));
2693 if (NitsAssert(instance != NULL, PAL_T("failed to create instance")))
2694 {
2695 if (NitsCompare(MI_Application_NewSession(&application, PAL_T("Test1"), NULL, NULL, NULL, NULL, &session), MI_RESULT_OK, PAL_T("MI_Application_NewSession returns OK")) &&
2696 NitsAssert(session.ft != NULL, PAL_T("MI_Session function table should not be NULL")))
2697 {
2698 MI_Session_GetInstance(&session, 0, NULL, NULL, instance, &callbacks, &operation);
2699 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
2700
2701 MI_Session_Close(&session, NULL, NULL);
2702 }
2703 MI_Instance_Delete(instance);
2704 }
2705
2706 MI_Application_Close(&application);
2707 }
2708 }
2709 NitsEndTest
2710 krisbash 1.1
2711 NitsTest(MI_Session_GetInstance_Async_CloseSessionBeforeResult_ResultOnDifferentThread)
2712 {
2713 MI_Application application = MI_APPLICATION_NULL;
2714 MI_Session session = MI_SESSION_NULL;
2715 MI_Operation operation = MI_OPERATION_NULL;
2716 MI_OperationCallbacks callbacks = MI_OPERATIONCALLBACKS_NULL;
2717
2718 callbacks.instanceResult = MI_Session_GetInstance_Async_CancelBeforeResult_Result;
2719
2720 if (NitsCompare(MI_Application_Initialize(0, NULL, NULL, &application), MI_RESULT_OK, PAL_T("MI_Application_Initialize returns OK")) &&
2721 NitsAssert(application.ft != NULL, PAL_T("MI_Application function table should not be NULL")))
2722 {
2723 MI_Instance *instance = TestCreateInstance(&application, PAL_T("NoResultDifferentThread"));
2724 if (NitsAssert(instance != NULL, PAL_T("failed to create instance")))
2725 {
2726 if (NitsCompare(MI_Application_NewSession(&application, PAL_T("Test1"), NULL, NULL, NULL, NULL, &session), MI_RESULT_OK, PAL_T("MI_Application_NewSession returns OK")) &&
2727 NitsAssert(session.ft != NULL, PAL_T("MI_Session function table should not be NULL")))
2728 {
2729 MI_Session_GetInstance(&session, 0, NULL, NULL, instance, &callbacks, &operation);
2730 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
2731 krisbash 1.1
2732 MI_Session_Close(&session, NULL, NULL);
2733 }
2734 MI_Instance_Delete(instance);
2735 }
2736
2737 MI_Application_Close(&application);
2738 }
2739 }
2740 NitsEndTest
2741
2742 extern "C" void MI_CALL MI_Session_GetInstance_Async_CloseApplicationBeforeResult_ResultOnDifferentThread_Result_SessionClosed(_In_opt_ void *completionContext)
2743 {
2744 }
2745 extern "C" void MI_CALL MI_Session_GetInstance_Async_CloseApplicationBeforeResult_ResultOnDifferentThread_Result(
2746 _In_ MI_Operation *operation,
2747 _In_ void *callbackContext,
2748 _In_opt_ const MI_Instance *instance,
2749 MI_Boolean moreResults,
2750 _In_ MI_Result resultCode,
2751 _In_opt_z_ const MI_Char * errorString,
2752 krisbash 1.1 _In_opt_ const MI_Instance *errorDetails,
2753 _In_opt_ MI_Result (MI_CALL * resultAcknowledgement)(_In_ MI_Operation *operation))
2754 {
2755 MI_Session session = MI_SESSION_NULL;
2756 NitsCompare(resultCode, MI_RESULT_FAILED, PAL_T("Operation should have failed"));
2757 MI_Operation_GetSession(operation, &session);
2758
2759 if (resultAcknowledgement)
2760 {
2761 resultAcknowledgement(operation);
2762 }
2763
2764 if (!moreResults)
2765 {
2766 MI_Operation_Close(operation);
2767 MI_Session_Close(&session, NULL, MI_Session_GetInstance_Async_CloseApplicationBeforeResult_ResultOnDifferentThread_Result_SessionClosed);
2768 }
2769
2770 }
2771
2772
2773 krisbash 1.1 NitsTest(MI_Session_GetInstance_Async_CloseApplicationBeforeResult_ResultOnDifferentThread)
2774 {
2775 MI_Application application = MI_APPLICATION_NULL;
2776 MI_Session session = MI_SESSION_NULL;
2777 MI_Operation operation = MI_OPERATION_NULL;
2778 MI_OperationCallbacks callbacks = MI_OPERATIONCALLBACKS_NULL;
2779
2780 callbacks.instanceResult = MI_Session_GetInstance_Async_CloseApplicationBeforeResult_ResultOnDifferentThread_Result;
2781
2782 if (NitsCompare(MI_Application_Initialize(0, NULL, NULL, &application), MI_RESULT_OK, PAL_T("MI_Application_Initialize returns OK")) &&
2783 NitsAssert(application.ft != NULL, PAL_T("MI_Application function table should not be NULL")))
2784 {
2785 MI_Instance *instance = TestCreateInstance(&application, PAL_T("NoResultDifferentThread"));
2786 if (NitsAssert(instance != NULL, PAL_T("failed to create instance")))
2787 {
2788 if (NitsCompare(MI_Application_NewSession(&application, PAL_T("Test1"), NULL, NULL, NULL, NULL, &session), MI_RESULT_OK, PAL_T("MI_Application_NewSession returns OK")) &&
2789 NitsAssert(session.ft != NULL, PAL_T("MI_Session function table should not be NULL")))
2790 {
2791 MI_Session_GetInstance(&session, 0, NULL, NULL, instance, &callbacks, &operation);
2792 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
2793 /* session cleaned up in callback */
2794 krisbash 1.1 }
2795 MI_Instance_Delete(instance);
2796 }
2797
2798 MI_Application_Close(&application);
2799 }
2800 }
2801 NitsEndTest
2802
2803 #endif
2804 /*==========================================================================================*/
2805 /*=================================== Enumerate Instances ==================================*/
2806 /*==========================================================================================*/
2807
2808 NitsTest2(MI_Session_EnumerateInstances_Sync,
2809 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
2810 SetupDefaultSession, SetupDefaultSessionDefaults)
2811 {
2812 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
2813 ResetRuntimeTestData(testData);
2814 MI_Session *session = &testData->session;
2815 krisbash 1.1 MI_Operation operation = MI_OPERATION_NULL;
2816
2817 const MI_Instance *resultInstance;
2818 MI_Boolean moreResults = MI_TRUE;
2819 MI_Result result;
2820 const MI_Char *errorMessage;
2821 const MI_Instance *completionDetails;
2822 unsigned int resultCount = 0;
2823
2824 MI_Session_EnumerateInstances(session, 0, NULL, NULL, PAL_T("testClass"), MI_FALSE, NULL, &operation);
2825 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
2826
2827 while (moreResults && (++resultCount <= 10))
2828 {
2829 MI_Operation_GetInstance(&operation, &resultInstance, &moreResults, &result, &errorMessage, &completionDetails);
2830 NitsCompare(result, MI_RESULT_OK, PAL_T("Operation should succeed"));
2831 }
2832 NitsCompare(resultCount, 10, PAL_T("Should have 10 results"));
2833 MI_Operation_Close(&operation);
2834 }
2835 NitsEndTest
2836 krisbash 1.1
2837 NitsTest2(MI_Session_EnumerateInstances_Sync_WithOptions,
2838 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
2839 SetupDefaultSession, SetupDefaultSessionDefaults)
2840 {
2841 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
2842 ResetRuntimeTestData(testData);
2843 MI_Application *application = &testData->application;
2844 MI_Session *session = &testData->session;
2845 MI_Operation operation = MI_OPERATION_NULL;
2846 MI_OperationOptions options = MI_DESTINATIONOPTIONS_NULL;
2847
2848 if (NitsCompare(MI_Application_NewOperationOptions(application, MI_FALSE, &options), MI_RESULT_OK, PAL_T("NewOperationOptions should succeed")))
2849 {
2850 NitsCompare(options.ft->SetString(&options, PAL_T("option1"), PAL_T("value1"), 0), MI_RESULT_OK, PAL_T("SetString should work"));
2851 NitsCompare(options.ft->SetNumber(&options, PAL_T("option2"), 22, 0), MI_RESULT_OK, PAL_T("SetNumber should work"));
2852 {
2853 MI_Value value;
2854 value.string = (MI_Char*) PAL_T("hello world");
2855 NitsCompare(options.ft->SetCustomOption(&options, PAL_T("option3"), MI_STRING, &value, MI_FALSE, 0), MI_RESULT_OK, PAL_T("SetCustomString should work"));
2856 }
2857 krisbash 1.1
2858 const MI_Instance *resultInstance;
2859 MI_Boolean moreResults = MI_TRUE;
2860 MI_Result result;
2861 const MI_Char *errorMessage;
2862 const MI_Instance *completionDetails;
2863 unsigned int resultCount = 0;
2864
2865 MI_Session_EnumerateInstances(session, 0, &options, NULL, PAL_T("testClass"), MI_FALSE, NULL, &operation);
2866 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
2867
2868 while (moreResults && (++resultCount <= 10))
2869 {
2870 MI_Operation_GetInstance(&operation, &resultInstance, &moreResults, &result, &errorMessage, &completionDetails);
2871 NitsCompare(result, MI_RESULT_OK, PAL_T("Operation should succeed"));
2872 }
2873 NitsCompare(resultCount, 10, PAL_T("Should have 10 results"));
2874 MI_Operation_Close(&operation);
2875
2876 MI_OperationOptions_Delete(&options);
2877 }
2878 krisbash 1.1 }
2879 NitsEndTest
2880
2881 NitsTest2(MI_Session_EnumerateInstances_Sync_InvalidParameters,
2882 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
2883 SetupDefaultSession, SetupDefaultSessionDefaults)
2884 {
2885 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
2886 ResetRuntimeTestData(testData);
2887 MI_Session *session = &testData->session;
2888 MI_Operation operation = MI_OPERATION_NULL;
2889
2890 const MI_Instance *resultInstance;
2891 MI_Boolean moreResults = MI_TRUE;
2892 MI_Result result;
2893 const MI_Char *errorMessage;
2894 const MI_Instance *completionDetails;
2895 unsigned int resultCount = 0;
2896
2897 {/* success */
2898 MI_Session_EnumerateInstances(session, 0, NULL, NULL, PAL_T("testClass"), MI_FALSE, NULL, &operation);
2899 krisbash 1.1 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
2900
2901 while (moreResults && (++resultCount <= 10))
2902 {
2903 MI_Operation_GetInstance(&operation, &resultInstance, &moreResults, &result, &errorMessage, &completionDetails);
2904 NitsCompare(result, MI_RESULT_OK, PAL_T("Operation should succeed"));
2905 }
2906 NitsCompare(resultCount, 10, PAL_T("Should have 10 results"));
2907 MI_Operation_Close(&operation);
2908 }
2909 {/* no opertion */
2910 #if defined (_MSC_VER)
2911 #pragma prefast(push)
2912 #pragma prefast(disable: 6309)
2913 #endif
2914 MI_Session_EnumerateInstances(session, 0, NULL, NULL, PAL_T("testClass"), MI_FALSE, NULL, NULL);
2915 #if defined (_MSC_VER)
2916 #pragma prefast(pop)
2917 #endif
2918 /* nothing more we can do as no where for result to go */
2919 }
2920 krisbash 1.1 }
2921 NitsEndTest
2922
2923 NitsTest2(MI_Session_EnumerateInstances_Sync_TransportNotSupported,
2924 SetupDefaultApplication, g_RuntimeApplicationSetup_Test2,
2925 SetupDefaultSession, SetupDefaultSessionDefaults)
2926 {
2927 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
2928 ResetRuntimeTestData(testData);
2929 MI_Session *session = &testData->session;
2930 MI_Operation operation = MI_OPERATION_NULL;
2931
2932 const MI_Instance *resultInstance;
2933 MI_Boolean moreResults = MI_TRUE;
2934 MI_Result result;
2935 const MI_Char *errorMessage;
2936 const MI_Instance *completionDetails;
2937
2938 MI_Session_EnumerateInstances(session, 0, NULL, NULL, PAL_T("testClass"), MI_FALSE, NULL, &operation);
2939 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
2940
2941 krisbash 1.1 MI_Operation_GetInstance(&operation, &resultInstance, &moreResults, &result, &errorMessage, &completionDetails);
2942 NitsCompare(result, MI_RESULT_NOT_SUPPORTED, PAL_T("Operation should fail with not supported"));
2943 MI_Operation_Close(&operation);
2944 }
2945 NitsEndTest
2946
2947 NitsTest2(MI_Session_EnumerateInstances_Async_AutoAck,
2948 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
2949 SetupDefaultSession, SetupDefaultSessionDefaults)
2950 {
2951 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
2952 ResetRuntimeTestData(testData);
2953 MI_Session *session = &testData->session;
2954 MI_Operation operation = MI_OPERATION_NULL;
2955 MI_OperationCallbacks callbacks = MI_OPERATIONCALLBACKS_NULL;
2956
2957 g_maximumInstanceCount = 10;
2958 callbacks.callbackContext = testData;
2959 callbacks.instanceResult = GetInstanceResult;
2960
2961 MI_Session_EnumerateInstances(session, 0, NULL, NULL, PAL_T("testClass"), MI_FALSE, &callbacks, &operation);
2962 krisbash 1.1 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
2963
2964 WaitForOperationToComplete(testData);
2965
2966 NitsCompare((MI_Uint32)testData->instanceCount, (MI_Uint32)g_maximumInstanceCount, PAL_T("Number of results callbacks received"));
2967 }
2968 NitsEndTest
2969
2970 /*==========================================================================================*/
2971 /*===================================== Query Instances ====================================*/
2972 /*==========================================================================================*/
2973
2974 NitsTest2(MI_Session_QueryInstances_Sync,
2975 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
2976 SetupDefaultSession, SetupDefaultSessionDefaults)
2977 {
2978 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
2979 ResetRuntimeTestData(testData);
2980 MI_Session *session = &testData->session;
2981 MI_Operation operation = MI_OPERATION_NULL;
2982
2983 krisbash 1.1 const MI_Instance *resultInstance;
2984 MI_Boolean moreResults = MI_TRUE;
2985 MI_Result result;
2986 const MI_Char *errorMessage;
2987 const MI_Instance *completionDetails;
2988 unsigned int resultCount = 0;
2989
2990 MI_Session_QueryInstances(session, 0, NULL, PAL_T("namespace"), PAL_T("dialect"), PAL_T("filter"), NULL, &operation);
2991 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
2992
2993 while (moreResults && (++resultCount <= 10))
2994 {
2995 MI_Operation_GetInstance(&operation, &resultInstance, &moreResults, &result, &errorMessage, &completionDetails);
2996 NitsCompare(result, MI_RESULT_OK, PAL_T("Operation should succeed"));
2997 }
2998 NitsCompare(resultCount, 10, PAL_T("Should have 10 results"));
2999 MI_Operation_Close(&operation);
3000 }
3001 NitsEndTest
3002
3003 NitsTest2(MI_Session_QueryInstances_Sync_WithOptions,
3004 krisbash 1.1 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
3005 SetupDefaultSession, SetupDefaultSessionDefaults)
3006 {
3007 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
3008 ResetRuntimeTestData(testData);
3009 MI_Application *application = &testData->application;
3010 MI_Session *session = &testData->session;
3011 MI_Operation operation = MI_OPERATION_NULL;
3012
3013 MI_OperationOptions options = MI_DESTINATIONOPTIONS_NULL;
3014 if (NitsCompare(MI_Application_NewOperationOptions(application, MI_FALSE, &options), MI_RESULT_OK, PAL_T("NewOperationOptions should succeed")))
3015 {
3016 NitsCompare(options.ft->SetString(&options, PAL_T("option1"), PAL_T("value1"), 0), MI_RESULT_OK, PAL_T("SetString should work"));
3017 NitsCompare(options.ft->SetNumber(&options, PAL_T("option2"), 22, 0), MI_RESULT_OK, PAL_T("SetNumber should work"));
3018 {
3019 MI_Value value;
3020 value.string = (MI_Char*) PAL_T("hello world");
3021 NitsCompare(options.ft->SetCustomOption(&options, PAL_T("option3"), MI_STRING, &value, MI_FALSE, 0), MI_RESULT_OK, PAL_T("SetCustomString should work"));
3022 }
3023
3024 const MI_Instance *resultInstance;
3025 krisbash 1.1 MI_Boolean moreResults = MI_TRUE;
3026 MI_Result result;
3027 const MI_Char *errorMessage;
3028 const MI_Instance *completionDetails;
3029 unsigned int resultCount = 0;
3030
3031 MI_Session_QueryInstances(session, 0, &options, PAL_T("namespace"), PAL_T("dialect"), PAL_T("filter"), NULL, &operation);
3032 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
3033
3034 while (moreResults && (++resultCount <= 10))
3035 {
3036 MI_Operation_GetInstance(&operation, &resultInstance, &moreResults, &result, &errorMessage, &completionDetails);
3037 NitsCompare(result, MI_RESULT_OK, PAL_T("Operation should succeed"));
3038 }
3039 NitsCompare(resultCount, 10, PAL_T("Should have 10 results"));
3040 MI_Operation_Close(&operation);
3041
3042 MI_OperationOptions_Delete(&options);
3043 }
3044 }
3045 NitsEndTest
3046 krisbash 1.1
3047 NitsTest2(MI_Session_QueryInstances_Sync_InvalidParameters,
3048 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
3049 SetupDefaultSession, SetupDefaultSessionDefaults)
3050 {
3051 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
3052 ResetRuntimeTestData(testData);
3053 MI_Session *session = &testData->session;
3054 MI_Operation operation = MI_OPERATION_NULL;
3055
3056 const MI_Instance *resultInstance;
3057 MI_Boolean moreResults = MI_TRUE;
3058 MI_Result result = MI_RESULT_FAILED;
3059 const MI_Char *errorMessage;
3060 const MI_Instance *completionDetails;
3061 unsigned int resultCount = 0;
3062
3063 {/* success */
3064 MI_Session_QueryInstances(session, 0, NULL, PAL_T("namespace"), PAL_T("dialect"), PAL_T("filter"), NULL, &operation);
3065 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
3066
3067 krisbash 1.1 while (moreResults && (++resultCount <= 10))
3068 {
3069 MI_Operation_GetInstance(&operation, &resultInstance, &moreResults, &result, &errorMessage, &completionDetails);
3070 NitsCompare(result, MI_RESULT_OK, PAL_T("Operation should succeed"));
3071 }
3072 NitsCompare(resultCount, 10, PAL_T("Should have 10 results"));
3073 MI_Operation_Close(&operation);
3074 }
3075 {/* no filter */
3076 MI_Session_QueryInstances(session, 0, NULL, PAL_T("namespace"), NULL, NULL, NULL, &operation);
3077 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
3078 resultCount = 0;
3079 moreResults = MI_TRUE;
3080 while (moreResults && (++resultCount <= 10))
3081 {
3082 MI_Operation_GetInstance(&operation, &resultInstance, &moreResults, &result, &errorMessage, &completionDetails);
3083 NitsCompare(result, MI_RESULT_OK, PAL_T("Operation should succeed"));
3084 }
3085 NitsCompare(result, MI_RESULT_OK, PAL_T("Operation should succeed"));
3086 MI_Operation_Close(&operation);
3087 }
3088 krisbash 1.1 {/* no opertion */
3089 #if defined (_MSC_VER)
3090 #pragma prefast(push)
3091 #pragma prefast(disable: 6309)
3092 #endif
3093 MI_Session_QueryInstances(session, 0, NULL, NULL, PAL_T("dialect"), PAL_T("filter"), NULL, NULL);
3094 #if defined (_MSC_VER)
3095 #pragma prefast(pop)
3096 #endif
3097 /* nothing more we can do as no where for result to go */
3098 }
3099
3100 }
3101 NitsEndTest
3102
3103 NitsTest2(MI_Session_QueryInstances_Sync_TransportNotSupported,
3104 SetupDefaultApplication, g_RuntimeApplicationSetup_Test2,
3105 SetupDefaultSession, SetupDefaultSessionDefaults)
3106 {
3107 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
3108 ResetRuntimeTestData(testData);
3109 krisbash 1.1 MI_Session *session = &testData->session;
3110 MI_Operation operation = MI_OPERATION_NULL;
3111
3112 const MI_Instance *resultInstance;
3113 MI_Boolean moreResults = MI_TRUE;
3114 MI_Result result;
3115 const MI_Char *errorMessage;
3116 const MI_Instance *completionDetails;
3117
3118 MI_Session_QueryInstances(session, 0, NULL, PAL_T("namespace"), PAL_T("dialect"), PAL_T("filter"), NULL, &operation);
3119 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
3120
3121 MI_Operation_GetInstance(&operation, &resultInstance, &moreResults, &result, &errorMessage, &completionDetails);
3122 NitsCompare(result, MI_RESULT_NOT_SUPPORTED, PAL_T("Operation should fail with not supported"));
3123 MI_Operation_Close(&operation);
3124 }
3125 NitsEndTest
3126
3127 NitsTest2(MI_Session_QueryInstances_Async_AutoAck,
3128 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
3129 SetupDefaultSession, SetupDefaultSessionDefaults)
3130 krisbash 1.1 {
3131 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
3132 ResetRuntimeTestData(testData);
3133 MI_Session *session = &testData->session;
3134 MI_Operation operation = MI_OPERATION_NULL;
3135 MI_OperationCallbacks callbacks = MI_OPERATIONCALLBACKS_NULL;
3136
3137 g_maximumInstanceCount = 10;
3138 callbacks.callbackContext = testData;
3139 callbacks.instanceResult = GetInstanceResult;
3140
3141 MI_Session_QueryInstances(session, 0, NULL, PAL_T("namespace"), PAL_T("dialect"), PAL_T("filter"), &callbacks, &operation);
3142 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
3143
3144 WaitForOperationToComplete(testData);
3145
3146 NitsCompare((MI_Uint32)testData->instanceCount, (MI_Uint32)g_maximumInstanceCount, PAL_T("Number of results callbacks received"));
3147 }
3148 NitsEndTest
3149
3150 /*==========================================================================================*/
3151 krisbash 1.1 /*=================================== ASSOCIATOR INSTANCE ==================================*/
3152 /*==========================================================================================*/
3153
3154 NitsTest3(MI_Session_AssociatorInstances_Sync,
3155 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
3156 SetupDefaultSession, SetupDefaultSessionDefaults,
3157 SetupTestInstance, g_SetupTestInstance_test)
3158 {
3159 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
3160 ResetRuntimeTestData(testData);
3161 MI_Session *session = &testData->session;
3162 MI_Instance *testInstance = testData->testInstance;
3163 MI_Operation operation = MI_OPERATION_NULL;
3164
3165 const MI_Instance *resultInstance;
3166 MI_Boolean moreResults = MI_TRUE;
3167 MI_Result result;
3168 const MI_Char *errorMessage;
3169 const MI_Instance *completionDetails;
3170 unsigned int resultCount = 0;
3171
3172 krisbash 1.1 MI_Session_AssociatorInstances(session, 0, NULL, NULL, testInstance, NULL, PAL_T("test"), NULL, NULL, MI_FALSE, NULL, &operation);
3173 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
3174
3175 while (moreResults && (++resultCount <= 10))
3176 {
3177 MI_Operation_GetInstance(&operation, &resultInstance, &moreResults, &result, &errorMessage, &completionDetails);
3178 NitsCompare(result, MI_RESULT_OK, PAL_T("Operation should succeed"));
3179 }
3180 NitsCompare(resultCount, 10, PAL_T("Should have 10 results"));
3181 MI_Operation_Close(&operation);
3182 }
3183 NitsEndTest
3184
3185 NitsTest3(MI_Session_AssociatorInstances_Sync_WithOptions,
3186 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
3187 SetupDefaultSession, SetupDefaultSessionDefaults,
3188 SetupTestInstance, g_SetupTestInstance_test)
3189 {
3190 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
3191 ResetRuntimeTestData(testData);
3192 MI_Application *application = &testData->application;
3193 krisbash 1.1 MI_Session *session = &testData->session;
3194 MI_Instance *testInstance = testData->testInstance;
3195 MI_Operation operation = MI_OPERATION_NULL;
3196
3197 MI_OperationOptions options = MI_OPERATIONOPTIONS_NULL;
3198 if (NitsCompare(MI_Application_NewOperationOptions(application, MI_FALSE, &options), MI_RESULT_OK, PAL_T("NewOperationOptions should succeed")))
3199 {
3200 NitsCompare(options.ft->SetString(&options, PAL_T("option1"), PAL_T("value1"), 0), MI_RESULT_OK, PAL_T("SetString should work"));
3201 NitsCompare(options.ft->SetNumber(&options, PAL_T("option2"), 22, 0), MI_RESULT_OK, PAL_T("SetNumber should work"));
3202 {
3203 MI_Value value;
3204 value.string = (MI_Char*)PAL_T("hello world");
3205 NitsCompare(options.ft->SetCustomOption(&options, PAL_T("option3"), MI_STRING, &value, MI_FALSE, 0), MI_RESULT_OK, PAL_T("SetCustomString should work"));
3206 }
3207
3208 const MI_Instance *resultInstance;
3209 MI_Boolean moreResults = MI_TRUE;
3210 MI_Result result;
3211 const MI_Char *errorMessage;
3212 const MI_Instance *completionDetails;
3213 unsigned int resultCount = 0;
3214 krisbash 1.1
3215 MI_Session_AssociatorInstances(session, 0, &options, NULL, testInstance, NULL, PAL_T("test"), NULL, NULL, MI_FALSE, NULL, &operation);
3216 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
3217
3218 while (moreResults && (++resultCount <= 10))
3219 {
3220 MI_Operation_GetInstance(&operation, &resultInstance, &moreResults, &result, &errorMessage, &completionDetails);
3221 NitsCompare(result, MI_RESULT_OK, PAL_T("Operation should succeed"));
3222 }
3223 NitsCompare(resultCount, 10, PAL_T("Should have 10 results"));
3224 MI_Operation_Close(&operation);
3225
3226 MI_OperationOptions_Delete(&options);
3227 }
3228 }
3229 NitsEndTest
3230
3231
3232 NitsTest3(MI_Session_AssociatorInstances_Sync_InvalidParameters,
3233 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
3234 SetupDefaultSession, SetupDefaultSessionDefaults,
3235 krisbash 1.1 SetupTestInstance, g_SetupTestInstance_test)
3236 {
3237 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
3238 ResetRuntimeTestData(testData);
3239 MI_Session *session = &testData->session;
3240 MI_Instance *testInstance = testData->testInstance;
3241 MI_Operation operation = MI_OPERATION_NULL;
3242
3243 const MI_Instance *resultInstance;
3244 MI_Boolean moreResults = MI_TRUE;
3245 MI_Result result;
3246 const MI_Char *errorMessage;
3247 const MI_Instance *completionDetails;
3248 unsigned int resultCount = 0;
3249
3250 {/* success */
3251 MI_Session_AssociatorInstances(session, 0, NULL, NULL, testInstance, NULL, PAL_T("test"), NULL, NULL, MI_FALSE, NULL, &operation);
3252 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
3253
3254 while (moreResults && (++resultCount <= 10))
3255 {
3256 krisbash 1.1 MI_Operation_GetInstance(&operation, &resultInstance, &moreResults, &result, &errorMessage, &completionDetails);
3257 NitsCompare(result, MI_RESULT_OK, PAL_T("Operation should succeed"));
3258 }
3259 NitsCompare(resultCount, 10, PAL_T("Should have 10 results"));
3260 MI_Operation_Close(&operation);
3261 }
3262 {/* no class */
3263 #if defined (_MSC_VER)
3264 #pragma prefast(push)
3265 #pragma prefast(disable: 6309)
3266 #endif
3267 MI_Session_AssociatorInstances(session, 0, NULL, NULL, NULL, NULL, PAL_T("test"), NULL, NULL, MI_FALSE, NULL, &operation);
3268 #if defined (_MSC_VER)
3269 #pragma prefast(pop)
3270 #endif
3271 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
3272
3273 MI_Operation_GetInstance(&operation, &resultInstance, &moreResults, &result, &errorMessage, &completionDetails);
3274 NitsCompare(result, MI_RESULT_INVALID_PARAMETER, PAL_T("Operation should succeed"));
3275 MI_Operation_Close(&operation);
3276 }
3277 krisbash 1.1 {/* no opertion */
3278 #if defined (_MSC_VER)
3279 #pragma prefast(push)
3280 #pragma prefast(disable: 6309)
3281 #endif
3282 MI_Session_AssociatorInstances(session, 0, NULL, NULL, testInstance, NULL, PAL_T("test"), NULL, NULL, MI_FALSE, NULL, NULL);
3283 #if defined (_MSC_VER)
3284 #pragma prefast(pop)
3285 #endif
3286 /* nothing more we can do as no where for result to go */
3287 }
3288 }
3289 NitsEndTest
3290
3291 NitsTest3(MI_Session_AssociatorInstances_Sync_TransportNotSupported,
3292 SetupDefaultApplication, g_RuntimeApplicationSetup_Test2,
3293 SetupDefaultSession, SetupDefaultSessionDefaults,
3294 SetupTestInstance, g_SetupTestInstance_test)
3295 {
3296 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
3297 ResetRuntimeTestData(testData);
3298 krisbash 1.1 MI_Session *session = &testData->session;
3299 MI_Instance *testInstance = testData->testInstance;
3300 MI_Operation operation = MI_OPERATION_NULL;
3301
3302 const MI_Instance *resultInstance;
3303 MI_Boolean moreResults = MI_TRUE;
3304 MI_Result result;
3305 const MI_Char *errorMessage;
3306 const MI_Instance *completionDetails;
3307
3308 MI_Session_AssociatorInstances(session, 0, NULL, NULL, testInstance, NULL, PAL_T("test"), NULL, NULL, MI_FALSE, NULL, &operation);
3309 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
3310
3311 MI_Operation_GetInstance(&operation, &resultInstance, &moreResults, &result, &errorMessage, &completionDetails);
3312 NitsCompare(result, MI_RESULT_NOT_SUPPORTED, PAL_T("Operation should fail with not supported"));
3313 MI_Operation_Close(&operation);
3314 }
3315 NitsEndTest
3316
3317 NitsTest3(MI_Session_AssociatorInstances_Async_AutoAck,
3318 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
3319 krisbash 1.1 SetupDefaultSession, SetupDefaultSessionDefaults,
3320 SetupTestInstance, g_SetupTestInstance_test)
3321 {
3322 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
3323 ResetRuntimeTestData(testData);
3324 MI_Session *session = &testData->session;
3325 MI_Instance *testInstance = testData->testInstance;
3326 MI_Operation operation = MI_OPERATION_NULL;
3327 MI_OperationCallbacks callbacks = MI_OPERATIONCALLBACKS_NULL;
3328
3329 g_maximumInstanceCount = 10;
3330 callbacks.callbackContext = testData;
3331 callbacks.instanceResult = GetInstanceResult;
3332
3333 MI_Session_AssociatorInstances(session, 0, NULL, NULL, testInstance, NULL, PAL_T("test"), NULL, NULL, MI_FALSE, &callbacks, &operation);
3334 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
3335
3336 WaitForOperationToComplete(testData);
3337
3338 NitsAssert(testData->instanceCount == g_maximumInstanceCount, PAL_T("Number of results callbacks received"));
3339 }
3340 krisbash 1.1 NitsEndTest
3341
3342 /*==========================================================================================*/
3343 /*=================================== REFERENCE INSTANCE ===================================*/
3344 /*==========================================================================================*/
3345
3346 NitsTest3(MI_Session_ReferenceInstances_Sync,
3347 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
3348 SetupDefaultSession, SetupDefaultSessionDefaults,
3349 SetupTestInstance, g_SetupTestInstance_test)
3350 {
3351 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
3352 ResetRuntimeTestData(testData);
3353 MI_Session *session = &testData->session;
3354 MI_Instance *testInstance = testData->testInstance;
3355 MI_Operation operation = MI_OPERATION_NULL;
3356
3357 const MI_Instance *resultInstance;
3358 MI_Boolean moreResults = MI_TRUE;
3359 MI_Result result;
3360 const MI_Char *errorMessage;
3361 krisbash 1.1 const MI_Instance *completionDetails;
3362 unsigned int resultCount = 0;
3363
3364 MI_Session_ReferenceInstances(session, 0, NULL, NULL, testInstance, PAL_T("test"), NULL, MI_FALSE, NULL, &operation);
3365 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
3366
3367 while (moreResults && (++resultCount <= 10))
3368 {
3369 MI_Operation_GetInstance(&operation, &resultInstance, &moreResults, &result, &errorMessage, &completionDetails);
3370 NitsCompare(result, MI_RESULT_OK, PAL_T("Operation should succeed"));
3371 }
3372 NitsCompare(resultCount, 10, PAL_T("Should have 10 results"));
3373 MI_Operation_Close(&operation);
3374 }
3375 NitsEndTest
3376
3377 NitsTest3(MI_Session_ReferenceInstances_Sync_WithOptions,
3378 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
3379 SetupDefaultSession, SetupDefaultSessionDefaults,
3380 SetupTestInstance, g_SetupTestInstance_test)
3381 {
3382 krisbash 1.1 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
3383 ResetRuntimeTestData(testData);
3384 MI_Application *application = &testData->application;
3385 MI_Session *session = &testData->session;
3386 MI_Instance *testInstance = testData->testInstance;
3387 MI_Operation operation = MI_OPERATION_NULL;
3388
3389 MI_OperationOptions options = MI_OPERATIONOPTIONS_NULL;
3390 if (NitsCompare(MI_Application_NewOperationOptions(application, MI_FALSE, &options), MI_RESULT_OK, PAL_T("NewOperationOptions should succeed")))
3391 {
3392 NitsCompare(options.ft->SetString(&options, PAL_T("option1"), PAL_T("value1"), 0), MI_RESULT_OK, PAL_T("SetString should work"));
3393 NitsCompare(options.ft->SetNumber(&options, PAL_T("option2"), 22, 0), MI_RESULT_OK, PAL_T("SetNumber should work"));
3394 {
3395 MI_Value value;
3396 value.string = (MI_Char *) PAL_T("hello world");
3397 NitsCompare(options.ft->SetCustomOption(&options, PAL_T("option3"), MI_STRING, &value, MI_FALSE, 0), MI_RESULT_OK, PAL_T("SetCustomString should work"));
3398 }
3399
3400 const MI_Instance *resultInstance;
3401 MI_Boolean moreResults = MI_TRUE;
3402 MI_Result result;
3403 krisbash 1.1 const MI_Char *errorMessage;
3404 const MI_Instance *completionDetails;
3405 unsigned int resultCount = 0;
3406
3407 MI_Session_ReferenceInstances(session, 0, &options, NULL, testInstance, PAL_T("test"), NULL, MI_FALSE, NULL, &operation);
3408 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
3409
3410 while (moreResults && (++resultCount <= 10))
3411 {
3412 MI_Operation_GetInstance(&operation, &resultInstance, &moreResults, &result, &errorMessage, &completionDetails);
3413 NitsCompare(result, MI_RESULT_OK, PAL_T("Operation should succeed"));
3414 }
3415 NitsCompare(resultCount, 10, PAL_T("Should have 10 results"));
3416 MI_Operation_Close(&operation);
3417
3418 MI_OperationOptions_Delete(&options);
3419 }
3420 }
3421 NitsEndTest
3422
3423 NitsTest3(MI_Session_ReferenceInstances_Sync_InvalidParameters,
3424 krisbash 1.1 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
3425 SetupDefaultSession, SetupDefaultSessionDefaults,
3426 SetupTestInstance, g_SetupTestInstance_test)
3427 {
3428 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
3429 ResetRuntimeTestData(testData);
3430 MI_Session *session = &testData->session;
3431 MI_Instance *testInstance = testData->testInstance;
3432 MI_Operation operation = MI_OPERATION_NULL;
3433
3434 const MI_Instance *resultInstance;
3435 MI_Boolean moreResults = MI_TRUE;
3436 MI_Result result;
3437 const MI_Char *errorMessage;
3438 const MI_Instance *completionDetails;
3439 unsigned int resultCount = 0;
3440
3441 {/* success */
3442 MI_Session_ReferenceInstances(session, 0, NULL, NULL, testInstance, PAL_T("test"), NULL, MI_FALSE, NULL, &operation);
3443 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
3444
3445 krisbash 1.1 while (moreResults && (++resultCount <= 10))
3446 {
3447 MI_Operation_GetInstance(&operation, &resultInstance, &moreResults, &result, &errorMessage, &completionDetails);
3448 NitsCompare(result, MI_RESULT_OK, PAL_T("Operation should succeed"));
3449 }
3450 NitsCompare(resultCount, 10, PAL_T("Should have 10 results"));
3451 MI_Operation_Close(&operation);
3452 }
3453 {/* no class */
3454 #if defined (_MSC_VER)
3455 #pragma prefast(push)
3456 #pragma prefast(disable: 6309)
3457 #endif
3458 MI_Session_ReferenceInstances(session, 0, NULL, NULL, NULL , PAL_T("test"), NULL, MI_FALSE, NULL, &operation);
3459 #if defined (_MSC_VER)
3460 #pragma prefast(pop)
3461 #endif
3462 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
3463
3464 MI_Operation_GetInstance(&operation, &resultInstance, &moreResults, &result, &errorMessage, &completionDetails);
3465 NitsCompare(result, MI_RESULT_INVALID_PARAMETER, PAL_T("Operation should succeed"));
3466 krisbash 1.1 MI_Operation_Close(&operation);
3467 }
3468 {/* no opertion */
3469 #if defined (_MSC_VER)
3470 #pragma prefast(push)
3471 #pragma prefast(disable: 6309)
3472 #endif
3473 MI_Session_ReferenceInstances(session, 0, NULL, NULL, testInstance, PAL_T("test"), NULL, MI_FALSE, NULL, NULL);
3474 #if defined (_MSC_VER)
3475 #pragma prefast(pop)
3476 #endif
3477 /* nothing more we can do as no where for result to go */
3478 }
3479 }
3480 NitsEndTest
3481
3482 NitsTest3(MI_Session_ReferenceInstances_Sync_TransportNotSupported,
3483 SetupDefaultApplication, g_RuntimeApplicationSetup_Test2,
3484 SetupDefaultSession, SetupDefaultSessionDefaults,
3485 SetupTestInstance, g_SetupTestInstance_test)
3486 {
3487 krisbash 1.1 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
3488 ResetRuntimeTestData(testData);
3489 MI_Session *session = &testData->session;
3490 MI_Instance *testInstance = testData->testInstance;
3491 MI_Operation operation = MI_OPERATION_NULL;
3492
3493 const MI_Instance *resultInstance;
3494 MI_Boolean moreResults = MI_TRUE;
3495 MI_Result result;
3496 const MI_Char *errorMessage;
3497 const MI_Instance *completionDetails;
3498
3499 MI_Session_ReferenceInstances(session, 0, NULL, NULL, testInstance, PAL_T("test"), NULL, MI_FALSE, NULL, &operation);
3500 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
3501
3502 MI_Operation_GetInstance(&operation, &resultInstance, &moreResults, &result, &errorMessage, &completionDetails);
3503 NitsCompare(result, MI_RESULT_NOT_SUPPORTED, PAL_T("Operation should fail with not supported"));
3504 MI_Operation_Close(&operation);
3505 }
3506 NitsEndTest
3507
3508 krisbash 1.1 NitsTest3(MI_Session_ReferenceInstances_Async_AutoAck,
3509 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
3510 SetupDefaultSession, SetupDefaultSessionDefaults,
3511 SetupTestInstance, g_SetupTestInstance_test)
3512 {
3513 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
3514 ResetRuntimeTestData(testData);
3515 MI_Session *session = &testData->session;
3516 MI_Instance *testInstance = testData->testInstance;
3517 MI_Operation operation = MI_OPERATION_NULL;
3518 MI_OperationCallbacks callbacks = MI_OPERATIONCALLBACKS_NULL;
3519
3520 g_maximumInstanceCount = 10;
3521 callbacks.callbackContext = testData;
3522 callbacks.instanceResult = GetInstanceResult;
3523
3524 MI_Session_ReferenceInstances(session, 0, NULL, NULL, testInstance, PAL_T("test"), NULL, MI_FALSE, &callbacks, &operation);
3525 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
3526
3527 WaitForOperationToComplete(testData);
3528
3529 krisbash 1.1 NitsAssert(testData->instanceCount == g_maximumInstanceCount, PAL_T("Number of results callbacks received"));
3530 }
3531 NitsEndTest
3532
3533 /*==========================================================================================*/
3534 /*======================================== Get Class =======================================*/
3535 /*==========================================================================================*/
3536
3537 NitsTest2(MI_Session_GetClass_Sync,
3538 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
3539 SetupDefaultSession, SetupDefaultSessionDefaults)
3540 {
3541 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
3542 ResetRuntimeTestData(testData);
3543 MI_Session *session = &testData->session;
3544 MI_Operation operation = MI_OPERATION_NULL;
3545
3546 const MI_Class *resultClass;
3547 MI_Boolean moreResults;
3548 MI_Result result;
3549 const MI_Char *errorMessage;
3550 krisbash 1.1 const MI_Instance *completionDetails;
3551
3552 MI_Session_GetClass(session, 0, NULL, PAL_T("namespace"), PAL_T("myClass"), NULL, &operation);
3553 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
3554
3555 MI_Operation_GetClass(&operation, &resultClass, &moreResults, &result, &errorMessage, &completionDetails);
3556 NitsCompare(result, MI_RESULT_OK, PAL_T("Operation should succeed"));
3557 NitsAssert(moreResults==MI_FALSE, PAL_T("Should be no more results"));
3558
3559 MI_Operation_Close(&operation);
3560 }
3561 NitsEndTest
3562
3563
3564 NitsTest2(MI_Session_GetClass_Async_AutoAck,
3565 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
3566 SetupDefaultSession, SetupDefaultSessionDefaults)
3567 {
3568 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
3569 ResetRuntimeTestData(testData);
3570 MI_Session *session = &testData->session;
3571 krisbash 1.1 MI_Operation operation = MI_OPERATION_NULL;
3572 MI_OperationCallbacks callbacks = MI_OPERATIONCALLBACKS_NULL;
3573
3574 g_maximumInstanceCount = 1;
3575 callbacks.callbackContext = testData;
3576 callbacks.classResult = GetClassResult;
3577
3578 MI_Session_GetClass(session, 0, NULL, PAL_T("Namespace"), PAL_T("MyClass"), &callbacks, &operation);
3579 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
3580
3581 WaitForOperationToComplete(testData);
3582
3583 NitsCompare((MI_Uint32)testData->classCount, (MI_Uint32)g_maximumInstanceCount, PAL_T("Number of results callbacks received"));
3584 }
3585 NitsEndTest
3586
3587 NitsTest2(MI_Session_GetClass_Async_ManualAck,
3588 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
3589 SetupDefaultSession, SetupDefaultSessionDefaults)
3590 {
3591 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
3592 krisbash 1.1 ResetRuntimeTestData(testData);
3593 MI_Session *session = &testData->session;
3594 MI_Operation operation = MI_OPERATION_NULL;
3595 MI_OperationCallbacks callbacks = MI_OPERATIONCALLBACKS_NULL;
3596
3597 g_maximumInstanceCount = 1;
3598 callbacks.callbackContext = testData;
3599 callbacks.classResult = GetClassResult;
3600
3601 MI_Session_GetClass(session, MI_OPERATIONFLAGS_MANUAL_ACK_RESULTS, NULL, PAL_T("namespace"), PAL_T("myClass"), &callbacks, &operation);
3602 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
3603
3604 WaitForOperationToComplete(testData);
3605
3606 NitsCompare((MI_Uint32)testData->classCount, (MI_Uint32)g_maximumInstanceCount, PAL_T("Number of results callbacks received"));
3607 }
3608 NitsEndTest
3609
3610 NitsTest2(MI_Session_GetClass_Sync_WithOptions,
3611 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
3612 SetupDefaultSession, SetupDefaultSessionDefaults)
3613 krisbash 1.1 {
3614 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
3615 ResetRuntimeTestData(testData);
3616 MI_Application *application = &testData->application;
3617 MI_Session *session = &testData->session;
3618 MI_Operation operation = MI_OPERATION_NULL;
3619 MI_OperationOptions options = MI_OPERATIONOPTIONS_NULL;
3620
3621 if (NitsCompare(MI_Application_NewOperationOptions(application, MI_FALSE, &options), MI_RESULT_OK, PAL_T("NewOperationOptions should succeed")))
3622 {
3623 NitsCompare(options.ft->SetString(&options, PAL_T("option1"), PAL_T("value1"), 0), MI_RESULT_OK, PAL_T("SetString should work"));
3624 NitsCompare(options.ft->SetNumber(&options, PAL_T("option2"), 22, 0), MI_RESULT_OK, PAL_T("SetNumber should work"));
3625 {
3626 MI_Value value;
3627 value.string = (MI_Char *)PAL_T("hello world");
3628 NitsCompare(options.ft->SetCustomOption(&options, PAL_T("option3"), MI_STRING, &value, MI_FALSE, 0), MI_RESULT_OK, PAL_T("SetCustomString should work"));
3629 }
3630
3631 const MI_Class *resultClass;
3632 MI_Boolean moreResults;
3633 MI_Result result;
3634 krisbash 1.1 const MI_Char *errorMessage;
3635 const MI_Instance *completionDetails;
3636
3637 MI_Session_GetClass(session, 0, &options, PAL_T("mynamespace"), PAL_T("myclass"), NULL, &operation);
3638 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
3639
3640 MI_Operation_GetClass(&operation, &resultClass, &moreResults, &result, &errorMessage, &completionDetails);
3641 NitsCompare(result, MI_RESULT_OK, PAL_T("Operation should succeed"));
3642 NitsAssert(moreResults==MI_FALSE, PAL_T("Should be no more results"));
3643
3644 MI_Operation_Close(&operation);
3645
3646 MI_OperationOptions_Delete(&options);
3647 }
3648 }
3649 NitsEndTest
3650
3651 #if 0
3652 NitsTest(MI_Session_GetClass_Sync_InvalidParameters)
3653 {
3654 MI_Application application = MI_APPLICATION_NULL;
3655 krisbash 1.1 MI_Session session = MI_SESSION_NULL;
3656 MI_Operation operation = MI_OPERATION_NULL;
3657 const MI_Class*result;
3658 const MI_Instance *extendedInfo;
3659 MI_Boolean moreResults;
3660 MI_Result resultCode;
3661 MI_Result returnValue;
3662 const MI_Char *errorMessage;
3663 MI_OperationCallbacks callbacks = MI_OPERATIONCALLBACKS_NULL;
3664 callbacks.classResult = GetClassResult_Fail;
3665
3666 if (NitsCompare(MI_Application_Initialize(0, NULL, NULL, &application), MI_RESULT_OK, PAL_T("MI_Application_Initialize returns OK")) &&
3667 NitsAssert(application.ft != NULL, PAL_T("MI_Application function table should not be NULL")))
3668 {
3669 if (NitsCompare(MI_Application_NewSession(&application, PAL_T("Test1"), NULL, NULL, NULL, NULL, &session), MI_RESULT_OK, PAL_T("MI_Application_NewSession returns OK")) &&
3670 NitsAssert(session.ft != NULL, PAL_T("MI_Session function table should not be NULL")))
3671 {
3672 session.ft->GetClass(&session, 0, NULL, PAL_T("namespace"), PAL_T("myclass"), NULL, &operation);
3673 MI_Operation_GetClass(&operation, &result, &moreResults, &resultCode, &errorMessage, &extendedInfo);
3674 NitsCompare(resultCode, MI_RESULT_OK, PAL_T("GetClass should succeed"));
3675
3676 krisbash 1.1 returnValue = operation.ft->GetClass(NULL, &result, NULL, &resultCode, NULL, NULL);
3677 NitsCompare(returnValue, MI_RESULT_INVALID_PARAMETER, PAL_T("Operation_GetClass should fail due to NULL operation"));
3678
3679 returnValue = operation.ft->GetClass(&operation, NULL, NULL, &resultCode, NULL, NULL);
3680 NitsCompare(returnValue, MI_RESULT_INVALID_PARAMETER, PAL_T("Operation_GetClass should fail due to NULL instance"));
3681
3682 operation.ft->GetClass(&operation, NULL, NULL, NULL, NULL, NULL);
3683 /* no where for result to go but may add code coverage for scenario */
3684
3685 MI_Operation_Close(&operation);
3686
3687 session.ft->GetClass(NULL, 0, NULL, PAL_T("namespace"), PAL_T("className"), NULL, &operation);
3688 MI_Operation_GetClass(&operation, &result, &moreResults, &resultCode, &errorMessage, &extendedInfo);
3689 NitsCompare(resultCode, MI_RESULT_INVALID_PARAMETER, PAL_T("GetClass should faul due to NULL session"));
3690 MI_Operation_Close(&operation);
3691
3692 session.ft->GetClass(&session, 0, NULL, PAL_T("namespace"), PAL_T("className"), &callbacks, NULL);
3693 MI_Operation_GetClass(&operation, &result, &moreResults, &resultCode, &errorMessage, &extendedInfo);
3694 NitsCompare(resultCode, MI_RESULT_INVALID_PARAMETER, PAL_T("GetClass should fail due to null operation, has callbacks"));
3695 MI_Operation_Close(&operation);
3696
3697 krisbash 1.1 session.ft->GetClass(&session, 0, NULL, PAL_T("namespace"), PAL_T("myclass"), NULL, NULL);
3698 /* Validate it doesn't crash only as nowhere for failure to go */
3699 MI_Session_Close(&session, NULL, NULL);
3700
3701 session.ft->GetClass(&session, 0, NULL, PAL_T("mynamespace"), PAL_T("myclass"), NULL, &operation);
3702 MI_Operation_GetClass(&operation, &result, &moreResults, &resultCode, &errorMessage, &extendedInfo);
3703 NitsCompare(resultCode, MI_RESULT_INVALID_PARAMETER, PAL_T("GetClass should fail because session is already closed"));
3704 MI_Operation_Close(&operation);
3705
3706 }
3707 MI_Application_Close(&application);
3708 }
3709 }
3710 NitsEndTest
3711 #endif
3712
3713 NitsTest2(MI_Session_GetClass_TransportNotSupported,
3714 SetupDefaultApplication, g_RuntimeApplicationSetup_Test2,
3715 SetupDefaultSession, SetupDefaultSessionDefaults)
3716 {
3717 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
3718 krisbash 1.1 ResetRuntimeTestData(testData);
3719 MI_Session *session = &testData->session;
3720 MI_Operation operation = MI_OPERATION_NULL;
3721
3722 const MI_Class *resultClass;
3723 MI_Boolean moreResults;
3724 MI_Result result;
3725 const MI_Char *errorMessage;
3726 const MI_Instance *completionDetails;
3727
3728 MI_Session_GetClass(session, 0, NULL, PAL_T("mynamespace"), PAL_T("myclass"), NULL, &operation);
3729
3730 MI_Operation_GetClass(&operation, &resultClass, &moreResults, &result, &errorMessage, &completionDetails);
3731 NitsCompare(result, MI_RESULT_NOT_SUPPORTED, PAL_T("Operation should succeed"));
3732 NitsAssert(moreResults==MI_FALSE, PAL_T("Should be no more results"));
3733
3734 MI_Operation_Close(&operation);
3735 }
3736 NitsEndTest
3737
3738 /*==========================================================================================*/
3739 krisbash 1.1 /*==================================== Enumerate Classes ===================================*/
3740 /*==========================================================================================*/
3741
3742 NitsTest2(MI_Session_EnumerateClasses_Sync,
3743 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
3744 SetupDefaultSession, SetupDefaultSessionDefaults)
3745 {
3746 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
3747 ResetRuntimeTestData(testData);
3748 MI_Session *session = &testData->session;
3749 MI_Operation operation = MI_OPERATION_NULL;
3750
3751 const MI_Class *resultClass;
3752 MI_Boolean moreResults = MI_TRUE;
3753 MI_Result result;
3754 const MI_Char *errorMessage;
3755 const MI_Instance *completionDetails;
3756 unsigned int resultCount = 0;
3757
3758 MI_Session_EnumerateClasses(session, 0, NULL, PAL_T("namespace"), PAL_T("testClass"), MI_FALSE, NULL, &operation);
3759 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
3760 krisbash 1.1
3761 while (moreResults && (++resultCount <= 10))
3762 {
3763 MI_Operation_GetClass(&operation, &resultClass, &moreResults, &result, &errorMessage, &completionDetails);
3764 NitsCompare(result, MI_RESULT_OK, PAL_T("Operation should succeed"));
3765 }
3766 NitsCompare(resultCount, 10, PAL_T("Should have 10 results"));
3767 MI_Operation_Close(&operation);
3768 }
3769 NitsEndTest
3770
3771 NitsTest2(MI_Session_EnumerateClasses_Sync_WithOptions,
3772 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
3773 SetupDefaultSession, SetupDefaultSessionDefaults)
3774 {
3775 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
3776 ResetRuntimeTestData(testData);
3777 MI_Application *application = &testData->application;
3778 MI_Session *session = &testData->session;
3779 MI_Operation operation = MI_OPERATION_NULL;
3780 MI_OperationOptions options = MI_OPERATIONOPTIONS_NULL;
3781 krisbash 1.1
3782 if (NitsCompare(MI_Application_NewOperationOptions(application, MI_FALSE, &options), MI_RESULT_OK, PAL_T("NewOperationOptions should succeed")))
3783 {
3784 NitsCompare(options.ft->SetString(&options, PAL_T("option1"), PAL_T("value1"), 0), MI_RESULT_OK, PAL_T("SetString should work"));
3785 NitsCompare(options.ft->SetNumber(&options, PAL_T("option2"), 22, 0), MI_RESULT_OK, PAL_T("SetNumber should work"));
3786 {
3787 MI_Value value;
3788 value.string = (MI_Char*)PAL_T("hello world");
3789 NitsCompare(options.ft->SetCustomOption(&options, PAL_T("option3"), MI_STRING, &value, MI_FALSE, 0), MI_RESULT_OK, PAL_T("SetCustomString should work"));
3790 }
3791
3792 const MI_Class *resultClass;
3793 MI_Boolean moreResults = MI_TRUE;
3794 MI_Result result;
3795 const MI_Char *errorMessage;
3796 const MI_Instance *completionDetails;
3797 unsigned int resultCount = 0;
3798
3799 MI_Session_EnumerateClasses(session, 0, &options, PAL_T("namespace"), PAL_T("testClass"), MI_FALSE, NULL, &operation);
3800 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
3801
3802 krisbash 1.1 while (moreResults && (++resultCount <= 10))
3803 {
3804 MI_Operation_GetClass(&operation, &resultClass, &moreResults, &result, &errorMessage, &completionDetails);
3805 NitsCompare(result, MI_RESULT_OK, PAL_T("Operation should succeed"));
3806 }
3807 NitsCompare(resultCount, 10, PAL_T("Should have 10 results"));
3808 MI_Operation_Close(&operation);
3809
3810 MI_OperationOptions_Delete(&options);
3811 }
3812 }
3813 NitsEndTest
3814
3815 #if 0
3816 NitsTest(MI_Session_EnumerateClasses_Sync_InvalidParameters)
3817 {
3818 MI_Application application = MI_APPLICATION_NULL;
3819 MI_Session session = MI_SESSION_NULL;
3820 MI_Operation operation = MI_OPERATION_NULL;
3821
3822 if (NitsCompare(MI_Application_Initialize(0, NULL, NULL, &application), MI_RESULT_OK, PAL_T("MI_Application_Initialize returns OK")) &&
3823 krisbash 1.1 NitsAssert(application.ft != NULL, PAL_T("MI_Application function table should not be NULL")))
3824 {
3825 if (NitsCompare(MI_Application_NewSession(&application, PAL_T("Test1"), NULL, NULL, NULL, NULL, &session), MI_RESULT_OK, PAL_T("MI_Application_NewSession returns OK")) &&
3826 NitsAssert(session.ft != NULL, PAL_T("MI_Session function table should not be NULL")))
3827 {
3828 const MI_Class *resultClass;
3829 MI_Boolean moreResults = MI_TRUE;
3830 MI_Result result = MI_RESULT_FAILED;
3831 const MI_Char *errorMessage;
3832 const MI_Instance *completionDetails;
3833 unsigned int resultCount = 0;
3834
3835 {/* success */
3836 MI_Session_EnumerateClasses(&session, 0, NULL, PAL_T("namespace"), PAL_T("testClass"), MI_FALSE, NULL, &operation);
3837 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
3838
3839 while (moreResults && (++resultCount <= 10))
3840 {
3841 MI_Operation_GetClass(&operation, &resultClass, &moreResults, &result, &errorMessage, &completionDetails);
3842 NitsCompare(result, MI_RESULT_OK, PAL_T("Operation should succeed"));
3843 }
3844 krisbash 1.1 NitsCompare(resultCount, 10, PAL_T("Should have 10 results"));
3845 MI_Operation_Close(&operation);
3846 }
3847 {/* no class */
3848 MI_Session_EnumerateClasses(&session, 0, NULL, PAL_T("namespace"), NULL, MI_FALSE, NULL, &operation);
3849 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
3850 resultCount = 0;
3851 moreResults = MI_TRUE;
3852 while (moreResults && (++resultCount <= 10))
3853 {
3854 MI_Operation_GetClass(&operation, &resultClass, &moreResults, &result, &errorMessage, &completionDetails);
3855 NitsCompare(result, MI_RESULT_OK, PAL_T("Operation should succeed"));
3856 }
3857 NitsCompare(result, MI_RESULT_OK, PAL_T("Operation should succeed"));
3858 MI_Operation_Close(&operation);
3859 }
3860 {/* no opertion */
3861 #if defined (_MSC_VER)
3862 #pragma prefast(push)
3863 #pragma prefast(disable: 6309)
3864 #endif
3865 krisbash 1.1 MI_Session_EnumerateClasses(&session, 0, NULL, PAL_T("namespace"), PAL_T("testClass"), MI_FALSE, NULL, NULL);
3866 #if defined (_MSC_VER)
3867 #pragma prefast(pop)
3868 #endif
3869 /* nothing more we can do as no where for result to go */
3870 }
3871
3872 MI_Session_Close(&session, NULL, NULL);
3873 }
3874
3875 MI_Application_Close(&application);
3876 }
3877 }
3878 NitsEndTest
3879 #endif
3880
3881 NitsTest2(MI_Session_EnumerateClasses_Sync_TransportNotSupported,
3882 SetupDefaultApplication, g_RuntimeApplicationSetup_Test2,
3883 SetupDefaultSession, SetupDefaultSessionDefaults)
3884 {
3885 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
3886 krisbash 1.1 ResetRuntimeTestData(testData);
3887 MI_Session *session = &testData->session;
3888 MI_Operation operation = MI_OPERATION_NULL;
3889
3890 const MI_Class *resultClass;
3891 MI_Boolean moreResults = MI_TRUE;
3892 MI_Result result;
3893 const MI_Char *errorMessage;
3894 const MI_Instance *completionDetails;
3895
3896 MI_Session_EnumerateClasses(session, 0, NULL, PAL_T("namespace"), PAL_T("testClass"), MI_FALSE, NULL, &operation);
3897 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
3898
3899 MI_Operation_GetClass(&operation, &resultClass, &moreResults, &result, &errorMessage, &completionDetails);
3900 NitsCompare(result, MI_RESULT_NOT_SUPPORTED, PAL_T("Operation should fail with not supported"));
3901 MI_Operation_Close(&operation);
3902
3903 }
3904 NitsEndTest
3905
3906 NitsTest2(MI_Session_EnumerateClasses_Async_AutoAck,
3907 krisbash 1.1 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
3908 SetupDefaultSession, SetupDefaultSessionDefaults)
3909 {
3910 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
3911 ResetRuntimeTestData(testData);
3912 MI_Session *session = &testData->session;
3913 MI_Operation operation = MI_OPERATION_NULL;
3914 MI_OperationCallbacks callbacks = MI_OPERATIONCALLBACKS_NULL;
3915
3916 g_maximumInstanceCount = 10;
3917 callbacks.callbackContext = testData;
3918 callbacks.classResult = GetClassResult;
3919
3920 MI_Session_EnumerateClasses(session, 0, NULL, PAL_T("namespace"), PAL_T("testClass"), MI_FALSE, &callbacks, &operation);
3921 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
3922
3923 WaitForOperationToComplete(testData);
3924
3925 NitsCompare((MI_Uint32)testData->classCount, (MI_Uint32)g_maximumInstanceCount, PAL_T("Number of results callbacks received"));
3926 }
3927 NitsEndTest
3928 krisbash 1.1
3929 /*==========================================================================================*/
3930 /*=================================== Subscribe Instances ==================================*/
3931 /*==========================================================================================*/
3932
3933 NitsTest2(MI_Session_Subscribe_Sync,
3934 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
3935 SetupDefaultSession, SetupDefaultSessionDefaults)
3936 {
3937 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
3938 ResetRuntimeTestData(testData);
3939 MI_Session *session = &testData->session;
3940 MI_Operation operation = MI_OPERATION_NULL;
3941
3942 const MI_Instance *resultInstance;
3943 const MI_Char *bookmark;
3944 const MI_Char *machineID;
3945 MI_Boolean moreResults = MI_TRUE;
3946 MI_Result result;
3947 const MI_Char *errorMessage;
3948 const MI_Instance *completionDetails;
3949 krisbash 1.1 unsigned int resultCount = 0;
3950
3951 MI_Session_Subscribe(session, 0, NULL, PAL_T("namespace"), PAL_T("dialect"), PAL_T("filter"), NULL, NULL, &operation);
3952 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
3953
3954 while (moreResults && (++resultCount <= 10))
3955 {
3956 MI_Operation_GetIndication(&operation, &resultInstance, &bookmark, &machineID, &moreResults, &result, &errorMessage, &completionDetails);
3957 NitsCompare(result, MI_RESULT_OK, PAL_T("Operation should succeed"));
3958 }
3959 NitsCompare(resultCount, 10, PAL_T("Should have 10 results"));
3960 MI_Operation_Close(&operation);
3961 }
3962 NitsEndTest
3963
3964 NitsTest2(MI_Session_Subscribe_Sync_WithOptions,
3965 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
3966 SetupDefaultSession, SetupDefaultSessionDefaults)
3967 {
3968 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
3969 ResetRuntimeTestData(testData);
3970 krisbash 1.1 MI_Application *application = &testData->application;
3971 MI_Session *session = &testData->session;
3972 MI_Operation operation = MI_OPERATION_NULL;
3973
3974 MI_OperationOptions options = MI_OPERATIONOPTIONS_NULL;
3975 if (NitsCompare(MI_Application_NewOperationOptions(application, MI_FALSE, &options), MI_RESULT_OK, PAL_T("NewOperationOptions should succeed")))
3976 {
3977 const MI_Instance *resultInstance;
3978 const MI_Char *bookmark;
3979 const MI_Char *machineID;
3980 MI_Boolean moreResults = MI_TRUE;
3981 MI_Result result;
3982 const MI_Char *errorMessage;
3983 const MI_Instance *completionDetails;
3984 unsigned int resultCount = 0;
3985
3986 NitsCompare(options.ft->SetString(&options, PAL_T("option1"), PAL_T("value1"), 0), MI_RESULT_OK, PAL_T("SetString should work"));
3987 NitsCompare(options.ft->SetNumber(&options, PAL_T("option2"), 22, 0), MI_RESULT_OK, PAL_T("SetNumber should work"));
3988 {
3989 MI_Value value;
3990 value.string = (MI_Char*) PAL_T("hello world");
3991 krisbash 1.1 NitsCompare(options.ft->SetCustomOption(&options, PAL_T("option3"), MI_STRING, &value, MI_FALSE, 0), MI_RESULT_OK, PAL_T("SetCustomString should work"));
3992 }
3993
3994 MI_Session_Subscribe(session, 0, &options, PAL_T("namespace"), PAL_T("dialect"), PAL_T("filter"), NULL, NULL, &operation);
3995 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
3996
3997 while (moreResults && (++resultCount <= 10))
3998 {
3999 MI_Operation_GetIndication(&operation, &resultInstance, &bookmark, &machineID, &moreResults, &result, &errorMessage, &completionDetails);
4000 NitsCompare(result, MI_RESULT_OK, PAL_T("Operation should succeed"));
4001 }
4002 NitsCompare(resultCount, 10, PAL_T("Should have 10 results"));
4003 MI_Operation_Close(&operation);
4004
4005 MI_OperationOptions_Delete(&options);
4006 }
4007 }
4008 NitsEndTest
4009
4010 #if 0
4011 NitsTest(MI_Session_Subscribe_Sync_WithDeliveryOptions)
4012 krisbash 1.1 {
4013 MI_Application application = MI_APPLICATION_NULL;
4014 MI_Session session = MI_SESSION_NULL;
4015 MI_Operation operation = MI_OPERATION_NULL;
4016
4017 if (NitsCompare(MI_Application_Initialize(0, NULL, NULL, &application), MI_RESULT_OK, PAL_T("MI_Application_Initialize returns OK")) &&
4018 NitsAssert(application.ft != NULL, PAL_T("MI_Application function table should not be NULL")))
4019 {
4020 MI_SubscriptionDeliveryOptions options = MI_SUBSCRIPTIONDELIVERYOPTIONS_NULL;
4021 if (NitsCompare(MI_Application_NewSubscriptionDeliveryOptions(&application, MI_SubscriptionDeliveryType_Push, &options), MI_RESULT_OK, PAL_T("NewSubscribeDeliveryOptions should succeed")))
4022 {
4023 NitsCompare(options.ft->SetString(&options, PAL_T("option1"), PAL_T("value1"), 0), MI_RESULT_OK, PAL_T("SetString should work"));
4024 NitsCompare(options.ft->SetNumber(&options, PAL_T("option2"), 22, 0), MI_RESULT_OK, PAL_T("SetNumber should work"));
4025 {
4026 MI_Datetime datetime;
4027 NitsCompare(options.ft->SetDateTime(&options, PAL_T("option3"), &datetime, 0), MI_RESULT_OK, PAL_T("SetDateTime should work"));
4028 }
4029 {
4030 MI_Interval interval;
4031 NitsCompare(options.ft->SetInterval(&options, PAL_T("option4"), &interval, 0), MI_RESULT_OK, PAL_T("SetInterval should work"));
4032 }
4033 krisbash 1.1 {
4034 MI_UserCredentials creds = { 0 };
4035 creds.authenticationType = MI_AUTH_TYPE_BASIC;
4036 creds.credentials.usernamePassword.username = PAL_T("username");
4037 creds.credentials.usernamePassword.domain = PAL_T("domain");
4038 creds.credentials.usernamePassword.password = PAL_T("password");
4039 NitsCompare(options.ft->AddCredentials(&options, PAL_T("option5"), &creds, 0), MI_RESULT_OK, PAL_T("AddCredentials should work"));
4040 }
4041
4042 if (NitsCompare(MI_Application_NewSession(&application, PAL_T("Test1"), NULL, NULL, NULL, NULL, &session), MI_RESULT_OK, PAL_T("MI_Application_NewSession returns OK")) &&
4043 NitsAssert(session.ft != NULL, PAL_T("MI_Session function table should not be NULL")))
4044 {
4045 const MI_Instance *resultInstance;
4046 const MI_Char *bookmark;
4047 const MI_Char *machineID;
4048 MI_Boolean moreResults = MI_TRUE;
4049 MI_Result result;
4050 const MI_Char *errorMessage;
4051 const MI_Instance *completionDetails;
4052 unsigned int resultCount = 0;
4053
4054 krisbash 1.1 MI_Session_Subscribe(&session, 0, NULL, PAL_T("namespace"), PAL_T("dialect"), PAL_T("filter"), &options, NULL, &operation);
4055 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
4056
4057 while (moreResults && (++resultCount <= 10))
4058 {
4059 MI_Operation_GetIndication(&operation, &resultInstance, &bookmark, &machineID, &moreResults, &result, &errorMessage, &completionDetails);
4060 NitsCompare(result, MI_RESULT_OK, PAL_T("Operation should succeed"));
4061 }
4062 NitsCompare(resultCount, 10, PAL_T("Should have 10 results"));
4063 MI_Operation_Close(&operation);
4064
4065 MI_Session_Close(&session, NULL, NULL);
4066 }
4067 MI_SubscriptionDeliveryOptions_Delete(&options);
4068 }
4069 MI_Application_Close(&application);
4070 }
4071 }
4072 NitsEndTest
4073
4074 NitsTest(MI_Session_Subscribe_Sync_InvalidParameters)
4075 krisbash 1.1 {
4076 MI_Application application = MI_APPLICATION_NULL;
4077 MI_Session session = MI_SESSION_NULL;
4078 MI_Operation operation = MI_OPERATION_NULL;
4079
4080 if (NitsCompare(MI_Application_Initialize(0, NULL, NULL, &application), MI_RESULT_OK, PAL_T("MI_Application_Initialize returns OK")) &&
4081 NitsAssert(application.ft != NULL, PAL_T("MI_Application function table should not be NULL")))
4082 {
4083 if (NitsCompare(MI_Application_NewSession(&application, PAL_T("Test1"), NULL, NULL, NULL, NULL, &session), MI_RESULT_OK, PAL_T("MI_Application_NewSession returns OK")) &&
4084 NitsAssert(session.ft != NULL, PAL_T("MI_Session function table should not be NULL")))
4085 {
4086 const MI_Instance *resultInstance;
4087 const MI_Char *bookmark;
4088 const MI_Char *machineID;
4089 MI_Boolean moreResults = MI_TRUE;
4090 MI_Result result;
4091 MI_Result returnValue;
4092 const MI_Char *errorMessage;
4093 const MI_Instance *completionDetails;
4094 unsigned int resultCount = 0;
4095
4096 krisbash 1.1 {/* success */
4097 MI_Session_Subscribe(&session, 0, NULL, PAL_T("namespace"), PAL_T("dialect"), PAL_T("filter"), NULL, NULL, &operation);
4098 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
4099
4100 while (moreResults && (++resultCount <= 10))
4101 {
4102 MI_Operation_GetIndication(&operation, &resultInstance, &bookmark, &machineID, &moreResults, &result, &errorMessage, &completionDetails);
4103 NitsCompare(result, MI_RESULT_OK, PAL_T("Operation should succeed"));
4104 }
4105 NitsCompare(resultCount, 10, PAL_T("Should have 10 results"));
4106 NitsCompare(moreResults, MI_FALSE, PAL_T("Need no more results for operation close to work properly"));
4107
4108 #if defined (_MSC_VER)
4109 #pragma prefast(push)
4110 #pragma prefast(disable: 6309)
4111 #endif
4112 returnValue = MI_Operation_GetIndication(NULL, &resultInstance, &bookmark, &machineID, &moreResults, &result, &errorMessage, &completionDetails);
4113 NitsCompare(returnValue, MI_RESULT_INVALID_PARAMETER, PAL_T("Should get invalid parameter"));
4114 returnValue = MI_Operation_GetIndication(&operation, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
4115 NitsCompare(returnValue, MI_RESULT_INVALID_PARAMETER, PAL_T("Should get invalid parameter"));
4116 #if defined (_MSC_VER)
4117 krisbash 1.1 #pragma prefast(pop)
4118 #endif
4119
4120 MI_Operation_Close(&operation);
4121 }
4122 {/* no filter */
4123 MI_Session_Subscribe(&session, 0, NULL, PAL_T("namespace"), PAL_T("dialect"), NULL, NULL, NULL, &operation);
4124
4125 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
4126
4127 MI_Operation_GetIndication(&operation, &resultInstance, &bookmark, &machineID, &moreResults, &result, &errorMessage, &completionDetails);
4128 NitsCompare(result, MI_RESULT_OK, PAL_T("Operation should succeed"));
4129 if (moreResults)
4130 {
4131 MI_Operation_Cancel(&operation, MI_REASON_NONE);
4132 while (moreResults)
4133 {
4134 MI_Operation_GetIndication(&operation, &resultInstance, &bookmark, &machineID, &moreResults, &result, &errorMessage, &completionDetails);
4135 }
4136 }
4137 MI_Operation_Close(&operation);
4138 krisbash 1.1 }
4139 {/* no opertion */
4140 #if defined (_MSC_VER)
4141 #pragma prefast(push)
4142 #pragma prefast(disable: 6309)
4143 #endif
4144 MI_Session_Subscribe(&session, 0, NULL, PAL_T("namespace"), PAL_T("dialect"), PAL_T("filter"), NULL, NULL, NULL);
4145 #if defined (_MSC_VER)
4146 #pragma prefast(pop)
4147 #endif
4148 /* nothing more we can do as no where for result to go */
4149 }
4150 {
4151 MI_SubscriptionDeliveryOptions options = MI_SUBSCRIPTIONDELIVERYOPTIONS_NULL;
4152 if (NitsCompare(MI_Application_NewSubscriptionDeliveryOptions(&application, MI_SubscriptionDeliveryType_Push, &options), MI_RESULT_OK, PAL_T("NewSubscribeDeliveryOptions should succeed")))
4153 {
4154 {
4155 MI_Datetime datetime;
4156 NitsCompare(options.ft->SetDateTime(NULL, PAL_T("option3"), &datetime, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("SetDateTime should fail"));
4157 NitsCompare(options.ft->SetDateTime(&options, NULL, &datetime, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("SetDateTime should fail"));
4158 NitsCompare(options.ft->SetDateTime(&options, PAL_T("option3"), NULL, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("SetDateTime should fail"));
4159 krisbash 1.1 NitsCompare(options.ft->SetDateTime(&options, PAL_T("option3"), &datetime, 42), MI_RESULT_INVALID_PARAMETER, PAL_T("SetDateTime should fail"));
4160 }
4161 {
4162 MI_Interval interval;
4163 NitsCompare(options.ft->SetInterval(NULL, PAL_T("option4"), &interval, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("SetInterval should fail"));
4164 NitsCompare(options.ft->SetInterval(&options, NULL, &interval, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("SetInterval should fail"));
4165 NitsCompare(options.ft->SetInterval(&options, PAL_T("option4"), NULL, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("SetInterval should fail"));
4166 NitsCompare(options.ft->SetInterval(&options, PAL_T("option4"), &interval, 32), MI_RESULT_INVALID_PARAMETER, PAL_T("SetInterval should fail"));
4167 }
4168 MI_SubscriptionDeliveryOptions_Delete(&options);
4169 }
4170 }
4171 MI_Session_Close(&session, NULL, NULL);
4172 }
4173
4174 MI_Application_Close(&application);
4175 }
4176 }
4177 NitsEndTest
4178 #endif
4179
4180 krisbash 1.1 NitsTest2(MI_Session_Subscribe_Sync_TransportNotSupported,
4181 SetupDefaultApplication, g_RuntimeApplicationSetup_Test2,
4182 SetupDefaultSession, SetupDefaultSessionDefaults)
4183 {
4184 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
4185 ResetRuntimeTestData(testData);
4186 MI_Session *session = &testData->session;
4187 MI_Operation operation = MI_OPERATION_NULL;
4188
4189 const MI_Instance *resultInstance;
4190 const MI_Char *bookmark;
4191 const MI_Char *machineID;
4192 MI_Boolean moreResults = MI_TRUE;
4193 MI_Result result;
4194 const MI_Char *errorMessage;
4195 const MI_Instance *completionDetails;
4196
4197 MI_Session_Subscribe(session, 0, NULL, PAL_T("namespace"), PAL_T("dialect"), PAL_T("filter"), NULL, NULL, &operation);
4198 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
4199
4200 MI_Operation_GetIndication(&operation, &resultInstance, &bookmark, &machineID, &moreResults, &result, &errorMessage, &completionDetails);
4201 krisbash 1.1 NitsCompare(result, MI_RESULT_NOT_SUPPORTED, PAL_T("Operation should fail with not supported"));
4202 MI_Operation_Close(&operation);
4203 }
4204 NitsEndTest
4205
4206 NitsTest2(MI_Session_Subscribe_Async_AutoAck,
4207 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
4208 SetupDefaultSession, SetupDefaultSessionDefaults)
4209 {
4210 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
4211 ResetRuntimeTestData(testData);
4212 MI_Session *session = &testData->session;
4213 MI_Operation operation = MI_OPERATION_NULL;
4214 MI_OperationCallbacks callbacks = MI_OPERATIONCALLBACKS_NULL;
4215
4216 g_maximumInstanceCount = 10;
4217 callbacks.callbackContext = testData;
4218 callbacks.indicationResult = GetIndicationResult;
4219
4220 MI_Session_Subscribe(session, 0, NULL, PAL_T("namespace"), PAL_T("dialect"), PAL_T("filter"), NULL, &callbacks, &operation);
4221 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
4222 krisbash 1.1
4223 WaitForOperationToComplete(testData);
4224
4225 NitsCompare((MI_Uint32)testData->indicationCount, (MI_Uint32)g_maximumInstanceCount, PAL_T("Number of results callbacks received"));
4226 }
4227 NitsEndTest
4228
4229 #if 0
4230 extern "C" void ValidateCondition(MI_CallbackMode writeErrorMode, MI_CallbackMode promptUserMode,
4231 MI_OperationCallback_ResponseType writeErrorResponse, MI_OperationCallback_ResponseType promptUserResponse)
4232 {
4233 NitsAssert(g_PSSemanticsProgressObject.WriteErrorCalled== 2, PAL_T(" WriteError not called"));
4234 if( writeErrorMode == MI_CALLBACKMODE_INQUIRE )
4235 {
4236 if(writeErrorResponse == MI_OperationCallback_ResponseType_YesToAll)
4237 {
4238 NitsCompare(g_PSSemanticsProgressObject.writeErrorCallback, 1, PAL_T(" writeErrorCallback is not 1"));
4239 }
4240 else
4241 {
4242 NitsAssert(g_PSSemanticsProgressObject.writeErrorCallback == 2, PAL_T(" writeErrorCallback is not 2"));
4243 krisbash 1.1 }
4244 }
4245 else
4246 {
4247 NitsAssert(g_PSSemanticsProgressObject.writeErrorCallback == 0, PAL_T(" writeErrorCallback is not 0"));
4248 }
4249
4250 if( promptUserMode == MI_CALLBACKMODE_INQUIRE)
4251 {
4252 NitsAssert(g_PSSemanticsProgressObject.PromptUserCalled== 2, PAL_T(" PromptUser not called twice"));
4253 }
4254 else if( promptUserMode == MI_CALLBACKMODE_REPORT)
4255 {
4256 NitsAssert(g_PSSemanticsProgressObject.PromptUserCalled== 2, PAL_T(" PromptUser not called twice"));
4257
4258 }
4259 else
4260 {
4261 NitsAssert(g_PSSemanticsProgressObject.PromptUserCalled== 1, PAL_T(" PromptUser not called once"));
4262 }
4263 }
4264 krisbash 1.1 extern "C" void Helper_MI_Session_Invoke_Async_PSSemantics_Part2(
4265 MI_OperationCallback_ResponseType writeErrorResponse = MI_OperationCallback_ResponseType_Yes,
4266 MI_OperationCallback_ResponseType promptUserResponse = MI_OperationCallback_ResponseType_Yes,
4267 MI_CallbackMode writeErrorMode = MI_CALLBACKMODE_REPORT,
4268 MI_CallbackMode promptUserMode = MI_CALLBACKMODE_INQUIRE)
4269 {
4270 MI_Application application = MI_APPLICATION_NULL;
4271 MI_Session session = MI_SESSION_NULL;
4272 MI_Operation operation = MI_OPERATION_NULL;
4273 MI_OperationCallbacks callbacks = MI_OPERATIONCALLBACKS_NULL;
4274 MI_OperationOptions options = MI_OPERATIONOPTIONS_NULL;
4275 g_WriteErrorResponseType = writeErrorResponse;
4276 g_PromptUserResponseType = promptUserResponse;
4277
4278 memset(&g_PSSemanticsProgressObject, 0 , sizeof(PSSemanticsProgressResult));
4279
4280 callbacks.instanceResult = GetInstanceResult;
4281 callbacks.promptUser = MI_Session_GetInstance_Async_PS_Semantics_PromptUser;
4282 callbacks.writeError = MI_Session_GetInstance_Async_PS_Semantics_WriteError;
4283 callbacks.writeMessage = MI_Session_GetInstance_Async_PS_Semantics_WriteMessage;
4284 callbacks.writeProgress = MI_Session_GetInstance_Async_PS_Semantics_WriteProgress;
4285 krisbash 1.1
4286 if (NitsCompare(MI_Application_Initialize(0, NULL, NULL, &application), MI_RESULT_OK, PAL_T("MI_Application_Initialize returns OK")) &&
4287 NitsAssert(application.ft != NULL, PAL_T("MI_Application function table should not be NULL")))
4288 {
4289 if (NitsCompare(MI_Application_NewOperationOptions(&application, MI_FALSE, &options), MI_RESULT_OK, PAL_T("NewOperationOptions should succeed")))
4290 {
4291 NitsAssert( MI_OperationOptions_SetWriteErrorMode(&options, writeErrorMode) == MI_RESULT_OK, PAL_T("Unable to ser Write Error mode"));
4292 NitsAssert( MI_OperationOptions_SetPromptUserMode(&options, promptUserMode) == MI_RESULT_OK, PAL_T("Unable to ser Prompt User mode"));
4293 if (NitsCompare(MI_Application_NewSession(&application, PAL_T("Test1"), NULL, NULL, NULL, NULL, &session), MI_RESULT_OK, PAL_T("MI_Application_NewSession returns OK")) &&
4294 NitsAssert(session.ft != NULL, PAL_T("MI_Session function table should not be NULL")))
4295 {
4296 MI_Session_Invoke(&session, 0, &options, NULL, PAL_T("testClass"), PAL_T("TestMethod"), NULL, NULL, &callbacks, &operation);
4297 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
4298
4299 MI_Session_Close(&session, NULL, NULL);
4300 //Validate the condition
4301 ValidateCondition(writeErrorMode, promptUserMode, writeErrorResponse, promptUserResponse);
4302 }
4303 MI_OperationOptions_Delete(&options);
4304 }
4305
4306 krisbash 1.1 MI_Application_Close(&application);
4307 }
4308 }
4309
4310 NitsTest(MI_Session_Invoke_Async_PSSemantics_Part2)
4311 {
4312 NitsTrace(PAL_T("Executing operation 1"));
4313 Helper_MI_Session_Invoke_Async_PSSemantics_Part2();
4314 NitsTrace(PAL_T("Executing operation 2"));
4315 Helper_MI_Session_Invoke_Async_PSSemantics_Part2(MI_OperationCallback_ResponseType_YesToAll, MI_OperationCallback_ResponseType_YesToAll);
4316 NitsTrace(PAL_T("Executing operation 3"));
4317 Helper_MI_Session_Invoke_Async_PSSemantics_Part2(MI_OperationCallback_ResponseType_YesToAll, MI_OperationCallback_ResponseType_YesToAll, MI_CALLBACKMODE_INQUIRE,
4318 MI_CALLBACKMODE_REPORT);
4319 NitsTrace(PAL_T("Executing operation 4"));
4320 Helper_MI_Session_Invoke_Async_PSSemantics_Part2(MI_OperationCallback_ResponseType_YesToAll, MI_OperationCallback_ResponseType_YesToAll, MI_CALLBACKMODE_REPORT,
4321 MI_CALLBACKMODE_REPORT);
4322 NitsTrace(PAL_T("Executing operation 5"));
4323 Helper_MI_Session_Invoke_Async_PSSemantics_Part2(MI_OperationCallback_ResponseType_YesToAll, MI_OperationCallback_ResponseType_YesToAll, MI_CALLBACKMODE_REPORT,
4324 MI_CALLBACKMODE_IGNORE);
4325 }
4326 NitsEndTest
4327 krisbash 1.1 #endif
4328 /*==========================================================================================*/
4329 /*===================================== TestConnection =====================================*/
4330 /*==========================================================================================*/
4331
4332 NitsTest2(MI_Session_TestConnection_Sync,
4333 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
4334 SetupDefaultSession, SetupDefaultSessionDefaults)
4335 {
4336 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
4337 ResetRuntimeTestData(testData);
4338 MI_Session *session = &testData->session;
4339 MI_Operation operation = MI_OPERATION_NULL;
4340
4341 MI_Boolean moreResults;
4342 MI_Result result;
4343 const MI_Char *errorMessage;
4344 const MI_Instance *completionDetails;
4345 const MI_Instance *resultInstance;
4346
4347 MI_Session_TestConnection(session, 0, NULL, &operation);
4348 krisbash 1.1 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
4349
4350 MI_Operation_GetInstance(&operation, &resultInstance, &moreResults, &result, &errorMessage, &completionDetails);
4351 NitsCompare(result, MI_RESULT_OK, PAL_T("Operation should succeed"));
4352 NitsAssert(moreResults==MI_FALSE, PAL_T("Should be no more results"));
4353
4354 MI_Operation_Close(&operation);
4355 }
4356 NitsEndTest
4357
4358 NitsTest2(MI_Session_TestConnection_Async_AutoAck,
4359 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
4360 SetupDefaultSession, SetupDefaultSessionDefaults)
4361 {
4362 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
4363 ResetRuntimeTestData(testData);
4364 MI_Session *session = &testData->session;
4365 MI_Operation operation = MI_OPERATION_NULL;
4366 MI_OperationCallbacks callbacks = MI_OPERATIONCALLBACKS_NULL;
4367
4368 g_maximumInstanceCount = 0;
4369 krisbash 1.1 callbacks.callbackContext = testData;
4370 callbacks.instanceResult = GetInstanceResult;
4371
4372 MI_Session_TestConnection(session, 0, &callbacks, &operation);
4373 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
4374
4375 WaitForOperationToComplete(testData);
4376
4377 NitsCompare((MI_Uint32)testData->instanceCount, (MI_Uint32)g_maximumInstanceCount, PAL_T("Number of results callbacks received"));
4378 }
4379 NitsEndTest
4380
4381 NitsTest2(MI_Session_TestConnection_Async_ManualAck,
4382 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1,
4383 SetupDefaultSession, SetupDefaultSessionDefaults)
4384 {
4385 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
4386 ResetRuntimeTestData(testData);
4387 MI_Session *session = &testData->session;
4388 MI_Operation operation = MI_OPERATION_NULL;
4389 MI_OperationCallbacks callbacks = MI_OPERATIONCALLBACKS_NULL;
4390 krisbash 1.1
4391 g_maximumInstanceCount = 0;
4392 callbacks.callbackContext = testData;
4393 callbacks.instanceResult = GetInstanceResult;
4394
4395 MI_Session_TestConnection(session, MI_OPERATIONFLAGS_MANUAL_ACK_RESULTS, &callbacks, &operation);
4396 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
4397
4398 WaitForOperationToComplete(testData);
4399
4400 NitsCompare((MI_Uint32)testData->instanceCount, (MI_Uint32)g_maximumInstanceCount, PAL_T("Number of results callbacks received"));
4401 }
4402 NitsEndTest
4403
4404 #if 0
4405
4406 NitsTest(MI_Session_TestConnection_Sync_InvalidParameters)
4407 {
4408 MI_Application application = MI_APPLICATION_NULL;
4409 MI_Session session = MI_SESSION_NULL;
4410 MI_Operation operation = MI_OPERATION_NULL;
4411 krisbash 1.1 const MI_Instance *extendedInfo;
4412 MI_Boolean moreResults;
4413 MI_Result resultCode;
4414 MI_Result returnValue;
4415 const MI_Char *errorMessage;
4416 MI_OperationCallbacks callbacks = MI_OPERATIONCALLBACKS_NULL;
4417 callbacks.instanceResult = GetInstanceResult_Fail;
4418 const MI_Instance *resultInstance = NULL;
4419
4420 if (NitsCompare(MI_Application_Initialize(0, NULL, NULL, &application), MI_RESULT_OK, PAL_T("MI_Application_Initialize returns OK")) &&
4421 NitsAssert(application.ft != NULL, PAL_T("MI_Application function table should not be NULL")))
4422 {
4423 if (NitsCompare(MI_Application_NewSession(&application, PAL_T("Test1"), NULL, NULL, NULL, NULL, &session), MI_RESULT_OK, PAL_T("MI_Application_NewSession returns OK")) &&
4424 NitsAssert(session.ft != NULL, PAL_T("MI_Session function table should not be NULL")))
4425 {
4426 session.ft->TestConnection(&session, 0, NULL, &operation);
4427 MI_Operation_GetInstance(&operation, &resultInstance, &moreResults, &resultCode, &errorMessage, &extendedInfo);
4428 NitsCompare(resultCode, MI_RESULT_OK, PAL_T("GetInstance should succeed"));
4429
4430 returnValue = operation.ft->GetInstance(NULL, &resultInstance, NULL, &resultCode, NULL, NULL);
4431 NitsCompare(returnValue, MI_RESULT_INVALID_PARAMETER, PAL_T("Operation_GetClass should fail due to NULL operation"));
4432 krisbash 1.1
4433 returnValue = operation.ft->GetInstance(&operation, NULL, NULL, &resultCode, NULL, NULL);
4434 NitsCompare(returnValue, MI_RESULT_INVALID_PARAMETER, PAL_T("Operation_GetClass should fail due to NULL instance"));
4435
4436 MI_Operation_Close(&operation);
4437
4438 session.ft->TestConnection(NULL, 0, NULL, &operation);
4439 MI_Operation_GetInstance(&operation, &resultInstance, &moreResults, &resultCode, &errorMessage, &extendedInfo);
4440 NitsCompare(resultCode, MI_RESULT_INVALID_PARAMETER, PAL_T("GetClass should faul due to NULL session"));
4441 MI_Operation_Close(&operation);
4442
4443 session.ft->TestConnection(&session, 0, NULL, &operation);
4444 MI_Operation_GetInstance(&operation, NULL, &moreResults, &resultCode, &errorMessage, &extendedInfo);
4445 NitsCompare(resultCode, MI_RESULT_INVALID_PARAMETER, PAL_T("GetInstance should fail due to NULL instance key"));
4446 MI_Operation_GetInstance(&operation, &resultInstance, &moreResults, &resultCode, &errorMessage, &extendedInfo);
4447 NitsCompare(resultCode, MI_RESULT_OK, PAL_T("GetInstances hould succeed"));
4448 MI_Operation_Close(&operation);
4449
4450 session.ft->TestConnection(&session, 0, &callbacks, NULL);
4451 returnValue = MI_Operation_GetInstance(&operation, &resultInstance, &moreResults, &resultCode, &errorMessage, &extendedInfo);
4452 NitsCompare(returnValue, MI_RESULT_INVALID_PARAMETER, PAL_T("GetClass should fail due to closed operation"));
4453 krisbash 1.1 MI_Operation_Close(&operation);
4454
4455 session.ft->TestConnection(&session, 0, NULL, NULL);
4456 /* Validate it doesn't crash only as nowhere for failure to go */
4457 MI_Session_Close(&session, NULL, NULL);
4458
4459 session.ft->TestConnection(&session, 0, NULL, &operation);
4460 MI_Operation_GetInstance(&operation, &resultInstance, &moreResults, &resultCode, &errorMessage, &extendedInfo);
4461 NitsCompare(resultCode, MI_RESULT_INVALID_PARAMETER, PAL_T("GetClass should fail because session is already closed"));
4462 MI_Operation_Close(&operation);
4463
4464 }
4465 MI_Application_Close(&application);
4466 }
4467 }
4468 NitsEndTest
4469 #endif
4470
4471 NitsTest2(MI_Session_TestConnection_TransportNotSupported,
4472 SetupDefaultApplication, g_RuntimeApplicationSetup_Test2,
4473 SetupDefaultSession, SetupDefaultSessionDefaults)
4474 krisbash 1.1 {
4475 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
4476 ResetRuntimeTestData(testData);
4477 MI_Session *session = &testData->session;
4478 MI_Operation operation = MI_OPERATION_NULL;
4479
4480 const MI_Instance *resultInstance;
4481 MI_Boolean moreResults;
4482 MI_Result result;
4483 const MI_Char *errorMessage;
4484 const MI_Instance *completionDetails;
4485
4486 MI_Session_TestConnection(session, 0, NULL, &operation);
4487
4488 MI_Operation_GetInstance(&operation, &resultInstance, &moreResults, &result, &errorMessage, &completionDetails);
4489 NitsCompare(result, MI_RESULT_NOT_SUPPORTED, PAL_T("Operation should succeed"));
4490 NitsAssert(moreResults==MI_FALSE, PAL_T("Should be no more results"));
4491
4492 MI_Operation_Close(&operation);
4493 }
4494 NitsEndTest
4495 krisbash 1.1
4496 NitsTest(TestMapErrorToMiErrorCategory)
4497 {
4498 MI_ErrorCategory errorCategory;
4499
4500 #if defined(_MSC_VER)
4501 errorCategory = MI_Utilities_MapErrorToMiErrorCategory(MI_RESULT_TYPE_WIN32, ERROR_NOT_SUPPORTED);
4502 NitsAssert(errorCategory==MI_ERRORCATEGORY_INVALID_OPERATION, PAL_T("ErrorCategory is not MI_ERRORCATEGORY_INVALID_OPERATION"));
4503 #endif
4504
4505 errorCategory = MI_Utilities_MapErrorToMiErrorCategory(MI_RESULT_TYPE_MI, MI_RESULT_ACCESS_DENIED);
4506 NitsAssert(errorCategory==MI_ERRORCATEGORY_ACCESS_DENIED, PAL_T("ErrorCategory is not MI_ERRORCATEGORY_ACCESS_DENIED"));
4507 }
4508 NitsEndTest
4509
4510 NitsTest(TestCimErrorFromErrorCode)
4511 {
4512 MI_Value value;
4513 #if defined(_MSC_VER)
4514 MI_Instance *pInst = NULL;
4515 LANGID idLang = GetSystemDefaultLangID();
4516 krisbash 1.1
4517 if(NitsCompare(MI_Utilities_CimErrorFromErrorCode(ERROR_FILE_NOT_FOUND, MI_RESULT_TYPE_WIN32, NULL, &pInst), MI_RESULT_OK,PAL_T("Got an error")))
4518 {
4519 if(NitsCompare( MI_Instance_GetElement( pInst, PAL_T("MessageID"), &value, NULL, NULL, NULL) , MI_RESULT_OK, PAL_T("MessageID is not there")) )
4520 {
4521 NitsTrace((MI_String)value.string);
4522 NitsCompareString((MI_String)value.string, PAL_T("Windows System Error 2"), PAL_T("MessageID != Windows System Error 2"));
4523 }
4524 if(NitsCompare( MI_Instance_GetElement( pInst, PAL_T("Message"), &value, NULL, NULL, NULL) , MI_RESULT_OK, PAL_T("Message is not there")) )
4525 {
4526 NitsTrace((MI_String)value.string);
4527 //Process only for en-us
4528 if( idLang == 0x0409)
4529 {
4530 NitsCompareString((MI_String)value.string, PAL_T("The system cannot find the file specified. "), PAL_T("Message != The system cannot find the file specified."));
4531 }
4532 }
4533 if(NitsCompare( MI_Instance_GetElement( pInst, PAL_T("OMI_ErrorMessage"), &value, NULL, NULL, NULL) , MI_RESULT_OK, PAL_T("OMI_ErrorMessage is not there")) )
4534 {
4535 NitsTrace((MI_String)value.string);
4536 //Process only for en-us
4537 krisbash 1.1 if( idLang == 0x0409)
4538 {
4539 NitsCompareString((MI_String)value.string, PAL_T("The system cannot find the file specified. "), PAL_T("OMI_ErrorMessage != The system cannot find the file specified."));
4540 }
4541 }
4542 if(NitsCompare( MI_Instance_GetElement( pInst, PAL_T("OMI_Category"), &value, NULL, NULL, NULL) , MI_RESULT_OK, PAL_T("Error_Category is not there")) )
4543 {
4544 NitsCompare(value.uint16, MI_ERRORCATEGORY_OBJECT_NOT_FOUND,PAL_T("OMI_Category != MI_ERRORCATEGORY_OBJECT_NOT_FOUND"));
4545 }
4546 if(NitsCompare( MI_Instance_GetElement( pInst, PAL_T("OMI_Type"), &value, NULL, NULL, NULL) , MI_RESULT_OK, PAL_T("OMI_Type is not there")) )
4547 {
4548 NitsTrace((MI_String)value.string);
4549 NitsCompareString((MI_String)value.string, PAL_T("Win32"), PAL_T("error_Type != Win32"));
4550 }
4551 if(NitsCompare( MI_Instance_GetElement( pInst, PAL_T("OMI_Code"), &value, NULL, NULL, NULL) , MI_RESULT_OK, PAL_T("OMI_Code is not there")) )
4552 {
4553 NitsCompare(value.uint32, ERROR_FILE_NOT_FOUND, PAL_T("OMI_Code != ERROR_FILE_NOT_FOUND"));
4554 }
4555 if(NitsCompare( MI_Instance_GetElement( pInst, PAL_T("CIMStatusCode"), &value, NULL, NULL, NULL) , MI_RESULT_OK, PAL_T("ErrorType is not there")) )
4556 {
4557 NitsCompare(value.uint32, MI_RESULT_NOT_FOUND,PAL_T("CIMStatusCode != MI_RESULT_FAILED"));
4558 krisbash 1.1 }
4559 }
4560 MI_Instance_Delete(pInst);
4561 #endif
4562
4563 MI_Instance* pInst3 = NULL;
4564 if(NitsCompare(MI_Utilities_CimErrorFromErrorCode(MI_RESULT_INVALID_CLASS, MI_RESULT_TYPE_MI, PAL_T("Testing MI"), &pInst3), MI_RESULT_OK,PAL_T("Got an error")))
4565 {
4566 if(NitsCompare( MI_Instance_GetElement( pInst3, PAL_T("MessageID"), &value, NULL, NULL, NULL) , MI_RESULT_OK, PAL_T("MessageID is not there")) )
4567 {
4568 NitsTrace((MI_String)value.string);
4569 NitsCompareString((MI_String)value.string, PAL_T("OMI:MI_Result:5"), PAL_T("MessageID != MI RESULT 5"));
4570 }
4571 if(NitsCompare( MI_Instance_GetElement( pInst3, PAL_T("Message"), &value, NULL, NULL, NULL) , MI_RESULT_OK, PAL_T("Expect Message is there")) )
4572 {
4573 NitsTrace((MI_String)value.string);
4574 NitsCompareString((MI_String)value.string, PAL_T("Testing MI"), PAL_T("Message != Testing MI"));
4575 }
4576 if(NitsAssert( MI_Instance_GetElement( pInst3, PAL_T("OMI_ErrorMessage"), &value, NULL, NULL, NULL) == MI_RESULT_OK, PAL_T("Expect Message is there")) )
4577 {
4578 NitsTrace((MI_String)value.string);
4579 krisbash 1.1 //Process only for en-us
4580 #if defined(_MSC_VER)
4581 if( idLang == 0x0409)
4582 #endif
4583 {
4584 NitsCompareString((MI_String)value.string, PAL_T("The specified class does not exist."), PAL_T("OMI_ErrorMessage != The specified Class does not exist."));
4585 }
4586
4587 }
4588 if(NitsCompare( MI_Instance_GetElement( pInst3, PAL_T("OMI_Category"), &value, NULL, NULL, NULL) , MI_RESULT_OK, PAL_T("OMI_Category is not there")) )
4589 {
4590 NitsCompare(value.uint16, MI_ERRORCATEGORY_METADATA_ERROR,PAL_T("OMI_Category != MI_ERRORCATEGORY_METADATA_ERROR"));
4591 }
4592 if(NitsCompare( MI_Instance_GetElement( pInst3, PAL_T("OMI_Type"), &value, NULL, NULL, NULL) , MI_RESULT_OK, PAL_T("OMI_Type is not there")) )
4593 {
4594 NitsTrace((MI_String)value.string);
4595 NitsCompareString((MI_String)value.string, PAL_T("MI"), PAL_T("OMI_Type != MI"));
4596 }
4597 if(NitsCompare( MI_Instance_GetElement( pInst3, PAL_T("OMI_Code"), &value, NULL, NULL, NULL) , MI_RESULT_OK, PAL_T("OMI_Code is not there")) )
4598 {
4599 NitsCompare(value.uint32, MI_RESULT_INVALID_CLASS,PAL_T("OMI_Code != MI_RESULT_INVALID_CLASS"));
4600 krisbash 1.1 }
4601 if(NitsCompare( MI_Instance_GetElement( pInst3, PAL_T("CIMStatusCode"), &value, NULL, NULL, NULL) , MI_RESULT_OK, PAL_T("CIMStatusCode is not there")) )
4602 {
4603 NitsCompare(value.uint32, MI_RESULT_INVALID_CLASS,PAL_T("CIMStatusCode != MI_RESULT_INVALID_CLASS"));
4604 }
4605 }
4606 MI_Instance_Delete(pInst3);
4607
4608 MI_Instance* pInst4 = NULL;
4609 if(NitsCompare(MI_Utilities_CimErrorFromErrorCode(E2BIG, MI_RESULT_TYPE_ERRNO, PAL_T("Testing MI"), &pInst4), MI_RESULT_OK,PAL_T("Got an error")))
4610 {
4611 if(NitsCompare( MI_Instance_GetElement( pInst4, PAL_T("MessageID"), &value, NULL, NULL, NULL) , MI_RESULT_OK, PAL_T("MessageID is not there")) )
4612 {
4613 NitsTrace((MI_String)value.string);
4614 NitsCompareString((MI_String)value.string, PAL_T("CRT errno 7"), PAL_T("MessageID != MI RESULT 7"));
4615 }
4616 if(NitsCompare( MI_Instance_GetElement( pInst4, PAL_T("Message"), &value, NULL, NULL, NULL) , MI_RESULT_OK, PAL_T("Expect Message is there")) )
4617 {
4618 NitsTrace((MI_String)value.string);
4619 NitsCompareString((MI_String)value.string, PAL_T("Testing MI"), PAL_T("Message != Testing MI"));
4620 }
4621 krisbash 1.1 if(NitsAssert( MI_Instance_GetElement( pInst4, PAL_T("OMI_ErrorMessage"), &value, NULL, NULL, NULL) == MI_RESULT_OK, PAL_T("Expect Message is there")) )
4622 {
4623 NitsTrace((MI_String)value.string);
4624 //Process only for en-us
4625 #if defined(_MSC_VER)
4626 if( idLang == 0x0409)
4627 #endif
4628 {
4629 #if !defined(CONFIG_HAVE_STRERROR_R)
4630 NitsCompareString((MI_String)value.string, PAL_T("Argument list too long"), PAL_T("OMI_ErrorMessage != Argument list too long."));
4631 #endif
4632 }
4633
4634 }
4635 if(NitsCompare( MI_Instance_GetElement( pInst4, PAL_T("OMI_Category"), &value, NULL, NULL, NULL) , MI_RESULT_OK, PAL_T("OMI_Category is not there")) )
4636 {
4637 NitsCompare(value.uint16, MI_ERRORCATEGORY_NOT_SPECIFIED,PAL_T("OMI_Category != MI_ERRORCATEGORY_METADATA_ERROR"));
4638 }
4639 if(NitsCompare( MI_Instance_GetElement( pInst4, PAL_T("OMI_Type"), &value, NULL, NULL, NULL) , MI_RESULT_OK, PAL_T("OMI_Type is not there")) )
4640 {
4641 NitsTrace((MI_String)value.string);
4642 krisbash 1.1 NitsCompareString((MI_String)value.string, PAL_T("ERRNO"), PAL_T("OMI_Type != ERRNO"));
4643 }
4644 if(NitsCompare( MI_Instance_GetElement( pInst4, PAL_T("OMI_Code"), &value, NULL, NULL, NULL) , MI_RESULT_OK, PAL_T("OMI_Code is not there")) )
4645 {
4646 NitsCompare(value.uint32, E2BIG,PAL_T("OMI_Code != E2BIG"));
4647 }
4648 if(NitsCompare( MI_Instance_GetElement( pInst4, PAL_T("CIMStatusCode"), &value, NULL, NULL, NULL) , MI_RESULT_OK, PAL_T("CIMStatusCode is not there")) )
4649 {
4650 NitsCompare(value.uint32, MI_RESULT_FAILED,PAL_T("CIMStatusCode != MI_RESULT_FAILED"));
4651 }
4652 MI_Instance_Delete(pInst4);
4653 }
4654 }
4655 NitsEndTest
4656
4657 #if 0
4658 NitsTest(TestPassingParametersToMethodThatNeedsNoParameters)
4659 {
4660 MI_Application application = MI_APPLICATION_NULL;
4661 MI_Session session = MI_SESSION_NULL;
4662 MI_Operation operation = MI_OPERATION_NULL;
4663 krisbash 1.1
4664 if (NitsCompare(MI_Application_Initialize(0, NULL, NULL, &application), MI_RESULT_OK, PAL_T("MI_Application_Initialize returns OK")) &&
4665 NitsAssert(application.ft != NULL, PAL_T("MI_Application function table should not be NULL")))
4666 {
4667 MI_Instance *instance = NULL;
4668 MI_Instance *parameter = NULL;
4669 MI_Value value;
4670 value.string = PAL_T("0");
4671
4672 if (NitsCompare(MI_Application_NewInstance(&application, PAL_T("Win32_Process"), NULL, &instance), MI_RESULT_OK, PAL_T("instance")) &&
4673 NitsAssert(instance != NULL, PAL_T("failed to create instance")) &&
4674 NitsCompare(MI_Instance_AddElement(instance, PAL_T("Handle"), &value, MI_STRING, MI_FLAG_KEY), MI_RESULT_OK, PAL_T("Add instance handle key")) &&
4675 NitsCompare(MI_Application_NewParameterSet(&application, NULL, ¶meter), MI_RESULT_OK, PAL_T("parameter")) &&
4676 NitsAssert(parameter != NULL, PAL_T("failed to create parameter")))
4677 {
4678 if (NitsCompare(MI_Application_NewSession(&application, NULL, NULL, NULL, NULL, NULL, &session), MI_RESULT_OK, PAL_T("MI_Application_NewSession returns OK")) &&
4679 NitsAssert(session.ft != NULL, PAL_T("MI_Session function table should not be NULL")))
4680 {
4681 MI_Session_Invoke(&session, 0, NULL, PAL_T("root\\cimv2"), PAL_T("Win32_Process"), PAL_T("GetOwner"), instance, parameter, NULL, &operation);
4682 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
4683
4684 krisbash 1.1 const MI_Instance *resultInstance;
4685 MI_Boolean moreResults;
4686 MI_Result result;
4687 const MI_Char *errorMessage;
4688 const MI_Instance *completionDetails;
4689
4690 MI_Operation_GetInstance(&operation, &resultInstance, &moreResults, &result, &errorMessage, &completionDetails);
4691 NitsCompare(result, MI_RESULT_INVALID_PARAMETER, PAL_T("Should fail with invalid parameter"));
4692
4693 MI_Operation_Close(&operation);
4694
4695 MI_Session_Close(&session, NULL, NULL);
4696 }
4697 MI_Instance_Delete(instance);
4698 MI_Instance_Delete(parameter);
4699 }
4700
4701 MI_Application_Close(&application);
4702 }
4703 }
4704 NitsEndTest
4705 krisbash 1.1 #endif
4706
4707 void MI_OperationOptions_ReadOperations_Internal(
4708 MI_OperationOptions& options,
4709 bool cloned = false)
4710 {
4711 MI_OperationOptions *nullOptions = NULL;
4712 const MI_Char *nullString = NULL;
4713 const MI_Char **nullStringPtr = NULL;
4714 MI_Uint32 *nullNumberPtr = 0;
4715 MI_Uint32 *nullIndex = 0;
4716 MI_Uint32 index = 0;
4717 MI_Value *nullMIValuePtr = NULL;
4718 MI_Type *nullMITypePtr = 0;
4719 MI_Uint32 flag;
4720
4721 // Read string
4722 {
4723 const MI_Char * stringValue = NULL;
4724 const MI_Char * optionName = PAL_T("option1");
4725 NitsCompare(options.ft->GetString(&options, optionName, &stringValue, nullIndex, &flag), MI_RESULT_OK, PAL_T("GetString should work"));
4726 krisbash 1.1 NitsCompare(options.ft->GetString(&options, optionName, &stringValue, &index, 0), MI_RESULT_OK, PAL_T("GetString should work"));
4727 NitsCompareString(stringValue, PAL_T("value1"), PAL_T("GetString should work"));
4728 if (!cloned) NitsCompare(index, 1, PAL_T("GetString should work"));
4729
4730 NitsCompare(options.ft->GetString(&options, PAL_T("option2"), &stringValue, nullIndex, 0), MI_RESULT_TYPE_MISMATCH, PAL_T("GetString should return MI_RESULT_TYPE_MISMATCH"));
4731 NitsCompare(options.ft->GetString(&options, PAL_T("optionbla"), &stringValue, nullIndex, 0), MI_RESULT_NO_SUCH_PROPERTY, PAL_T("GetString should return MI_RESULT_NO_SUCH_PROPERTY"));
4732 NitsCompare(options.ft->GetString(nullOptions, optionName, &stringValue, 0, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetString should fail"));
4733 NitsCompare(options.ft->GetString(&options, nullString, &stringValue, 0, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetString should fail"));
4734 NitsCompare(options.ft->GetString(&options, optionName, nullStringPtr, 0, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetString should fail"));
4735 }
4736 // Read number
4737 {
4738 MI_Uint32 int32Value = 0;
4739 const MI_Char * optionName = PAL_T("option2");
4740 NitsCompare(options.ft->GetNumber(&options, optionName, &int32Value, nullIndex, 0), MI_RESULT_OK, PAL_T("GetNumber should work"));
4741 NitsCompare(options.ft->GetNumber(&options, optionName, &int32Value, &index, 0), MI_RESULT_OK, PAL_T("GetNumber should work"));
4742 NitsCompare(int32Value, 33, PAL_T("GetNumber should work"));
4743 if (!cloned) NitsCompare(index, 2, PAL_T("GetNumber should work"));
4744
4745 NitsCompare(options.ft->GetNumber(&options, PAL_T("option1"), &int32Value, nullIndex, 0), MI_RESULT_TYPE_MISMATCH, PAL_T("GetNumber return MI_RESULT_TYPE_MISMATCH"));
4746 NitsCompare(options.ft->GetNumber(&options, PAL_T("optionBla"), &int32Value, nullIndex, 0), MI_RESULT_NO_SUCH_PROPERTY, PAL_T("GetNumber return MI_RESULT_NOT_FOUND"));
4747 krisbash 1.1 NitsCompare(options.ft->GetNumber(nullOptions, optionName, &int32Value, 0, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetNumber should fail"));
4748 NitsCompare(options.ft->GetNumber(&options, nullString, &int32Value, 0, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetNumber should fail"));
4749 NitsCompare(options.ft->GetNumber(&options, optionName, nullNumberPtr, 0, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetNumber should fail"));
4750 }
4751
4752 // GetOptionCount
4753 {
4754 MI_Uint32 optionCount = 0;
4755 NitsCompare(options.ft->GetOptionCount(nullOptions, &optionCount), MI_RESULT_INVALID_PARAMETER, PAL_T("GetOptionCount should fail"));
4756 NitsCompare(options.ft->GetOptionCount(&options, nullNumberPtr), MI_RESULT_INVALID_PARAMETER, PAL_T("GetOptionCount should fail"));
4757
4758 NitsCompare(options.ft->GetOptionCount(&options, &optionCount), MI_RESULT_OK, PAL_T("GetOptionCount should success"));
4759 MI_Uint32 expectedCount = 5;
4760 NitsCompare(optionCount, expectedCount, PAL_T("GetOptionCount should success"));
4761 if (optionCount == expectedCount)
4762 {
4763 for(MI_Uint32 i = 0; i < optionCount; i++)
4764 {
4765 MI_Value value = {0};
4766 MI_Type type = MI_BOOLEAN;
4767 const MI_Char * optionName = NULL;
4768 krisbash 1.1 NitsCompare(options.ft->GetOptionAt(&options, i, &optionName, &value, &type, 0), MI_RESULT_OK, PAL_T("GetOptionAt should success"));
4769 }
4770 }
4771 }
4772
4773 // GetOptionAt
4774 if (!cloned)
4775 {
4776 MI_Value value = {0};
4777 MI_Type type = MI_BOOLEAN;
4778 const MI_Char * optionName = NULL;
4779 NitsCompare(options.ft->GetOptionAt(nullOptions, 0, &optionName, &value, nullMITypePtr, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetOptionAt should fail"));
4780 NitsCompare(options.ft->GetOptionAt(&options, 0, &optionName, &value, nullMITypePtr, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetOptionAt should fail"));
4781 NitsCompare(options.ft->GetOptionAt(&options, 0, nullStringPtr, nullMIValuePtr, nullMITypePtr, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetOptionAt should fail"));
4782 NitsCompare(options.ft->GetOptionAt(&options, 0, &optionName, &value, nullMITypePtr, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetOptionAt should fail"));
4783
4784 NitsCompare(options.ft->GetOptionAt(&options, 0x100, &optionName, &value, &type, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetOptionAt should return MI_RESULT_INVALID_PARAMETER"));
4785
4786 NitsCompare(options.ft->GetOptionAt(&options, 1, &optionName, &value, &type, 0), MI_RESULT_OK, PAL_T("GetOptionAt should success"));
4787 if (NitsCompare(type, MI_STRING, PAL_T("GetOptionAt should success")))
4788 {
4789 krisbash 1.1 NitsCompareString(value.string, PAL_T("value1"), PAL_T("GetOptionAt should success"));
4790 }
4791 }
4792
4793 // GetOption
4794 {
4795 MI_Value value = {0};
4796 MI_Type type = MI_BOOLEAN;
4797 const MI_Char * optionName = PAL_T("option1");
4798 NitsCompare(options.ft->GetOption(nullOptions, optionName, &value, nullMITypePtr, 0, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetOption should fail"));
4799 NitsCompare(options.ft->GetOption(&options, nullString, &value, nullMITypePtr, 0, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetOption should fail"));
4800 NitsCompare(options.ft->GetOption(&options, optionName, nullMIValuePtr, nullMITypePtr, 0, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetOption should fail"));
4801 NitsCompare(options.ft->GetOption(&options, optionName, &value, nullMITypePtr, 0, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetOption should fail"));
4802 NitsCompare(options.ft->GetOption(&options, PAL_T("optionbla"), &value, &type, &index, 0), MI_RESULT_NO_SUCH_PROPERTY, PAL_T("GetOption should return MI_RESULT_NOT_FOUND"));
4803
4804 NitsCompare(options.ft->GetOption(&options, optionName, &value, &type, &index, 0), MI_RESULT_OK, PAL_T("GetOption should success"));
4805 if (NitsCompare(type, MI_STRING, PAL_T("GetOption should success")))
4806 {
4807 NitsCompareString(value.string, PAL_T("value1"), PAL_T("GetOption should success"));
4808 }
4809 if (!cloned) NitsCompare(index, 1, PAL_T("GetOption should success"));
4810 krisbash 1.1 }
4811
4812 // GetEnabledChannels
4813 {
4814 const MI_Char * optionName = PAL_T("option1");
4815 MI_Uint32 channels[3] = {0};
4816 MI_Uint32 channelCount = 0;
4817 NitsCompare(options.ft->GetEnabledChannels(nullOptions, optionName, channels, 1, nullNumberPtr, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetEnabledChannels should fail"));
4818 NitsCompare(options.ft->GetEnabledChannels(&options, nullString, channels, 1, nullNumberPtr, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetEnabledChannels should fail"));
4819 NitsCompare(options.ft->GetEnabledChannels(&options, optionName, channels, 1, nullNumberPtr, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetEnabledChannels should fail"));
4820
4821 NitsCompare(options.ft->GetEnabledChannels(&options, optionName, channels, 1, &channelCount, 0), MI_RESULT_TYPE_MISMATCH, PAL_T("GetEnabledChannels should return MI_RESULT_NOT_FOUND"));
4822
4823 // too small buffer
4824 NitsCompare(MI_OperationOptions_GetEnabledChannels(&options, channels, 1, &channelCount, 0), MI_RESULT_FAILED, PAL_T("GetEnabledChannels should return MI_RESULT_FAILED"));
4825
4826 MI_Uint32 expectedCount = 3;
4827 NitsCompare(MI_OperationOptions_GetEnabledChannels(&options, channels, expectedCount, &channelCount, 0), MI_RESULT_OK, PAL_T("GetEnabledChannels should success"));
4828 NitsCompare(MI_OperationOptions_GetEnabledChannels(&options, channels, expectedCount, &channelCount, &flag), MI_RESULT_OK, PAL_T("GetEnabledChannels should success"));
4829
4830 NitsCompare(channelCount, expectedCount, PAL_T("GetEnabledChannels should success"));
4831 krisbash 1.1
4832 NitsCompare(channels[0], 0, PAL_T("GetEnabledChannels should success"));
4833 NitsCompare(channels[1], 2, PAL_T("GetEnabledChannels should success"));
4834 NitsCompare(channels[2], 3, PAL_T("GetEnabledChannels should success"));
4835 }
4836 }
4837
4838 NitsTest1(MI_OperationOptions_ReadOperations,
4839 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1)
4840 {
4841 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
4842 ResetRuntimeTestData(testData);
4843 MI_Application *application = &testData->application;
4844
4845 MI_OperationOptions options = MI_OPERATIONOPTIONS_NULL;
4846
4847 #if defined (_MSC_VER)
4848 #pragma prefast(push)
4849 #pragma prefast(disable: 6309)
4850 #endif
4851 NitsCompare(MI_Application_NewOperationOptions(NULL, MI_FALSE, &options), MI_RESULT_INVALID_PARAMETER, PAL_T("NewOperationOptions invalid parameter"));
4852 krisbash 1.1 NitsCompare(MI_Application_NewOperationOptions(application, MI_FALSE, NULL), MI_RESULT_INVALID_PARAMETER, PAL_T("NewOperationOptions invalid parameter"));
4853 #if defined (_MSC_VER)
4854 #pragma prefast(pop)
4855 #endif
4856
4857 if (NitsCompare(MI_Application_NewOperationOptions(application, MI_FALSE, &options), MI_RESULT_OK, PAL_T("NewOperationOptions should succeed")))
4858 {
4859 if (NitsAssert(options.ft != NULL, PAL_T("Should have options function table")))
4860 {
4861 NitsCompare(options.ft->SetString(&options, PAL_T("option1"), PAL_T("value1"), 0), MI_RESULT_OK, PAL_T("SetString should work"));
4862 NitsCompare(options.ft->SetNumber(&options, PAL_T("option2"), 33, 0), MI_RESULT_OK, PAL_T("SetNumber should work"));
4863 {
4864 MI_Uint8 valueArray[2];
4865 MI_Value value;
4866 value.uint8 = 10;
4867 NitsCompare(options.ft->SetCustomOption(&options, PAL_T("uint8"), MI_UINT8, &value, MI_FALSE, 0), MI_RESULT_OK, PAL_T("SetCustomOption(uint8) should work"));
4868
4869 valueArray[0] = 10;
4870 valueArray[1] = 20;
4871 value.uint8a.data = valueArray;
4872 value.uint8a.size = 2;
4873 krisbash 1.1 NitsCompare(options.ft->SetCustomOption(&options, PAL_T("uint8a"), MI_UINT8A, &value, MI_FALSE, 0), MI_RESULT_OK, PAL_T("SetCustomOption(uint8a) should work"));
4874 }
4875 {
4876 NitsCompare(MI_OperationOptions_EnableChannel(&options, 1), MI_RESULT_OK, PAL_T("MI_OperationOptions_EnableChannel should work"));
4877 NitsCompare(MI_OperationOptions_EnableChannel(&options, 2), MI_RESULT_OK, PAL_T("MI_OperationOptions_EnableChannel should work"));
4878 NitsCompare(MI_OperationOptions_EnableChannel(&options, 3), MI_RESULT_OK, PAL_T("MI_OperationOptions_EnableChannel should work"));
4879 NitsCompare(MI_OperationOptions_DisableChannel(&options, 1), MI_RESULT_OK, PAL_T("MI_OperationOptions_DisableChannel should work"));
4880 }
4881
4882 MI_OperationOptions_ReadOperations_Internal(options);
4883 }
4884 #if defined (_MSC_VER)
4885 #pragma prefast(push)
4886 #pragma prefast(disable: 6011)
4887 #endif
4888 options.ft->Delete(NULL);
4889 #if defined (_MSC_VER)
4890 #pragma prefast(pop)
4891 #endif
4892 MI_OperationOptions_Delete(&options);
4893 }
4894 krisbash 1.1 }
4895 NitsEndTest
4896
4897 NitsTest1(MI_OperationOptions_CloneTest,
4898 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1)
4899 {
4900 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
4901 ResetRuntimeTestData(testData);
4902 MI_Application *application = &testData->application;
4903
4904 MI_OperationOptions options = MI_OPERATIONOPTIONS_NULL;
4905
4906 #if defined (_MSC_VER)
4907 #pragma prefast(push)
4908 #pragma prefast(disable: 6309)
4909 #endif
4910 NitsCompare(MI_Application_NewOperationOptions(NULL, MI_FALSE, &options), MI_RESULT_INVALID_PARAMETER, PAL_T("NewOperationOptions invalid parameter"));
4911 NitsCompare(MI_Application_NewOperationOptions(application, MI_FALSE, NULL), MI_RESULT_INVALID_PARAMETER, PAL_T("NewOperationOptions invalid parameter"));
4912 #if defined (_MSC_VER)
4913 #pragma prefast(pop)
4914 #endif
4915 krisbash 1.1
4916 if (NitsCompare(MI_Application_NewOperationOptions(application, MI_FALSE, &options), MI_RESULT_OK, PAL_T("NewOperationOptions should succeed")))
4917 {
4918 if (NitsAssert(options.ft != NULL, PAL_T("Should have options function table")))
4919 {
4920 NitsCompare(options.ft->SetString(&options, PAL_T("option1"), PAL_T("value1"), 0), MI_RESULT_OK, PAL_T("SetString should work"));
4921 NitsCompare(options.ft->SetNumber(&options, PAL_T("option2"), 33, 0), MI_RESULT_OK, PAL_T("SetNumber should work"));
4922 {
4923 MI_Uint8 valueArray[2];
4924 MI_Value value;
4925 value.uint8 = 10;
4926 NitsCompare(options.ft->SetCustomOption(&options, PAL_T("uint8"), MI_UINT8, &value, MI_FALSE, 0), MI_RESULT_OK, PAL_T("SetCustomOption(uint8) should work"));
4927
4928 valueArray[0] = 10;
4929 valueArray[1] = 20;
4930 value.uint8a.data = valueArray;
4931 value.uint8a.size = 2;
4932 NitsCompare(options.ft->SetCustomOption(&options, PAL_T("uint8a"), MI_UINT8A, &value, MI_FALSE, 0), MI_RESULT_OK, PAL_T("SetCustomOption(uint8a) should work"));
4933 }
4934 {
4935 NitsCompare(MI_OperationOptions_EnableChannel(&options, 1), MI_RESULT_OK, PAL_T("MI_OperationOptions_EnableChannel should work"));
4936 krisbash 1.1 NitsCompare(MI_OperationOptions_EnableChannel(&options, 2), MI_RESULT_OK, PAL_T("MI_OperationOptions_EnableChannel should work"));
4937 NitsCompare(MI_OperationOptions_EnableChannel(&options, 3), MI_RESULT_OK, PAL_T("MI_OperationOptions_EnableChannel should work"));
4938 NitsCompare(MI_OperationOptions_DisableChannel(&options, 1), MI_RESULT_OK, PAL_T("MI_OperationOptions_DisableChannel should work"));
4939 }
4940 MI_OperationOptions clonedOptions = MI_OPERATIONOPTIONS_NULL;
4941 if (NitsCompare(MI_OperationOptions_Clone(&options, &clonedOptions), MI_RESULT_OK, PAL_T("MI_OperationOptions_Clone returns OK")) &&
4942 NitsAssert(clonedOptions.ft != NULL, PAL_T("MI_OperationOptions function table should not be NULL")))
4943 {
4944 NitsCompare((MI_Uint32)options.reserved1, (MI_Uint32)clonedOptions.reserved1, PAL_T("Cloned options should has same mustUnderstand value"));
4945 MI_OperationOptions_ReadOperations_Internal(clonedOptions, true);
4946 MI_OperationOptions_Delete(&clonedOptions);
4947 }
4948 }
4949 #if defined (_MSC_VER)
4950 #pragma prefast(push)
4951 #pragma prefast(disable: 6011)
4952 #endif
4953 options.ft->Delete(NULL);
4954 #if defined (_MSC_VER)
4955 #pragma prefast(pop)
4956 #endif
4957 krisbash 1.1 MI_OperationOptions_Delete(&options);
4958 }
4959 }
4960 NitsEndTest
4961
4962 void MI_DestinationOptions_ReadOperations_Internal(
4963 MI_DestinationOptions& options,
4964 MI_UserCredentials& creds,
4965 bool cloned = false)
4966 {
4967 MI_DestinationOptions *nullOptions = NULL;
4968 const MI_Char *nullString = NULL;
4969 const MI_Char **nullStringPtr = NULL;
4970 MI_Uint32 *nullNumberPtr = 0;
4971 MI_Uint32 *nullIndex = 0;
4972 MI_Uint32 index = 0;
4973 MI_Value *nullMIValuePtr = NULL;
4974 MI_Type *nullMITypePtr = 0;
4975 MI_Uint32 flag;
4976
4977 // Read string
4978 krisbash 1.1 {
4979 const MI_Char * stringValue = NULL;
4980 const MI_Char * optionName = PAL_T("option1");
4981 NitsCompare(options.ft->GetString(&options, optionName, &stringValue, nullIndex, &flag), MI_RESULT_OK, PAL_T("GetString should work"));
4982 NitsCompare(options.ft->GetString(&options, optionName, &stringValue, &index, 0), MI_RESULT_OK, PAL_T("GetString should work"));
4983 NitsCompareString(stringValue, PAL_T("value1"), PAL_T("GetString should work"));
4984
4985 #if defined (_MSC_VER)
4986 if (!cloned) NitsCompare(index, 2, PAL_T("GetString should work"));
4987 #else
4988 if (!cloned) NitsCompare(index, 0, PAL_T("GetString should work"));
4989 #endif
4990
4991 NitsCompare(options.ft->GetString(&options, PAL_T("option2"), &stringValue, nullIndex, 0), MI_RESULT_TYPE_MISMATCH, PAL_T("GetString should return MI_RESULT_TYPE_MISMATCH"));
4992 NitsCompare(options.ft->GetString(&options, PAL_T("optionbla"), &stringValue, nullIndex, 0), MI_RESULT_NO_SUCH_PROPERTY, PAL_T("GetString should return MI_RESULT_NOT_FOUND"));
4993 NitsCompare(options.ft->GetString(nullOptions, optionName, &stringValue, 0, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetString should fail"));
4994 NitsCompare(options.ft->GetString(&options, nullString, &stringValue, 0, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetString should fail"));
4995 NitsCompare(options.ft->GetString(&options, optionName, nullStringPtr, 0, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetString should fail"));
4996 }
4997
4998 // Read default Locale
4999 krisbash 1.1 #if defined(_MSC_VER)
5000 {
5001 ULONG numLangs = 0;
5002 ULONG lenBuffer = MI_MAX_LOCALE_SIZE;
5003 WCHAR buffer[MI_MAX_LOCALE_SIZE];
5004 if (GetThreadPreferredUILanguages(0, &numLangs, buffer, &lenBuffer))
5005 {
5006 const MI_Char * strLocale = NULL;
5007 MI_Result r = MI_DestinationOptions_GetUILocale(&options, &strLocale);
5008 NitsCompare(r, MI_RESULT_OK, PAL_T("MI_DestinationOptions_GetUILocale should success"));
5009 if (r == MI_RESULT_OK)
5010 {
5011 NitsCompareString(strLocale, buffer, PAL_T("MI_DestinationOptions_GetUILocale should success"));
5012 }
5013 r = MI_DestinationOptions_GetDataLocale(&options, &strLocale);
5014 NitsCompare(r, MI_RESULT_OK, PAL_T("MI_DestinationOptions_GetDataLocale should success"));
5015 if (r == MI_RESULT_OK)
5016 {
5017 NitsCompareString(strLocale, buffer, PAL_T("MI_DestinationOptions_GetDataLocale should success"));
5018 }
5019 }
5020 krisbash 1.1 else
5021 {
5022 NitsCompare(1, 0, PAL_T("GetThreadPreferredUILanguages failed"));
5023 }
5024 }
5025 #endif
5026
5027 // Read number
5028 {
5029 MI_Uint32 int32Value = 0;
5030 const MI_Char * optionName = PAL_T("option2");
5031 NitsCompare(options.ft->GetNumber(&options, optionName, &int32Value, nullIndex, 0), MI_RESULT_OK, PAL_T("GetNumber should work"));
5032 NitsCompare(options.ft->GetNumber(&options, optionName, &int32Value, &index, &flag), MI_RESULT_OK, PAL_T("GetNumber should work"));
5033 NitsCompare(int32Value, 33, PAL_T("GetNumber should work"));
5034 #if defined (_MSC_VER)
5035 if (!cloned) NitsCompare(index, 3, PAL_T("GetString should work"));
5036 #else
5037 if (!cloned) NitsCompare(index, 1, PAL_T("GetString should work"));
5038 #endif
5039
5040 NitsCompare(options.ft->GetNumber(&options, PAL_T("option1"), &int32Value, nullIndex, 0), MI_RESULT_TYPE_MISMATCH, PAL_T("GetNumber return MI_RESULT_TYPE_MISMATCH"));
5041 krisbash 1.1 NitsCompare(options.ft->GetNumber(&options, PAL_T("optionBla"), &int32Value, nullIndex, 0), MI_RESULT_NO_SUCH_PROPERTY, PAL_T("GetNumber return MI_RESULT_NOT_FOUND"));
5042 NitsCompare(options.ft->GetNumber(nullOptions, optionName, &int32Value, 0, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetNumber should fail"));
5043 NitsCompare(options.ft->GetNumber(&options, nullString, &int32Value, 0, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetNumber should fail"));
5044 NitsCompare(options.ft->GetNumber(&options, optionName, nullNumberPtr, 0, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetNumber should fail"));
5045 }
5046
5047 // GetOptionCount
5048 {
5049 MI_Uint32 optionCount = 0;
5050 NitsCompare(options.ft->GetOptionCount(nullOptions, &optionCount), MI_RESULT_INVALID_PARAMETER, PAL_T("GetOptionCount should fail"));
5051 NitsCompare(options.ft->GetOptionCount(&options, nullNumberPtr), MI_RESULT_INVALID_PARAMETER, PAL_T("GetOptionCount should fail"));
5052
5053 NitsCompare(options.ft->GetOptionCount(&options, &optionCount), MI_RESULT_OK, PAL_T("GetOptionCount should success"));
5054
5055 #if defined(_MSC_VER)
5056 NitsCompare(optionCount, 4, PAL_T("GetOptionCount should success"));
5057 #else
5058 /* No locale items yet */
5059 NitsCompare(optionCount, 2, PAL_T("GetOptionCount should success"));
5060 #endif
5061 }
5062 krisbash 1.1
5063 // GetOptionAt
5064 if (!cloned)
5065 {
5066 MI_Value value = {0};
5067 MI_Type type = MI_BOOLEAN;
5068 const MI_Char * optionName = NULL;
5069 NitsCompare(options.ft->GetOptionAt(nullOptions, 0, &optionName, &value, nullMITypePtr, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetOptionAt should fail"));
5070 NitsCompare(options.ft->GetOptionAt(&options, 0, &optionName, &value, nullMITypePtr, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetOptionAt should fail"));
5071 NitsCompare(options.ft->GetOptionAt(&options, 0, nullStringPtr, nullMIValuePtr, nullMITypePtr, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetOptionAt should fail"));
5072 NitsCompare(options.ft->GetOptionAt(&options, 0, &optionName, &value, nullMITypePtr, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetOptionAt should fail"));
5073
5074 NitsCompare(options.ft->GetOptionAt(&options, 0x100, &optionName, &value, &type, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetOptionAt should return MI_RESULT_NOT_FOUND"));
5075
5076 #if defined (_MSC_VER)
5077 NitsCompare(options.ft->GetOptionAt(&options, 2, &optionName, &value, &type, &flag), MI_RESULT_OK, PAL_T("GetOptionAt should success"));
5078 #else
5079 NitsCompare(options.ft->GetOptionAt(&options, 0, &optionName, &value, &type, &flag), MI_RESULT_OK, PAL_T("GetOptionAt should success"));
5080 #endif
5081 if (NitsCompare(type, MI_STRING, PAL_T("GetOptionAt should success")))
5082 NitsCompareString(value.string, PAL_T("value1"), PAL_T("GetOptionAt should success"));
5083 krisbash 1.1 }
5084
5085 // GetOption
5086 {
5087 MI_Value value = {0};
5088 MI_Type type = MI_BOOLEAN;
5089 const MI_Char * optionName = PAL_T("option1");
5090 NitsCompare(options.ft->GetOption(nullOptions, optionName, &value, nullMITypePtr, 0, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetOption should fail"));
5091 NitsCompare(options.ft->GetOption(&options, nullString, &value, nullMITypePtr, 0, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetOption should fail"));
5092 NitsCompare(options.ft->GetOption(&options, optionName, nullMIValuePtr, nullMITypePtr, 0, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetOption should fail"));
5093 NitsCompare(options.ft->GetOption(&options, optionName, &value, nullMITypePtr, 0, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetOption should fail"));
5094 NitsCompare(options.ft->GetOption(&options, PAL_T("optionbla"), &value, &type, &index, 0), MI_RESULT_NO_SUCH_PROPERTY, PAL_T("GetOption should return MI_RESULT_NOT_FOUND"));
5095
5096 NitsCompare(options.ft->GetOption(&options, optionName, &value, &type, &index, 0), MI_RESULT_OK, PAL_T("GetOption should success"));
5097 if (NitsCompare(type, MI_STRING, PAL_T("GetOption should success")))
5098 NitsCompareString(value.string, PAL_T("value1"), PAL_T("GetOption should success"));
5099 #if defined(_MSC_VER)
5100 if (!cloned) NitsCompare(index, 2, PAL_T("GetOption should success"));
5101 #else
5102 if (!cloned) NitsCompare(index, 0, PAL_T("GetOption should success"));
5103 #endif
5104 krisbash 1.1 }
5105
5106 // GetCredentials
5107 {
5108 MI_Uint32 credentialCount = 0;
5109 NitsCompare(options.ft->GetCredentialsCount(&options, &credentialCount), MI_RESULT_OK, PAL_T("GetCredentialsCount should work"));
5110 NitsCompare(credentialCount, 1, PAL_T("GetCredentialsCount should work"));
5111
5112 MI_UserCredentials credential = {0};
5113 const MI_Char *credentialOptionName = NULL;
5114 NitsCompare(options.ft->GetCredentialsAt(&options, 0, &credentialOptionName, &credential, &flag), MI_RESULT_OK, PAL_T("GetCredentialsAt should work"));
5115 NitsCompareString(credential.authenticationType, creds.authenticationType, PAL_T("GetCredentialsAt authenticationType should correct"));
5116 NitsCompareString(credential.credentials.usernamePassword.domain, creds.credentials.usernamePassword.domain, PAL_T("GetCredentialsAt domain should correct"));
5117 NitsCompareString(credential.credentials.usernamePassword.password, PAL_T("******"), PAL_T("GetCredentialsAt password should correct"));
5118 NitsCompareString(credential.credentials.usernamePassword.username, creds.credentials.usernamePassword.username, PAL_T("GetCredentialsAt username should correct"));
5119 NitsCompareString(credentialOptionName, PAL_T("option3"), PAL_T("GetCredentialsAt option name should correct"));
5120
5121 MI_Uint32 passwordLength = 0;
5122 MI_Char password[9];
5123 MI_Result r = options.ft->GetCredentialsPasswordAt(&options, 0, &credentialOptionName, password, 9, &passwordLength, &flag);
5124 NitsCompare(r, MI_RESULT_OK, PAL_T("GetCredentialsPasswordAt should work"));
5125 krisbash 1.1 if (r == MI_RESULT_OK)
5126 {
5127 NitsCompareString(credentialOptionName, PAL_T("option3"), PAL_T("GetCredentialsPasswordAt option name should correct"));
5128
5129 #ifdef _PREFAST_
5130 #pragma prefast(push)
5131 #pragma prefast(disable:26035)
5132 #endif
5133 NitsCompareString(password, creds.credentials.usernamePassword.password, PAL_T("GetCredentialsPasswordAt should work"));
5134 #ifdef _PREFAST_
5135 #pragma prefast(pop)
5136 #endif
5137 NitsCompare(passwordLength, 9, PAL_T("GetCredentialsPasswordAt should work"));
5138 }
5139
5140 NitsCompare(options.ft->GetCredentialsPasswordAt(&options, 1, &credentialOptionName, password, 9, &passwordLength, 0), MI_RESULT_NO_SUCH_PROPERTY, PAL_T("GetCredentialsPasswordAt should return MI_RESULT_NOT_FOUND"));
5141 NitsCompare(options.ft->GetCredentialsPasswordAt(nullOptions, 0, &credentialOptionName, password, 9, &passwordLength, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetCredentialsPasswordAt should return MI_RESULT_INVALID_PARAMETER"));
5142 NitsCompare(options.ft->GetCredentialsPasswordAt(&options, 0, nullStringPtr, password, 9, &passwordLength, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetCredentialsPasswordAt should return MI_RESULT_INVALID_PARAMETER"));
5143 NitsCompare(options.ft->GetCredentialsPasswordAt(&options, 0, &credentialOptionName, password, 9, nullNumberPtr, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetCredentialsPasswordAt should return MI_RESULT_INVALID_PARAMETER"));
5144 NitsCompare(options.ft->GetCredentialsPasswordAt(&options, 0, &credentialOptionName, password, 8, &passwordLength, 0), MI_RESULT_FAILED, PAL_T("GetCredentialsPasswordAt should return MI_RESULT_FAILED"));
5145
5146 krisbash 1.1 MI_UserCredentials *nullCredentials = NULL;
5147 NitsCompare(options.ft->GetCredentialsAt(&options, 1, &credentialOptionName, &credential, 0), MI_RESULT_NO_SUCH_PROPERTY, PAL_T("GetCredentialsAt should return MI_RESULT_NOT_FOUND"));
5148 NitsCompare(options.ft->GetCredentialsAt(nullOptions, 0, &credentialOptionName, &credential, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetCredentialsAt should return MI_RESULT_INVALID_PARAMETER"));
5149 NitsCompare(options.ft->GetCredentialsAt(&options, 0, nullStringPtr, &credential, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetCredentialsAt should return MI_RESULT_INVALID_PARAMETER"));
5150 NitsCompare(options.ft->GetCredentialsAt(&options, 0, &credentialOptionName, nullCredentials, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetCredentialsAt should return MI_RESULT_INVALID_PARAMETER"));
5151 }
5152 }
5153
5154 NitsTest1(MI_DestinationOptions_ReadOperations,
5155 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1)
5156 {
5157 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
5158 ResetRuntimeTestData(testData);
5159 MI_Application *application = &testData->application;
5160
5161 MI_DestinationOptions options = MI_DESTINATIONOPTIONS_NULL;
5162
5163 #if defined (_MSC_VER)
5164 #pragma prefast(push)
5165 #pragma prefast(disable: 6309)
5166 #endif
5167 krisbash 1.1 NitsCompare(MI_Application_NewDestinationOptions(NULL, &options), MI_RESULT_INVALID_PARAMETER, PAL_T("NewDestinationOptions invalid parameter"));
5168 NitsCompare(MI_Application_NewDestinationOptions(application, NULL), MI_RESULT_INVALID_PARAMETER, PAL_T("NewDestinationOptions invalid parameter"));
5169 #if defined (_MSC_VER)
5170 #pragma prefast(pop)
5171 #endif
5172
5173 if (NitsCompare(MI_Application_NewDestinationOptions(application, &options), MI_RESULT_OK, PAL_T("NewDestinationOptions should succeed")))
5174 {
5175 if (NitsAssert(options.ft != NULL, PAL_T("Should have options function table")))
5176 {
5177 NitsCompare(options.ft->SetString(&options, PAL_T("option1"), PAL_T("value1"), 0), MI_RESULT_OK, PAL_T("SetString should work"));
5178
5179 NitsCompare(options.ft->SetNumber(&options, PAL_T("option2"), 33, 0), MI_RESULT_OK, PAL_T("SetNumber should work"));
5180
5181 MI_UserCredentials creds = { MI_AUTH_TYPE_BASIC, {{ PAL_T("domain"), PAL_T("username"), PAL_T("password") }}};
5182 NitsCompare(options.ft->AddCredentials(&options, PAL_T("option3"), &creds, 0), MI_RESULT_OK, PAL_T("AddCredentials should work"));
5183
5184 MI_DestinationOptions_ReadOperations_Internal(options, creds);
5185 }
5186 #if defined (_MSC_VER)
5187 #pragma prefast(push)
5188 krisbash 1.1 #pragma prefast(disable: 6011)
5189 #endif
5190 options.ft->Delete(NULL);
5191 #if defined (_MSC_VER)
5192 #pragma prefast(pop)
5193 #endif
5194 MI_DestinationOptions_Delete(&options);
5195 }
5196 }
5197 NitsEndTest
5198
5199 NitsTest1(MI_DestinationOptions_CloneTest,
5200 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1)
5201 {
5202 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
5203 ResetRuntimeTestData(testData);
5204 MI_Application *application = &testData->application;
5205
5206 MI_DestinationOptions options = MI_DESTINATIONOPTIONS_NULL;
5207
5208 #if defined (_MSC_VER)
5209 krisbash 1.1 #pragma prefast(push)
5210 #pragma prefast(disable: 6309)
5211 #endif
5212 NitsCompare(MI_Application_NewDestinationOptions(NULL, &options), MI_RESULT_INVALID_PARAMETER, PAL_T("NewDestinationOptions invalid parameter"));
5213 NitsCompare(MI_Application_NewDestinationOptions(application, NULL), MI_RESULT_INVALID_PARAMETER, PAL_T("NewDestinationOptions invalid parameter"));
5214 #if defined (_MSC_VER)
5215 #pragma prefast(pop)
5216 #endif
5217
5218 if (NitsCompare(MI_Application_NewDestinationOptions(application, &options), MI_RESULT_OK, PAL_T("NewDestinationOptions should succeed")))
5219 {
5220 if (NitsAssert(options.ft != NULL, PAL_T("Should have options function table")))
5221 {
5222 NitsCompare(options.ft->SetString(&options, PAL_T("option1"), PAL_T("value1"), 0), MI_RESULT_OK, PAL_T("SetString should work"));
5223
5224 NitsCompare(options.ft->SetNumber(&options, PAL_T("option2"), 33, 0), MI_RESULT_OK, PAL_T("SetNumber should work"));
5225
5226 MI_UserCredentials creds = { MI_AUTH_TYPE_BASIC, {{PAL_T("domain"), PAL_T("username"), PAL_T("password") }}};
5227 NitsCompare(options.ft->AddCredentials(&options, PAL_T("option3"), &creds, 0), MI_RESULT_OK, PAL_T("AddCredentials should work"));
5228
5229 MI_DestinationOptions clonedOptions = MI_DESTINATIONOPTIONS_NULL;
5230 krisbash 1.1 if (NitsCompare(MI_DestinationOptions_Clone(&options, &clonedOptions), MI_RESULT_OK, PAL_T("MI_DestinationOptions_Clone returns OK")) &&
5231 NitsAssert(clonedOptions.ft != NULL, PAL_T("MI_DestinationOptions function table should not be NULL")))
5232 {
5233 MI_DestinationOptions_ReadOperations_Internal(clonedOptions, creds, true);
5234 MI_DestinationOptions_Delete(&clonedOptions);
5235 }
5236 }
5237 #if defined (_MSC_VER)
5238 #pragma prefast(push)
5239 #pragma prefast(disable: 6011)
5240 #endif
5241 options.ft->Delete(NULL);
5242 #if defined (_MSC_VER)
5243 #pragma prefast(pop)
5244 #endif
5245 MI_DestinationOptions_Delete(&options);
5246 }
5247 }
5248 NitsEndTest
5249
5250 void MI_SubscriptionDeliveryOptions_ReadOperations_Internal(
5251 krisbash 1.1 MI_SubscriptionDeliveryOptions& options,
5252 MI_UserCredentials& creds,
5253 bool cloned = false)
5254 {
5255 MI_SubscriptionDeliveryOptions *nullOptions = NULL;
5256 const MI_Char *nullString = NULL;
5257 const MI_Char **nullStringPtr = NULL;
5258 MI_Uint32 *nullNumberPtr = 0;
5259 MI_Uint32 *nullIndex = 0;
5260 MI_Uint32 index = 0;
5261 MI_Value *nullMIValuePtr = NULL;
5262 MI_Type *nullMITypePtr = 0;
5263 MI_Uint32 flag = 0;
5264
5265 // Read string
5266 {
5267 const MI_Char * stringValue = NULL;
5268 const MI_Char * optionName = PAL_T("option1");
5269 NitsCompare(options.ft->GetString(&options, optionName, &stringValue, nullIndex, 0), MI_RESULT_OK, PAL_T("GetString should work"));
5270 NitsCompare(options.ft->GetString(&options, optionName, &stringValue, &index, &flag), MI_RESULT_OK, PAL_T("GetString should work"));
5271 NitsCompareString(stringValue, PAL_T("value1"), PAL_T("GetString should work"));
5272 krisbash 1.1 if (!cloned) NitsCompare(index, 0, PAL_T("GetString should work"));
5273
5274 NitsCompare(options.ft->GetString(&options, PAL_T("option2"), &stringValue, nullIndex, 0), MI_RESULT_TYPE_MISMATCH, PAL_T("GetString should return MI_RESULT_TYPE_MISMATCH"));
5275 NitsCompare(options.ft->GetString(&options, PAL_T("optionbla"), &stringValue, nullIndex, 0), MI_RESULT_NO_SUCH_PROPERTY, PAL_T("GetString should return MI_RESULT_NOT_FOUND"));
5276 NitsCompare(options.ft->GetString(nullOptions, optionName, &stringValue, 0, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetString should fail"));
5277 NitsCompare(options.ft->GetString(&options, nullString, &stringValue, 0, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetString should fail"));
5278 NitsCompare(options.ft->GetString(&options, optionName, nullStringPtr, 0, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetString should fail"));
5279 }
5280 // Read number
5281 {
5282 MI_Uint32 int32Value = 0;
5283 const MI_Char * optionName = PAL_T("option2");
5284 NitsCompare(options.ft->GetNumber(&options, optionName, &int32Value, nullIndex, 0), MI_RESULT_OK, PAL_T("GetNumber should work"));
5285 NitsCompare(options.ft->GetNumber(&options, optionName, &int32Value, &index, &flag), MI_RESULT_OK, PAL_T("GetNumber should work"));
5286 NitsCompare(int32Value, 33, PAL_T("GetNumber should work"));
5287 if (!cloned) NitsCompare(index, 1, PAL_T("GetNumber should work"));
5288
5289 NitsCompare(options.ft->GetNumber(&options, PAL_T("option1"), &int32Value, nullIndex, 0), MI_RESULT_TYPE_MISMATCH, PAL_T("GetNumber return MI_RESULT_TYPE_MISMATCH"));
5290 NitsCompare(options.ft->GetNumber(&options, PAL_T("optionBla"), &int32Value, nullIndex, 0), MI_RESULT_NO_SUCH_PROPERTY, PAL_T("GetNumber return MI_RESULT_NOT_FOUND"));
5291 NitsCompare(options.ft->GetNumber(nullOptions, optionName, &int32Value, 0, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetNumber should fail"));
5292 NitsCompare(options.ft->GetNumber(&options, nullString, &int32Value, 0, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetNumber should fail"));
5293 krisbash 1.1 NitsCompare(options.ft->GetNumber(&options, optionName, nullNumberPtr, 0, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetNumber should fail"));
5294 }
5295 // Read datetime
5296 {
5297 MI_Datetime datetimeRead = {0};
5298 MI_Datetime * nullDatetimeRead = (MI_Datetime *)0;
5299 const MI_Char * optionName = PAL_T("option3");
5300
5301 NitsCompare(options.ft->GetDateTime(&options, optionName, &datetimeRead, nullIndex, 0), MI_RESULT_OK, PAL_T("GetDateTime should work"));
5302 NitsCompare(options.ft->GetDateTime(&options, optionName, &datetimeRead, &index, &flag), MI_RESULT_OK, PAL_T("GetDateTime should work"));
5303 if (!cloned) NitsCompare(index, 2, PAL_T("GetDateTime should work"));
5304 NitsCompare(datetimeRead.isTimestamp, MI_TRUE, PAL_T("GetDateTime should work"));
5305 NitsCompare(datetimeRead.u.timestamp.day, 10, PAL_T("GetDateTime should work"));
5306 NitsCompare(datetimeRead.u.timestamp.hour, 11, PAL_T("GetDateTime should work"));
5307 NitsCompare(datetimeRead.u.timestamp.minute, 12, PAL_T("GetDateTime should work"));
5308 NitsCompare(datetimeRead.u.timestamp.second, 13, PAL_T("GetDateTime should work"));
5309 NitsCompare(datetimeRead.u.timestamp.microseconds, 14, PAL_T("GetDateTime should work"));
5310
5311 NitsCompare(options.ft->GetDateTime(&options, PAL_T("option1"), &datetimeRead, nullIndex, 0), MI_RESULT_TYPE_MISMATCH, PAL_T("GetDateTime return MI_RESULT_TYPE_MISMATCH"));
5312 NitsCompare(options.ft->GetDateTime(&options, PAL_T("optionBla"), &datetimeRead, nullIndex, 0), MI_RESULT_NO_SUCH_PROPERTY, PAL_T("GetDateTime return MI_RESULT_NOT_FOUND"));
5313
5314 krisbash 1.1 NitsCompare(options.ft->GetDateTime(nullOptions, optionName, &datetimeRead, 0, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetDateTime should fail"));
5315 NitsCompare(options.ft->GetDateTime(&options, nullString, &datetimeRead, 0, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetDateTime should fail"));
5316 NitsCompare(options.ft->GetDateTime(&options, optionName, nullDatetimeRead, 0, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetDateTime should fail"));
5317 }
5318 // Read interval
5319 {
5320 MI_Interval intervalRead = {0};
5321 MI_Interval * nullIntervalRead = (MI_Interval *)0;
5322 const MI_Char * optionName = PAL_T("option4");
5323 NitsCompare(options.ft->GetInterval(&options, optionName, &intervalRead, nullIndex, 0), MI_RESULT_OK, PAL_T("GetInterval should work"));
5324 NitsCompare(options.ft->GetInterval(&options, optionName, &intervalRead, &index, &flag), MI_RESULT_OK, PAL_T("GetInterval should work"));
5325 if (!cloned) NitsCompare(index, 3, PAL_T("GetInterval should work"));
5326 NitsCompare(intervalRead.days, 8, PAL_T("GetInterval should work"));
5327 NitsCompare(intervalRead.hours, 9, PAL_T("GetInterval should work"));
5328 NitsCompare(intervalRead.minutes, 10, PAL_T("GetInterval should work"));
5329 NitsCompare(intervalRead.seconds, 11, PAL_T("GetInterval should work"));
5330 NitsCompare(intervalRead.microseconds, 12, PAL_T("GetInterval should work"));
5331
5332 NitsCompare(options.ft->GetInterval(&options, PAL_T("option1"), &intervalRead, nullIndex, 0), MI_RESULT_TYPE_MISMATCH, PAL_T("GetInterval return MI_RESULT_TYPE_MISMATCH"));
5333 // Option3 is a datetime not interval
5334 NitsCompare(options.ft->GetInterval(&options, PAL_T("option3"), &intervalRead, nullIndex, 0), MI_RESULT_TYPE_MISMATCH, PAL_T("GetInterval return MI_RESULT_TYPE_MISMATCH"));
5335 krisbash 1.1 NitsCompare(options.ft->GetInterval(&options, PAL_T("optionBla"), &intervalRead, nullIndex, 0), MI_RESULT_NO_SUCH_PROPERTY, PAL_T("GetInterval return MI_RESULT_NOT_FOUND"));
5336
5337 NitsCompare(options.ft->GetInterval(nullOptions, optionName, &intervalRead, 0, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetInterval should fail"));
5338 NitsCompare(options.ft->GetInterval(&options, nullString, &intervalRead, 0, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetInterval should fail"));
5339 NitsCompare(options.ft->GetInterval(&options, optionName, nullIntervalRead, 0, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetInterval should fail"));
5340 }
5341 // GetOptionCount
5342 {
5343 MI_Uint32 optionCount = 0;
5344 NitsCompare(options.ft->GetOptionCount(nullOptions, &optionCount), MI_RESULT_INVALID_PARAMETER, PAL_T("GetOptionCount should fail"));
5345 NitsCompare(options.ft->GetOptionCount(&options, nullNumberPtr), MI_RESULT_INVALID_PARAMETER, PAL_T("GetOptionCount should fail"));
5346
5347 NitsCompare(options.ft->GetOptionCount(&options, &optionCount), MI_RESULT_OK, PAL_T("GetOptionCount should success"));
5348 NitsCompare(optionCount, 4, PAL_T("GetOptionCount should success"));
5349 }
5350 // GetOptionAt
5351 if (!cloned)
5352 {
5353 MI_Value value = {0};
5354 MI_Type type = MI_BOOLEAN;
5355 const MI_Char * optionName = NULL;
5356 krisbash 1.1 NitsCompare(options.ft->GetOptionAt(nullOptions, 0, &optionName, &value, nullMITypePtr, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetOptionAt should fail"));
5357 NitsCompare(options.ft->GetOptionAt(&options, 0, &optionName, &value, nullMITypePtr, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetOptionAt should fail"));
5358 NitsCompare(options.ft->GetOptionAt(&options, 0, nullStringPtr, nullMIValuePtr, nullMITypePtr, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetOptionAt should fail"));
5359 NitsCompare(options.ft->GetOptionAt(&options, 0, &optionName, &value, nullMITypePtr, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetOptionAt should fail"));
5360
5361 NitsCompare(options.ft->GetOptionAt(&options, 0x100, &optionName, &value, &type, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetOptionAt should return MI_RESULT_NOT_FOUND"));
5362
5363 NitsCompare(options.ft->GetOptionAt(&options, 0, &optionName, &value, &type, &flag), MI_RESULT_OK, PAL_T("GetOptionAt should success"));
5364 if (NitsCompare(type, MI_STRING, PAL_T("GetOptionAt should success")))
5365 NitsCompareString(value.string, PAL_T("value1"), PAL_T("GetOptionAt should success"));
5366 }
5367 // GetOption
5368 {
5369 MI_Value value = {0};
5370 MI_Type type = MI_BOOLEAN;
5371 const MI_Char * optionName = PAL_T("option1");
5372 NitsCompare(options.ft->GetOption(nullOptions, optionName, &value, nullMITypePtr, 0, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetOption should fail"));
5373 NitsCompare(options.ft->GetOption(&options, nullString, &value, nullMITypePtr, 0, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetOption should fail"));
5374 NitsCompare(options.ft->GetOption(&options, optionName, nullMIValuePtr, nullMITypePtr, 0, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetOption should fail"));
5375 NitsCompare(options.ft->GetOption(&options, optionName, &value, nullMITypePtr, 0, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetOption should fail"));
5376 NitsCompare(options.ft->GetOption(&options, PAL_T("optionbla"), &value, &type, &index, 0), MI_RESULT_NO_SUCH_PROPERTY, PAL_T("GetOption should return MI_RESULT_NOT_FOUND"));
5377 krisbash 1.1
5378 NitsCompare(options.ft->GetOption(&options, optionName, &value, &type, &index, &flag), MI_RESULT_OK, PAL_T("GetOption should success"));
5379 if (NitsCompare(type, MI_STRING, PAL_T("GetOption should success")))
5380 NitsCompareString(value.string, PAL_T("value1"), PAL_T("GetOption should success"));
5381 if (!cloned) NitsCompare(index, 0, PAL_T("GetOption should success"));
5382 }
5383 // GetCredentials
5384 {
5385 MI_Uint32 credentialCount = 0;
5386 NitsCompare(options.ft->GetCredentialsCount(&options, &credentialCount), MI_RESULT_OK, PAL_T("GetCredentialsCount should work"));
5387 NitsCompare(credentialCount, 1, PAL_T("GetCredentialsCount should work"));
5388
5389 MI_UserCredentials credential = {0};
5390 const MI_Char *credentialOptionName = NULL;
5391 NitsCompare(options.ft->GetCredentialsAt(&options, 0, &credentialOptionName, &credential, &flag), MI_RESULT_OK, PAL_T("GetCredentialsAt should work"));
5392 NitsCompareString(credential.authenticationType, creds.authenticationType, PAL_T("GetCredentialsAt authenticationType should correct"));
5393 NitsCompareString(credential.credentials.usernamePassword.domain, creds.credentials.usernamePassword.domain, PAL_T("GetCredentialsAt domain should correct"));
5394 NitsCompareString(credential.credentials.usernamePassword.password, PAL_T("******"), PAL_T("GetCredentialsAt password should correct"));
5395 NitsCompareString(credential.credentials.usernamePassword.username, creds.credentials.usernamePassword.username, PAL_T("GetCredentialsAt username should correct"));
5396 NitsCompareString(credentialOptionName, PAL_T("option5"), PAL_T("GetCredentialsAt option name should correct"));
5397
5398 krisbash 1.1 MI_Uint32 passwordLength = 0;
5399 MI_Char password[9];
5400 MI_Result r = options.ft->GetCredentialsPasswordAt(&options, 0, &credentialOptionName, password, 9, &passwordLength, &flag);
5401 NitsCompare(r, MI_RESULT_OK, PAL_T("GetCredentialsPasswordAt should work"));
5402 if (r == MI_RESULT_OK)
5403 {
5404 NitsCompareString(credentialOptionName, PAL_T("option5"), PAL_T("GetCredentialsPasswordAt option name should correct"));
5405
5406 #ifdef _PREFAST_
5407 #pragma prefast(push)
5408 #pragma prefast(disable:26035)
5409 #endif
5410 NitsCompareString(password, creds.credentials.usernamePassword.password, PAL_T("GetCredentialsPasswordAt should work"));
5411 #ifdef _PREFAST_
5412 #pragma prefast(pop)
5413 #endif
5414
5415 NitsCompare(passwordLength, 9, PAL_T("GetCredentialsPasswordAt should work"));
5416 }
5417 NitsCompare(options.ft->GetCredentialsPasswordAt(&options, 1, &credentialOptionName, password, 9, &passwordLength, 0), MI_RESULT_NO_SUCH_PROPERTY, PAL_T("GetCredentialsPasswordAt should return MI_RESULT_NOT_FOUND"));
5418 NitsCompare(options.ft->GetCredentialsPasswordAt(nullOptions, 0, &credentialOptionName, password, 9, &passwordLength, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetCredentialsPasswordAt should return MI_RESULT_INVALID_PARAMETER"));
5419 krisbash 1.1 NitsCompare(options.ft->GetCredentialsPasswordAt(&options, 0, nullStringPtr, password, 9, &passwordLength, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetCredentialsPasswordAt should return MI_RESULT_INVALID_PARAMETER"));
5420 NitsCompare(options.ft->GetCredentialsPasswordAt(&options, 0, &credentialOptionName, password, 9, nullNumberPtr, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetCredentialsPasswordAt should return MI_RESULT_INVALID_PARAMETER"));
5421 NitsCompare(options.ft->GetCredentialsPasswordAt(&options, 0, &credentialOptionName, password, 8, &passwordLength, 0), MI_RESULT_FAILED, PAL_T("GetCredentialsPasswordAt should return MI_RESULT_FAILED"));
5422
5423 MI_UserCredentials *nullCredentials = NULL;
5424 NitsCompare(options.ft->GetCredentialsAt(&options, 1, &credentialOptionName, &credential, 0), MI_RESULT_NO_SUCH_PROPERTY, PAL_T("GetCredentialsAt should return MI_RESULT_NOT_FOUND"));
5425 NitsCompare(options.ft->GetCredentialsAt(nullOptions, 0, &credentialOptionName, &credential, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetCredentialsAt should return MI_RESULT_INVALID_PARAMETER"));
5426 NitsCompare(options.ft->GetCredentialsAt(&options, 0, nullStringPtr, &credential, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetCredentialsAt should return MI_RESULT_INVALID_PARAMETER"));
5427 NitsCompare(options.ft->GetCredentialsAt(&options, 0, &credentialOptionName, nullCredentials, 0), MI_RESULT_INVALID_PARAMETER, PAL_T("GetCredentialsAt should return MI_RESULT_INVALID_PARAMETER"));
5428 }
5429 }
5430
5431 NitsTest1(MI_SubscriptionDeliveryOptions_ReadOperations,
5432 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1)
5433 {
5434 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
5435 ResetRuntimeTestData(testData);
5436 MI_Application *application= &testData->application;
5437
5438 MI_SubscriptionDeliveryOptions options = MI_SUBSCRIPTIONDELIVERYOPTIONS_NULL;
5439 if (NitsCompare(MI_Application_NewSubscriptionDeliveryOptions(application, MI_SubscriptionDeliveryType_Push, &options), MI_RESULT_OK, PAL_T("NewSubscribeDeliveryOptions should succeed")))
5440 krisbash 1.1 {
5441 NitsCompare(options.ft->SetString(&options, PAL_T("option1"), PAL_T("value1"), 0), MI_RESULT_OK, PAL_T("SetString should work"));
5442 NitsCompare(options.ft->SetNumber(&options, PAL_T("option2"), 33, 0), MI_RESULT_OK, PAL_T("SetNumber should work"));
5443 MI_Datetime datetime = {0};
5444 {
5445 datetime.isTimestamp = true;
5446 datetime.u.timestamp.day = 10;
5447 datetime.u.timestamp.hour = 11;
5448 datetime.u.timestamp.minute = 12;
5449 datetime.u.timestamp.second = 13;
5450 datetime.u.timestamp.microseconds = 14;
5451 NitsCompare(options.ft->SetDateTime(&options, PAL_T("option3"), &datetime, 0), MI_RESULT_OK, PAL_T("SetDateTime should work"));
5452 }
5453 MI_Interval interval = {0};
5454 {
5455 interval.days = 8;
5456 interval.hours = 9;
5457 interval.minutes = 10;
5458 interval.seconds = 11;
5459 interval.microseconds = 12;
5460 NitsCompare(options.ft->SetInterval(&options, PAL_T("option4"), &interval, 0), MI_RESULT_OK, PAL_T("SetInterval should work"));
5461 krisbash 1.1 }
5462 MI_UserCredentials creds = { 0 };
5463 {
5464 creds.authenticationType = MI_AUTH_TYPE_BASIC;
5465 creds.credentials.usernamePassword.username = PAL_T("username");
5466 creds.credentials.usernamePassword.domain = PAL_T("domain");
5467 creds.credentials.usernamePassword.password = PAL_T("password");
5468 NitsCompare(options.ft->AddCredentials(&options, PAL_T("option5"), &creds, 0), MI_RESULT_OK, PAL_T("AddCredentials should work"));
5469 }
5470
5471 MI_SubscriptionDeliveryOptions_ReadOperations_Internal(options, creds);
5472 MI_SubscriptionDeliveryOptions_Delete(&options);
5473 }
5474 }
5475 NitsEndTest
5476
5477 NitsTest1(MI_SubscriptionDeliveryOptions_CloneTest,
5478 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1)
5479 {
5480 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
5481 ResetRuntimeTestData(testData);
5482 krisbash 1.1 MI_Application *application = &testData->application;
5483
5484 MI_SubscriptionDeliveryOptions options = MI_SUBSCRIPTIONDELIVERYOPTIONS_NULL;
5485 if (NitsCompare(MI_Application_NewSubscriptionDeliveryOptions(application, MI_SubscriptionDeliveryType_Push, &options), MI_RESULT_OK, PAL_T("NewSubscribeDeliveryOptions should succeed")))
5486 {
5487 NitsCompare(options.ft->SetString(&options, PAL_T("option1"), PAL_T("value1"), 0), MI_RESULT_OK, PAL_T("SetString should work"));
5488 NitsCompare(options.ft->SetNumber(&options, PAL_T("option2"), 33, 0), MI_RESULT_OK, PAL_T("SetNumber should work"));
5489 MI_Datetime datetime = {0};
5490 {
5491 datetime.isTimestamp = true;
5492 datetime.u.timestamp.day = 10;
5493 datetime.u.timestamp.hour = 11;
5494 datetime.u.timestamp.minute = 12;
5495 datetime.u.timestamp.second = 13;
5496 datetime.u.timestamp.microseconds = 14;
5497 NitsCompare(options.ft->SetDateTime(&options, PAL_T("option3"), &datetime, 0), MI_RESULT_OK, PAL_T("SetDateTime should work"));
5498 }
5499 MI_Interval interval = {0};
5500 {
5501 interval.days = 8;
5502 interval.hours = 9;
5503 krisbash 1.1 interval.minutes = 10;
5504 interval.seconds = 11;
5505 interval.microseconds = 12;
5506 NitsCompare(options.ft->SetInterval(&options, PAL_T("option4"), &interval, 0), MI_RESULT_OK, PAL_T("SetInterval should work"));
5507 }
5508 MI_UserCredentials creds = { 0 };
5509 {
5510 creds.authenticationType = MI_AUTH_TYPE_BASIC;
5511 creds.credentials.usernamePassword.username = PAL_T("username");
5512 creds.credentials.usernamePassword.domain = PAL_T("domain");
5513 creds.credentials.usernamePassword.password = PAL_T("password");
5514 NitsCompare(options.ft->AddCredentials(&options, PAL_T("option5"), &creds, 0), MI_RESULT_OK, PAL_T("AddCredentials should work"));
5515 }
5516 MI_SubscriptionDeliveryOptions clonedOptions = MI_SUBSCRIPTIONDELIVERYOPTIONS_NULL;
5517 if (NitsCompare(MI_SubscriptionDeliveryOptions_Clone(&options, &clonedOptions), MI_RESULT_OK, PAL_T("MI_SubscriptionDeliveryOptions_Clone returns OK")) &&
5518 NitsAssert(clonedOptions.ft != NULL, PAL_T("MI_SubscriptionDeliveryOptions function table should not be NULL")))
5519 {
5520 NitsCompare((MI_Uint32)options.reserved1, (MI_Uint32)clonedOptions.reserved1, PAL_T("Cloned options should has same deliveryType"));
5521 MI_SubscriptionDeliveryOptions_ReadOperations_Internal(clonedOptions, creds, true);
5522 MI_SubscriptionDeliveryOptions_Delete(&clonedOptions);
5523 }
5524 krisbash 1.1 MI_SubscriptionDeliveryOptions_Delete(&options);
5525 }
5526 }
5527 NitsEndTest
5528
5529 NitsTest1(MI_SubscriptionDeliveryOptions_StronglyTypedCheck,
5530 SetupDefaultApplication, g_RuntimeApplicationSetup_Test1)
5531 {
5532 RuntimeTestData *testData = NitsContext()->_SetupDefaultApplication->_BaseSetup->_RuntimeTestData;
5533 ResetRuntimeTestData(testData);
5534 MI_Application *application = &testData->application;
5535
5536 MI_SubscriptionDeliveryOptions sdo = MI_SUBSCRIPTIONDELIVERYOPTIONS_NULL;
5537
5538 if (NitsCompare(MI_Application_NewSubscriptionDeliveryOptions(application, MI_SubscriptionDeliveryType_Pull, &sdo), MI_RESULT_OK, PAL_T("Subscribe delivery options created")))
5539 {
5540 MI_Interval value = {0};
5541 value.days = 1;
5542 NitsCompare(MI_SubscriptionDeliveryOptions_GetDeliveryRetryInterval(&sdo, &value), MI_RESULT_NO_SUCH_PROPERTY, PAL_T("Get delivery retry interval should be not found"));
5543 NitsCompare(MI_SubscriptionDeliveryOptions_SetDeliveryRetryInterval(&sdo, &value), MI_RESULT_OK, PAL_T("Set delivery retry interval"));
5544 NitsCompare(MI_SubscriptionDeliveryOptions_GetDeliveryRetryInterval(&sdo, &value), MI_RESULT_OK, PAL_T("Get delivery retry interval should work"));
5545 krisbash 1.1 NitsCompare(value.days, 1, PAL_T("validate get value same as set"));
5546
5547 NitsCompare(MI_SubscriptionDeliveryOptions_Delete(&sdo), MI_RESULT_OK, PAL_T("subscribe delivery options delete failed"));
5548 }
5549 }
5550 NitsEndTest
5551 #if 0
5552 NitsTest(Session_GetInstance_Sync_OperationAck)
5553 {
5554 MI_Application application = MI_APPLICATION_NULL;
5555 MI_Session session = MI_SESSION_NULL;
5556 MI_Operation operation = MI_OPERATION_NULL;
5557
5558 if (NitsCompare(MI_Application_Initialize(0, NULL, NULL, &application), MI_RESULT_OK, PAL_T("MI_Application_Initialize returns OK")) &&
5559 NitsAssert(application.ft != NULL, PAL_T("MI_Application function table should not be NULL")))
5560 {
5561 MI_Instance *instance = NULL;
5562 if (NitsAssert(MI_Application_NewInstance(&application, PAL_T("Win32_OperatingSystem"), NULL, &instance) == MI_RESULT_OK, PAL_T("failed to create instance")))
5563 {
5564 if (NitsCompare(MI_Application_NewSession(&application, NULL, NULL, NULL, NULL, NULL, &session), MI_RESULT_OK, PAL_T("MI_Application_NewSession returns OK")) &&
5565 NitsAssert(session.ft != NULL, PAL_T("MI_Session function table should not be NULL")))
5566 krisbash 1.1 {
5567 MI_Session_GetInstance(&session, MI_OPERATIONFLAGS_REPORT_OPERATION_STARTED, NULL, PAL_T("root\\cimv2"), instance, NULL, &operation);
5568 NitsAssert(operation.ft != NULL, PAL_T("operation function table null"));
5569
5570 const MI_Instance *newInst = NULL;
5571 MI_Boolean moreResults = MI_TRUE;
5572 MI_Result miResult;
5573 MI_Operation_GetInstance(&operation, &newInst, &moreResults, &miResult, NULL, NULL);
5574 if (NitsCompare(moreResults, MI_TRUE, PAL_T("result ACK should mean more results available")))
5575 {
5576 MI_Uint32 count = 0;
5577 NitsAssert(newInst == NULL, PAL_T("First result should be NULL as it is an ACK"));
5578 NitsCompare(miResult, MI_RESULT_OK, PAL_T("Should get success for ACK"));
5579 while (moreResults)
5580 {
5581 MI_Operation_GetInstance(&operation, &newInst, &moreResults, &miResult, NULL, NULL);
5582 if (NitsCompare(miResult, MI_RESULT_OK, PAL_T("operation should succeed")))
5583 count++;
5584 }
5585 NitsCompare(count, 1, PAL_T("singleton so should be only 1 real response"));
5586 }
5587 krisbash 1.1 MI_Operation_Close(&operation);
5588
5589 MI_Session_Close(&session, NULL, NULL);
5590 }
5591 MI_Instance_Delete(instance);
5592 }
5593
5594 MI_Application_Close(&application);
5595 }
5596
5597 }
5598 NitsEndTest
5599 #endif
5600
5601 /*
5602 **==============================================================================
5603 **
5604 ** Test structure for MIAPI end to end test
5605 **
5606 **==============================================================================
5607 */
5608 krisbash 1.1 struct MIAPITestStruct
5609 {
5610 /* Configurations */
5611 const MI_Char* nameSpace; /* target namespace */
5612 const MI_Char* className;
5613
5614 /* expected results */
5615 MI_Uint32 expectedInstanceCount;
5616
5617 InstanceOperationStruct ios;
5618 };
5619
5620 /*
5621 **==============================================================================
5622 **
5623 ** Setup function, it is called before running each test case
5624 ** NOTE: for "nits -fault" run, this function will be called once and only once
5625 ** for each test case.
5626 **
5627 **==============================================================================
5628 */
5629 krisbash 1.1 static void _setup(_In_ MIAPITestStruct* mts)
5630 {
5631 MI_Application *application = &mts->ios.app;
5632 mts->ios.app.ft = NULL;
5633 if (NitsCompare(MI_Application_Initialize(0, NULL, NULL, application),
5634 MI_RESULT_OK,
5635 PAL_T("MI_Application_Initialize returns OK")))
5636 {
5637 NitsAssert(application->ft != NULL,
5638 PAL_T("MI_Application_Initialize returns object with function table"));
5639 if (application->ft == NULL)
5640 return;
5641 }
5642 else
5643 return;
5644
5645 mts->ios.session.ft = NULL;
5646 if (NitsCompare(MI_Application_NewSession(&mts->ios.app, NULL, NULL, NULL, NULL, NULL, &mts->ios.session),
5647 MI_RESULT_OK,
5648 PAL_T("MI_Application_NewSession returns OK")))
5649 {
5650 krisbash 1.1 NitsAssert(mts->ios.session.ft != NULL,
5651 PAL_T("MI_Application_NewSession returns object with function table"));
5652 if (mts->ios.session.ft == NULL)
5653 return;
5654 }
5655 else
5656 return;
5657
5658 mts->ios.finished = 0;
5659 }
5660
5661 NitsSetup0(MIAPITest_Setup, MIAPITestStruct)
5662 /*
5663 * MI_Application_Intialize create global log file handler _os
5664 * MI_Application_Close closes it,
5665 * thus the test case needs to make sure not close _os while
5666 * there are active MI_Application(s) objects
5667 */
5668 NitsAssert( StartServer_Assert() == MI_RESULT_OK, PAL_T(" Failed to start server "));
5669 _setup(NitsContext()->_MIAPITestStruct);
5670 NitsEndSetup
5671 krisbash 1.1
5672 /*
5673 **==============================================================================
5674 **
5675 ** Cleanup function, it is called after run each test case
5676 ** NOTE: for "nits -fault" run, this function will be called once and only once
5677 ** for each test case.
5678 **
5679 **==============================================================================
5680 */
5681 static void _cleanup(_In_ MIAPITestStruct* mts)
5682 {
5683 MI_Application *application = &mts->ios.app;
5684 MI_Session *session = &mts->ios.session;
5685
5686 if (NULL != session->ft)
5687 NitsCompare(MI_Session_Close(session, NULL, NULL), MI_RESULT_OK, PAL_T("Failed to close MI_Session"));
5688 if (NULL != application->ft)
5689 NitsCompare(MI_Application_Close(application), MI_RESULT_OK, PAL_T("Failed to close MI_Application"));
5690 }
5691
5692 krisbash 1.1 NitsCleanup(MIAPITest_Setup)
5693 /*
5694 * MI_Application_Intialize create global log file handler _os
5695 * MI_Application_Close closes it,
5696 * thus the test case needs to make sure not close _os while
5697 * there are active MI_Application(s) objects
5698 */
5699 NitsAssert( StopServer_Assert() == MI_RESULT_OK, PAL_T("Failed to stop server"));
5700 _cleanup (NitsContext()->_MIAPITestStruct);
5701 NitsEndCleanup
5702
5703 /*
5704 **==============================================================================
5705 **
5706 ** Default test structure
5707 **
5708 **==============================================================================
5709 */
5710 static struct MIAPITestStruct MTS1 = {
5711 MI_T("test/cpp"),
5712 MI_T("X_SmallNumber"),
5713 krisbash 1.1 0,
5714 {MI_FALSE, 0, 0}
5715 };
5716
5717
5718 /*
5719 **==============================================================================
5720 **
5721 ** Enumerate instance and validate results
5722 **
5723 **==============================================================================
5724 */
5725 static MI_Boolean _Enumerate_Validate(_In_ MIAPITestStruct* mts)
5726 {
5727 MI_Result miResult;
5728
5729 /* Cleanup actual result */
5730 mts->ios.count = 0;
5731
5732 miResult = EnumerateInstance(&mts->ios, mts->nameSpace, mts->className);
5733 NitsCompare(miResult, MI_RESULT_OK, PAL_T("Unexpected enumerate result"));
5734 krisbash 1.1
5735 /* Validate subscribe result */
5736 NitsCompare(mts->ios.count, mts->expectedInstanceCount, PAL_T("Unexpected instance count"));
5737
5738 if (mts->ios.count == mts->expectedInstanceCount)
5739 return MI_TRUE;
5740 return MI_FALSE;
5741 }
5742
5743
5744 /*
5745 **==============================================================================
5746 **
5747 ** For following tests, each test case needs to run twice w.r.t.
5748 ** sync and async consume result instances
5749 **
5750 ** To avoid the duplicate test code, following structure was introduced to
5751 ** indicate the way of deliver indication
5752 **
5753 **==============================================================================
5754 */
5755 krisbash 1.1 struct Sync_Struct
5756 {
5757 MI_Boolean sync;
5758 };
5759
5760 NitsSetup1(ConsumeInstance_Sync, Sync_Struct, MIAPITest_Setup, MTS1)
5761 NitsContext()->_Sync_Struct->sync = MI_TRUE;
5762 NitsEndSetup
5763
5764 NitsSetup1(ConsumeInstance_Async, Sync_Struct, MIAPITest_Setup, MTS1)
5765 NitsContext()->_Sync_Struct->sync = MI_FALSE;
5766 NitsEndSetup
5767
5768 NitsSplit2(ConsumeInstance_Approach, Sync_Struct, ConsumeInstance_Sync, ConsumeInstance_Async)
5769 NitsEndSplit
5770
5771 typedef struct _ThreadStruct
5772 {
5773 MIAPITestStruct mts;
5774 Sem sem;
5775 MI_Uint32* threadCount;
5776 krisbash 1.1 Thread threadHandle;
5777 }ThreadStruct;
5778
5779 NITS_EXTERN_C PAL_Uint32 THREAD_API EnumerateInstanceProc(void* param)
5780 {
5781 ThreadStruct* ts = (ThreadStruct*)param;
5782 if ( MI_TRUE == _Enumerate_Validate(&ts->mts))
5783 {
5784 *ts->threadCount = (*ts->threadCount) + 1;
5785 }
5786 Sem_Post(&ts->sem, 1);
5787 return 0;
5788 }
5789
5790 #if !defined(_MSC_VER)
5791
5792 NitsTest1(Test_SingleThread_Enumerate, ConsumeInstance_Approach, ConsumeInstance_ApproachDefaults)
5793 {
5794 NitsDisableFaultSim;
5795 MIAPITestStruct* mts = NitsContext()->_ConsumeInstance_Approach->_ConsumeInstance_Sync->_MIAPITest_Setup->_MIAPITestStruct;
5796 MI_Boolean sync = NitsContext()->_ConsumeInstance_Approach->_Sync_Struct->sync;
5797 krisbash 1.1 mts->ios.sync = sync;
5798 mts->ios.count = 0;
5799 mts->expectedInstanceCount = 1000;
5800 _Enumerate_Validate(mts);
5801 }
5802 NitsEndTest
5803
5804
5805 NitsTest1(Test_MultiThreads_Enumerate, ConsumeInstance_Approach, ConsumeInstance_ApproachDefaults)
5806 {
5807 NitsDisableFaultSim;
5808 MIAPITestStruct* mts = NitsContext()->_ConsumeInstance_Approach->_ConsumeInstance_Sync->_MIAPITest_Setup->_MIAPITestStruct;
5809 MI_Boolean sync = NitsContext()->_ConsumeInstance_Approach->_Sync_Struct->sync;
5810 mts->ios.sync = sync;
5811 mts->ios.count = 0;
5812 mts->expectedInstanceCount = 1000;
5813
5814 static const MI_Uint32 sthreadCount = 8;
5815 ThreadStruct* tsarray[sthreadCount];
5816 MI_Uint32 successThreadCount = 0;
5817 for (MI_Uint32 i = 0; i < sthreadCount; i++)
5818 krisbash 1.1 {
5819 ThreadStruct* ts = (ThreadStruct*)PAL_Malloc(sizeof(ThreadStruct));
5820 tsarray[i] = NULL;
5821 if (ts)
5822 {
5823 Sem_Init(&ts->sem, SEM_USER_ACCESS_ALLOW_ALL, 0);
5824 ts->mts = *mts;
5825 ts->threadCount = &successThreadCount;
5826 int code = Thread_CreateJoinable(&ts->threadHandle,
5827 EnumerateInstanceProc,
5828 NULL, (void*)ts);
5829 NitsAssert( (code == 0), PAL_T("failed to create thread"));
5830 if (code == 0)
5831 tsarray[i] = ts;
5832 else
5833 PAL_Free(ts);
5834 }
5835 else
5836 NitsAssert(0, PAL_T("failed to create ThreadStruct"));
5837 }
5838 for (MI_Uint32 i = 0; i < sthreadCount; i++)
5839 krisbash 1.1 {
5840 if (tsarray[i])
5841 {
5842 PAL_Uint32 result = 0;
5843
5844 Sem_Wait(&tsarray[i]->sem);
5845 Sem_Destroy(&tsarray[i]->sem);
5846
5847 Thread_Join(&tsarray[i]->threadHandle, &result);
5848 Thread_Destroy(&tsarray[i]->threadHandle);
5849
5850 PAL_Free(tsarray[i]);
5851 tsarray[i] = NULL;
5852 }
5853 }
5854 NitsCompare(successThreadCount, sthreadCount, PAL_T("Some enumerate threads failed"));
5855 }
5856 NitsEndTest
5857
5858 #endif
5859
|
Return to
main.cpp
CVS log
Up to [OMI] / omi / tests / miapi