← Back to branch summary

~ubuntu-branches/ubuntu/wily/sblim-sfcb/wily

« back to all changes in this revision

Viewing changes to test/TestProviders/cmpiTestMiscProvider.c

  • Committer: Bazaar Package Importer
  • Author(s): Guillaume BOTTEX
  • Date: 2010-06-07 11:27:00 UTC
  • mfrom: (1.1.3 upstream)
  • Revision ID: james.westby@ubuntu.com-20100607112700-xcihh864agv7gigq
Tags: 1.3.8-0ubuntu1
* New upstream release
* Packaging format changed from 1.0 to 3.0 (quilt)
* Add missing man pages for getSchema and genSslCert
* Add missing binary sfcbinst2mof
* flex and unzip added as dependencies, because needed at build time by
  configure

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/TestProviders/cmpiTestMiscProvider.c
 
1
#include <stdlib.h>
 
2
#include <stdio.h>
 
3
#include <string.h>
 
4
#include <ctype.h>
 
5
#include <stdarg.h>
 
6
 
 
7
#include "cmpidt.h"
 
8
#include "cmpift.h"
 
9
#include "cmpimacs.h"
 
10
 
 
11
#define _ClassName "TestCMPI_Method"
 
12
#define _ClassName_size strlen(_ClassName)
 
13
#define _Namespace    "root/cimv2"
 
14
#define _PersonClass  "CMPI_TEST_Person"
 
15
#  define CMObjectPathToString(p,rc) \
 
16
       ((p)->ft->toString((p),(rc)))
 
17
#  define CMGetMessage(b,id,def,rc,parms) \
 
18
       ((b)->eft->getMessage((b),(id),(def),(rc),parms))
 
19
 
 
20
static const CMPIBroker *_broker;
 
21
 
 
22
#ifdef __GNUC__
 
23
# define UINT64_LITERAL(X) ((CMPIUint64)X##ULL)
 
24
#else
 
25
# define UINT64_LITERAL(X) ((CMPIUint64)X)
 
26
#endif
 
27
 
 
28
/* ---------------------------------------------------------------------------*/
 
29
/*                       CMPI Helper function                        */
 
30
/* ---------------------------------------------------------------------------*/
 
31
 
 
32
 
 
33
 
 
34
CMPIObjectPath * make_ObjectPath (
 
35
    const CMPIBroker *broker,
 
36
    const char *ns,
 
37
    const char *className)
 
38
{
 
39
    CMPIObjectPath *objPath = NULL;
 
40
    CMPIStatus rc = { CMPI_RC_OK, NULL };
 
41
    objPath = CMNewObjectPath (broker, ns, className, &rc);
 
42
    CMAddKey (objPath, "ElementName", (CMPIValue *) className, CMPI_chars);
 
43
    return objPath;
 
44
}
 
45
 
 
46
CMPIInstance * make_Instance (const CMPIObjectPath * op)
 
47
{
 
48
    CMPIStatus rc = { CMPI_RC_OK, NULL };
 
49
    CMPIInstance *ci = NULL;
 
50
    ci = CMNewInstance (_broker, op, &rc);
 
51
    if (rc.rc == CMPI_RC_ERR_NOT_FOUND)
 
52
    {
 
53
        return NULL;
 
54
    }
 
55
    return ci;
 
56
}
 
57
 
 
58
static int
 
59
_CMGetMessage (char **result)
 
60
{
 
61
 
 
62
  CMPIString *str = NULL;
 
63
  CMPIStatus rc = { CMPI_RC_OK, NULL };
 
64
  str =
 
65
    CMGetMessage (_broker, "Common.CIMStatusCode.CIM_ERR_SUCCESS",
 
66
                  "CIM_ERR_SUCCESS: Successful.", &rc, 0);
 
67
  if (str)
 
68
    {
 
69
      *result = strdup (CMGetCharsPtr (str,NULL));
 
70
    }
 
71
  if (rc.rc == CMPI_RC_OK)
 
72
    return 0;
 
73
  return 1;
 
74
}
 
75
 
 
76
static int
 
77
_CMLogMessage (char **result)
 
78
{
 
79
  CMPIStatus rc = { CMPI_RC_OK, NULL };
 
80
  rc.rc = CMPI_RC_OK;
 
81
  rc = CMLogMessage (_broker, 64, _ClassName, "Log message", NULL);
 
82
  if (rc.rc == CMPI_RC_ERR_NOT_SUPPORTED) {
 
83
    *result=strdup("LogMessage success");
 
84
    return 0;
 
85
  }
 
86
  return 1;
 
87
}
 
88
 
 
89
static int
 
90
_CMTraceMessage (char **result)
 
91
{
 
92
  CMPIStatus rc = { CMPI_RC_OK, NULL };
 
93
  rc.rc = CMPI_RC_OK;
 
94
  rc = CMTraceMessage (_broker, 2, NULL, NULL, NULL);
 
95
  if (rc.rc == CMPI_RC_ERR_NOT_SUPPORTED){
 
96
    *result=strdup("TraceMessage success");
 
97
    return 0;
 
98
  }
 
99
  return 1;
 
100
}
 
101
 
 
102
static int _testArrayTypes()
 
103
{
 
104
    struct array_types
 
105
    {
 
106
        CMPIType element_type;
 
107
        CMPIType typeA;
 
108
        char* typeName;
 
109
        char* typeAName;
 
110
        char* args_name;
 
111
    }types_arr[] = {
 
112
        {CMPI_uint32,
 
113
        CMPI_uint32A,
 
114
        "CMPI_uint32",
 
115
        "CMPI_uint32A",
 
116
        "CMPI_uint32_array"},
 
117
 
 
118
        {CMPI_uint16,
 
119
        CMPI_uint16A,
 
120
        "CMPI_uint16",
 
121
        "CMPI_uint16A",
 
122
        "CMPI_uint16_array"},
 
123
 
 
124
        {CMPI_uint8,
 
125
        CMPI_uint8A,
 
126
        "CMPI_uint8",
 
127
        "CMPI_uint8A",
 
128
        "CMPI_uint8_array"},
 
129
 
 
130
        {CMPI_uint64,
 
131
        CMPI_uint64A,
 
132
        "CMPI_uint64",
 
133
        "CMPI_uint64A",
 
134
        "CMPI_uint64_array"},
 
135
 
 
136
        {CMPI_sint32,
 
137
        CMPI_sint32A,
 
138
        "CMPI_sint32",
 
139
        "CMPI_sint32A",
 
140
        "CMPI_sint32_array"},
 
141
 
 
142
        {CMPI_sint16,
 
143
        CMPI_sint16A,
 
144
        "CMPI_sint16",
 
145
        "CMPI_sint16A",
 
146
        "CMPI_sint16_array"},
 
147
 
 
148
        {CMPI_sint8,
 
149
        CMPI_sint8A,
 
150
        "CMPI_sint8",
 
151
        "CMPI_sint8A",
 
152
        "CMPI_sint8_array"},
 
153
 
 
154
        {CMPI_sint64,
 
155
        CMPI_sint64A,
 
156
        "CMPI_sint64",
 
157
        "CMPI_sint64A",
 
158
        "CMPI_sint64_array"},
 
159
 
 
160
        {CMPI_real32,
 
161
        CMPI_real32A,
 
162
        "CMPI_real32",
 
163
        "CMPI_real32A",
 
164
        "CMPI_real32_array"},
 
165
 
 
166
        {CMPI_real64,
 
167
        CMPI_real64A,
 
168
        "CMPI_real64",
 
169
        "CMPI_real64A",
 
170
        "CMPI_real64_array"},
 
171
 
 
172
        {CMPI_char16,
 
173
        CMPI_char16A,
 
174
        "CMPI_char16",
 
175
        "CMPI_char16A",
 
176
        "CMPI_char16_array"},
 
177
 
 
178
        {CMPI_boolean,
 
179
        CMPI_booleanA,
 
180
        "CMPI_boolean",
 
181
        "CMPI_booleanA",
 
182
        "CMPI_boolean_array"},
 
183
 
 
184
        {CMPI_string,
 
185
        CMPI_stringA,
 
186
        "CMPI_string",
 
187
        "CMPI_stringA",
 
188
        "CMPI_string_array"},
 
189
 
 
190
        {CMPI_dateTime,
 
191
        CMPI_dateTimeA,
 
192
        "CMPI_dateTime",
 
193
        "CMPI_dateTimeA",
 
194
        "CMPI_dateTime_array"},
 
195
 
 
196
        {CMPI_ref,
 
197
        CMPI_refA,
 
198
        "CMPI_ref",
 
199
        "CMPI_refA",
 
200
        "CMPI_ref_array"},
 
201
 
 
202
        {CMPI_instance,
 
203
        CMPI_instanceA,
 
204
        "CMPI_instance",
 
205
        "CMPI_instanceA",
 
206
        "CMPI_instance_array"},
 
207
        {CMPI_null,
 
208
        CMPI_ARRAY,
 
209
        "Invalid",
 
210
        "InvalidArray",
 
211
        "Invalid_array"}};
 
212
 
 
213
    int i ,flag, size;
 
214
    CMPIStatus rc = { CMPI_RC_OK, NULL };
 
215
    CMPIStatus rc1 = { CMPI_RC_OK, NULL };
 
216
    CMPIArray *arr = NULL;
 
217
    CMPIString* retNamespace = NULL;
 
218
    CMPIString* retClassname = NULL;
 
219
    CMPIValue value, value1;
 
220
    CMPIData data;
 
221
    CMPIData arr_data;
 
222
    CMPIData dataInst;
 
223
    CMPIData retDataInst;
 
224
    CMPIArgs* args_ptr = NULL;
 
225
    CMPIObjectPath* objPath = make_ObjectPath(_broker,
 
226
        _Namespace,
 
227
        _ClassName);
 
228
    CMPIUint64 datetime1, datetime2;
 
229
    const char* str1;
 
230
    const char* str2;
 
231
 
 
232
    size = 17;
 
233
    for ( i = 0 ; i < size; i++)
 
234
    {
 
235
        args_ptr = CMNewArgs(_broker, &rc);
 
236
        switch(types_arr[i].element_type)
 
237
        {
 
238
            case CMPI_uint32:
 
239
                value.uint32 = 56;
 
240
                break;
 
241
 
 
242
            case CMPI_uint16:
 
243
                value.uint16 = 32;
 
244
                break;
 
245
 
 
246
            case CMPI_uint8:
 
247
                value.uint8 = 56;
 
248
                break;
 
249
 
 
250
            case CMPI_uint64:
 
251
                value.uint64 = 32;
 
252
                break;
 
253
 
 
254
            case CMPI_sint32:
 
255
                value.sint32 = -56;
 
256
                break;
 
257
 
 
258
            case CMPI_sint16:
 
259
                value.sint16 = -32;
 
260
                break;
 
261
 
 
262
            case CMPI_sint8:
 
263
                value.sint8 = -56;
 
264
                break;
 
265
 
 
266
            case CMPI_sint64:
 
267
                value.sint64 = -32;
 
268
                break;
 
269
 
 
270
            case CMPI_real32:
 
271
                value.real32 = (CMPIReal32)-32.78;
 
272
                break;
 
273
 
 
274
            case CMPI_real64:
 
275
                value.real64 = -899.32;
 
276
                break;
 
277
 
 
278
            case CMPI_char16:
 
279
                value.char16 = 'k';
 
280
                break;
 
281
 
 
282
            case CMPI_string:
 
283
                value.string = CMNewString(_broker, "string", &rc);
 
284
                break;
 
285
 
 
286
            case CMPI_boolean:
 
287
                value.boolean = 1;
 
288
                break;
 
289
 
 
290
            case CMPI_dateTime:
 
291
                value.dateTime = CMNewDateTime(_broker, &rc);
 
292
                break;
 
293
 
 
294
            case CMPI_ref:
 
295
                value.ref = CMNewObjectPath (_broker,
 
296
                    "root/cimv2",
 
297
                    "Sample_Instance",
 
298
                    &rc);
 
299
                break;
 
300
 
 
301
            case CMPI_null:
 
302
                value.args = NULL;
 
303
                break;
 
304
 
 
305
            case CMPI_instance:
 
306
                value.inst = make_Instance(objPath);
 
307
                value1.uint32 = 20;
 
308
                rc = CMSetProperty(value.inst,
 
309
                    "Property1",
 
310
                    &value1,
 
311
                    CMPI_uint32);
 
312
                break;
 
313
        }
 
314
 
 
315
        arr = NULL;
 
316
        rc = CMAddArg (args_ptr,
 
317
            "EmptyArray",
 
318
            (CMPIValue *) &arr,
 
319
            types_arr[i].typeA);
 
320
        arr = CMNewArray (_broker, 1, types_arr[i].element_type, &rc);
 
321
 
 
322
        rc = CMSetArrayElementAt(arr, 0, &value, types_arr[i].element_type);
 
323
 
 
324
        rc = CMAddArg (args_ptr,
 
325
            types_arr[i].args_name,
 
326
            (CMPIValue *) &arr,
 
327
            types_arr[i].typeA);
 
328
 
 
329
        flag = 1;
 
330
        if((types_arr[i].element_type) != CMPI_null)
 
331
        {
 
332
            data = CMGetArg(args_ptr, types_arr[i].args_name , &rc);
 
333
 
 
334
            arr_data = CMGetArrayElementAt(data.value.array, 0, &rc);
 
335
 
 
336
            switch(types_arr[i].element_type)
 
337
            {
 
338
                case CMPI_uint32:
 
339
                    if (arr_data.value.uint32 != value.uint32)
 
340
                    {
 
341
                        flag = 0;
 
342
                    }
 
343
                    break;
 
344
 
 
345
                case CMPI_uint16:
 
346
                    if (arr_data.value.uint16 != value.uint16)
 
347
                    {
 
348
                        flag = 0;
 
349
                    }
 
350
                    break;
 
351
 
 
352
                case CMPI_uint8:
 
353
                    if (arr_data.value.uint8 != value.uint8)
 
354
                    {
 
355
                        flag = 0;
 
356
                    }
 
357
                    break;
 
358
 
 
359
                case CMPI_uint64:
 
360
                    if (arr_data.value.uint64 != value.uint64)
 
361
                    {
 
362
                        flag = 0;
 
363
                    }
 
364
                    break;
 
365
 
 
366
                case CMPI_sint32:
 
367
                    if (arr_data.value.sint32 != value.sint32)
 
368
                    {
 
369
                        flag = 0;
 
370
                    }
 
371
                    break;
 
372
 
 
373
                case CMPI_sint16:
 
374
                    if (arr_data.value.sint16 != value.sint16)
 
375
                    {
 
376
                        flag = 0;
 
377
                    }
 
378
                    break;
 
379
 
 
380
                case CMPI_sint8:
 
381
                    if (arr_data.value.sint8 != value.sint8)
 
382
                    {
 
383
                        flag = 0;
 
384
                    }
 
385
                    break;
 
386
 
 
387
                case CMPI_sint64:
 
388
                    if (arr_data.value.sint64 != value.sint64)
 
389
                    {
 
390
                        flag = 0;
 
391
                    }
 
392
                    break;
 
393
 
 
394
                case CMPI_real32:
 
395
                    if (arr_data.value.real32 != value.real32)
 
396
                    {
 
397
                        flag = 0;
 
398
                    }
 
399
                    break;
 
400
 
 
401
                case CMPI_real64:
 
402
                    if (arr_data.value.real64 != value.real64)
 
403
                    {
 
404
                        flag = 0;
 
405
                    }
 
406
                    break;
 
407
 
 
408
                case CMPI_char16:
 
409
                    if (arr_data.value.char16 != value.char16)
 
410
                    {
 
411
                        flag = 0;
 
412
                    }
 
413
                    break;
 
414
 
 
415
                case CMPI_string:
 
416
                    str1 = CMGetCharsPtr(arr_data.value.string, &rc);
 
417
                    str2 = CMGetCharsPtr(value.string, &rc1);
 
418
                    if ((rc.rc != CMPI_RC_OK) ||
 
419
                        (rc1.rc != CMPI_RC_OK) ||
 
420
                        strcmp(str1, str2))
 
421
                    {
 
422
                        flag = 0;
 
423
                    }
 
424
                    break;
 
425
 
 
426
                case CMPI_boolean:
 
427
                    if (arr_data.value.boolean != value.boolean)
 
428
                    {
 
429
                        flag = 0;
 
430
                    }
 
431
                    break;
 
432
 
 
433
                case CMPI_dateTime:
 
434
                    datetime1 = CMGetBinaryFormat(arr_data.value.dateTime,
 
435
                        &rc);
 
436
                    datetime2 = CMGetBinaryFormat(value.dateTime, &rc1);
 
437
                    if ((rc.rc != CMPI_RC_OK) ||
 
438
                        (rc1.rc != CMPI_RC_OK) ||
 
439
                        (datetime1 != datetime2))
 
440
                    {
 
441
                        flag = 0;
 
442
                    }
 
443
                    rc = CMRelease(value.dateTime);
 
444
                    break;
 
445
 
 
446
                case CMPI_ref:
 
447
                    retNamespace = CMGetNameSpace(arr_data.value.ref, &rc);
 
448
                    retClassname = CMGetClassName(arr_data.value.ref, &rc1);
 
449
                    if((rc.rc == CMPI_RC_OK) &&
 
450
                        (rc1.rc == CMPI_RC_OK))
 
451
                    {
 
452
                        str1 = CMGetCharsPtr(retNamespace, &rc);
 
453
                        str2 = CMGetCharsPtr(retClassname, &rc1);
 
454
                        if ((rc.rc == CMPI_RC_OK) &&
 
455
                            (rc1.rc == CMPI_RC_OK))
 
456
                        {
 
457
                            if ((strcmp(str1, "root/cimv2")) ||
 
458
                                (strcmp(str2, "TestCMPI_Instance")))
 
459
                            {
 
460
                                flag = 0;
 
461
                            }
 
462
                        }
 
463
                        else
 
464
                        {
 
465
                            flag = 0;
 
466
                        }
 
467
                    }
 
468
                    else
 
469
                    {
 
470
                        flag = 0;
 
471
                    }
 
472
                    rc = CMRelease(value.ref);
 
473
                    break;
 
474
 
 
475
                case CMPI_instance:
 
476
                    retDataInst = CMGetProperty(arr_data.value.inst,
 
477
                        "Property1", &rc);
 
478
                    dataInst = CMGetProperty(value.inst, "Property1", &rc);
 
479
                    if (retDataInst.value.uint32 != dataInst.value.uint32)
 
480
                    {
 
481
                        flag = 0;
 
482
                    }
 
483
                    rc = CMRelease(value.inst);
 
484
                    break;
 
485
            }
 
486
            if (data.type == types_arr[i].typeA && flag)
 
487
            {
 
488
            }
 
489
        }
 
490
        rc = CMRelease(arr);
 
491
        rc = CMRelease(args_ptr);
 
492
    }
 
493
    return flag;
 
494
}
 
495
 
 
496
static int _testSimpleTypes()
 
497
{
 
498
    CMPIArgs* args_ptr = NULL;
 
499
    CMPIStatus rc = { CMPI_RC_OK, NULL };
 
500
    CMPIStatus rc1 = { CMPI_RC_OK, NULL };
 
501
    int i, flag, size;
 
502
    CMPIValue value;
 
503
    CMPIValue value1;
 
504
    CMPIData data;
 
505
    CMPIData dataInst;
 
506
    CMPIData retDataInst;
 
507
    CMPIString* retNamespace = NULL;
 
508
    CMPIString* retClassname = NULL;
 
509
    CMPIObjectPath* objPath = make_ObjectPath(_broker,
 
510
        _Namespace,
 
511
        _ClassName);
 
512
    const char* str1;
 
513
    const char* str2;
 
514
 
 
515
    struct array_types
 
516
    {
 
517
        CMPIType element_type;
 
518
        char* typeName;
 
519
        char* args_name;
 
520
    }types_arr[] = {
 
521
 
 
522
        {CMPI_instance,
 
523
        "CMPI_instance",
 
524
        "CMPI_instance"},
 
525
        {CMPI_ref,
 
526
        "CMPI_ref",
 
527
        "CMPI_ref"}};
 
528
 
 
529
    size = 2;
 
530
 
 
531
    flag = 1;
 
532
    for ( i = 0 ; i < size; i++)
 
533
    {
 
534
        args_ptr = CMNewArgs(_broker, &rc);
 
535
 
 
536
        switch(types_arr[i].element_type)
 
537
        {
 
538
            case CMPI_ref:
 
539
                value.ref = CMNewObjectPath (_broker,
 
540
                    "root/cimv2",
 
541
                    "Sample_Instance",
 
542
                    &rc);
 
543
                break;
 
544
 
 
545
            case CMPI_instance:
 
546
                value.inst = make_Instance(objPath);
 
547
                value1.uint32 = 20;
 
548
                rc = CMSetProperty(value.inst,
 
549
                    "Property1",
 
550
                    &value1,
 
551
                    CMPI_uint32);
 
552
                break;
 
553
        }
 
554
        rc = CMAddArg (args_ptr,
 
555
            types_arr[i].args_name,
 
556
            (CMPIValue *) &value,
 
557
            types_arr[i].element_type);
 
558
 
 
559
        data = CMGetArg(args_ptr, types_arr[i].args_name , &rc);
 
560
 
 
561
        switch(types_arr[i].element_type)
 
562
        {
 
563
            case CMPI_ref:
 
564
                retNamespace = CMGetNameSpace(data.value.ref, &rc);
 
565
                retClassname = CMGetClassName(data.value.ref, &rc1);
 
566
 
 
567
                if((rc.rc == CMPI_RC_OK) &&
 
568
                    (rc1.rc == CMPI_RC_OK))
 
569
                {
 
570
                    str1 = CMGetCharsPtr(retNamespace, &rc);
 
571
                    str2 = CMGetCharsPtr(retClassname, &rc1);
 
572
                    if ((rc.rc == CMPI_RC_OK) &&
 
573
                        (rc1.rc == CMPI_RC_OK))
 
574
                    {
 
575
                        if ((strcmp(str1, "root/cimv2")) ||
 
576
                            (strcmp(str2, "Sample_Instance")))
 
577
                        {
 
578
                            flag = 0;
 
579
                        }
 
580
                    }
 
581
                    else
 
582
                    {
 
583
                        flag = 0;
 
584
                    }
 
585
                }
 
586
                else
 
587
                {
 
588
                    flag = 0;
 
589
                }
 
590
                rc = CMRelease(value.ref);
 
591
                break;
 
592
 
 
593
            case CMPI_instance:
 
594
                retDataInst = CMGetProperty(data.value.inst,
 
595
                    "Property1", &rc);
 
596
                dataInst = CMGetProperty(value.inst, "Property1", &rc);
 
597
                if (retDataInst.value.uint32 != dataInst.value.uint32)
 
598
                {
 
599
                    flag = 0;
 
600
                }
 
601
                rc = CMRelease(value.inst);
 
602
                break;
 
603
        }
 
604
        if (data.type == types_arr[i].element_type && flag)
 
605
        {
 
606
        }
 
607
        rc = CMRelease(args_ptr);
 
608
    }
 
609
    return flag;
 
610
}
 
611
 
 
612
static int _testErrorPaths()
 
613
{
 
614
    CMPIArgs* args_ptr = NULL;
 
615
    CMPIStatus rc = { CMPI_RC_OK, NULL };
 
616
    CMPIValue value;
 
617
    char* str = NULL;
 
618
    value.inst = NULL;
 
619
    args_ptr = CMNewArgs(_broker, &rc);
 
620
    rc = CMAddArg (args_ptr,
 
621
        "EmptyInstance",
 
622
        (CMPIValue *) &value,
 
623
        CMPI_instance);
 
624
    value.ref = NULL;
 
625
    rc = CMAddArg (args_ptr,
 
626
        "EmptyRef",
 
627
        (CMPIValue *) &value,
 
628
        CMPI_ref);
 
629
    value.dateTime = NULL;
 
630
    rc = CMAddArg (args_ptr,
 
631
        "EmptyDatetime",
 
632
        (CMPIValue *) &value,
 
633
        CMPI_dateTime);
 
634
    rc = CMAddArg (args_ptr,
 
635
        "EmptyChars",
 
636
        (CMPIValue *) str,
 
637
        CMPI_chars);
 
638
    rc = CMAddArg (args_ptr,
 
639
        "EmptyCharsPtrA",
 
640
        NULL,
 
641
        CMPI_charsptrA);
 
642
 
 
643
    value.chars = NULL;
 
644
    rc = CMAddArg (args_ptr,
 
645
        "EmptyCharsPtr",
 
646
        &value,
 
647
        CMPI_charsptr);
 
648
 
 
649
    value.args = NULL;
 
650
    rc = CMAddArg (args_ptr,
 
651
        "EmptyArgs",
 
652
        (CMPIValue *) &value,
 
653
        CMPI_args);
 
654
 
 
655
    rc = CMRelease(args_ptr);
 
656
    return 1;
 
657
}
 
658
 
 
659
 
 
660
static int _testCMPIEnumeration (const CMPIContext* ctx)
 
661
{
 
662
    CMPIStatus rc = { CMPI_RC_OK, NULL };
 
663
    CMPIEnumeration *enum_ptr = NULL;
 
664
    CMPIData data;
 
665
    unsigned int initCount = 0;
 
666
    CMPIObjectPath* objPath = NULL;
 
667
    CMPIArray* arr_ptr = NULL;
 
668
    CMPICount returnedArraySize;
 
669
    void *eptr;
 
670
    objPath = make_ObjectPath(_broker, _Namespace, _PersonClass);
 
671
    enum_ptr = CBEnumInstances(_broker, ctx, objPath, NULL, &rc);
 
672
    if (enum_ptr == NULL)
 
673
    {
 
674
        return 1;
 
675
    }
 
676
 
 
677
    arr_ptr = CMToArray(enum_ptr, &rc);
 
678
    if (arr_ptr == NULL)
 
679
    {
 
680
        return 1;
 
681
    }
 
682
 
 
683
    returnedArraySize = CMGetArrayCount(arr_ptr, &rc);
 
684
    while (CMHasNext(enum_ptr, &rc))
 
685
    {
 
686
        data = CMGetNext(enum_ptr, &rc);
 
687
        if (data.type != CMPI_instance)
 
688
        {
 
689
            return 1;
 
690
        }
 
691
        initCount++;
 
692
    }
 
693
 
 
694
    eptr = enum_ptr->hdl;
 
695
    enum_ptr->hdl = NULL;
 
696
 
 
697
    CMToArray(enum_ptr, &rc);
 
698
    if (rc.rc != CMPI_RC_ERR_INVALID_HANDLE)
 
699
    {
 
700
        return 1;
 
701
    }
 
702
 
 
703
    CMGetNext(enum_ptr, &rc);
 
704
    if (rc.rc != CMPI_RC_ERR_INVALID_HANDLE)
 
705
    {
 
706
        return 1;
 
707
    }
 
708
 
 
709
    CMHasNext(enum_ptr, &rc);
 
710
    if (rc.rc != CMPI_RC_ERR_INVALID_HANDLE)
 
711
    {
 
712
        return 1;
 
713
    }
 
714
    enum_ptr->hdl = eptr;
 
715
    rc = CMRelease (enum_ptr);
 
716
    if (rc.rc != CMPI_RC_OK)
 
717
    {
 
718
        return 1;
 
719
    }
 
720
 
 
721
    return 0;
 
722
}
 
723
 
 
724
static int _testCMPIArray ()
 
725
{
 
726
  CMPIStatus rc = { CMPI_RC_OK, NULL };
 
727
    CMPIArray *arr_ptr = NULL;
 
728
    CMPIArray *new_arr_ptr = NULL;
 
729
    CMPIData data[3];
 
730
    CMPIData clonedData[3];
 
731
    CMPIValue value;
 
732
    CMPIType initArrayType = CMPI_uint32;
 
733
    CMPIType initErrArrayType = CMPI_REAL;
 
734
    CMPIType returnedArrayType;
 
735
    CMPICount initArraySize = 3;
 
736
    CMPICount returnedArraySize;
 
737
    CMPIUint32 i;
 
738
    CMPIBoolean cloneSuccessful = 0;
 
739
    CMPIBoolean getDataSuccessful;
 
740
    void *aptr;
 
741
    arr_ptr = CMNewArray(_broker, initArraySize, initArrayType, &rc);
 
742
    if (arr_ptr == NULL)
 
743
    {
 
744
        return 1;
 
745
    }
 
746
    returnedArraySize = CMGetArrayCount(arr_ptr, &rc);
 
747
    returnedArrayType = CMGetArrayType(arr_ptr, &rc);
 
748
 
 
749
    value.uint32 = 10;
 
750
    rc = CMSetArrayElementAt(arr_ptr, 0, &value, initArrayType);
 
751
    value.uint32 = 20;
 
752
    rc = CMSetArrayElementAt(arr_ptr, 1, &value, initArrayType);
 
753
    value.uint32 = 30;
 
754
    rc = CMSetArrayElementAt(arr_ptr, 2, &value, initArrayType);
 
755
 
 
756
    i = 0;
 
757
    while (i < 3)
 
758
    {
 
759
        data[i] = CMGetArrayElementAt(arr_ptr, i, &rc);
 
760
        i++;
 
761
    }
 
762
 
 
763
    i = 0;
 
764
    getDataSuccessful = 1;
 
765
    while (i < 3)
 
766
    {
 
767
        if (data[i].value.uint32 != (i + 1) * 10)
 
768
        {
 
769
            getDataSuccessful = 0;
 
770
            break;
 
771
        }
 
772
        i++;
 
773
    }
 
774
    new_arr_ptr = arr_ptr->ft->clone(arr_ptr, &rc);
 
775
    i = 0;
 
776
    while (i < 3)
 
777
    {
 
778
        clonedData[i] = CMGetArrayElementAt(new_arr_ptr, i, &rc);
 
779
        i++;
 
780
    }
 
781
 
 
782
    cloneSuccessful = 1;
 
783
    for (i = 0; i < initArraySize; i++)
 
784
    {
 
785
        if (data[i].value.uint32 != clonedData[i].value.uint32)
 
786
        {
 
787
            cloneSuccessful = 0;
 
788
            break;
 
789
        }
 
790
    }
 
791
    rc = new_arr_ptr->ft->release(new_arr_ptr);
 
792
    aptr = arr_ptr->hdl;
 
793
    arr_ptr->hdl = NULL;
 
794
 
 
795
    returnedArraySize = CMGetArrayCount(arr_ptr, &rc);
 
796
    if (rc.rc != CMPI_RC_ERR_INVALID_HANDLE)
 
797
    {
 
798
        return 1;
 
799
    }
 
800
 
 
801
    returnedArrayType = CMGetArrayType(arr_ptr, &rc);
 
802
    if (rc.rc != CMPI_RC_ERR_INVALID_HANDLE)
 
803
    {
 
804
        return 1;
 
805
    }
 
806
 
 
807
    rc = CMSetArrayElementAt(arr_ptr, 2, &value, initArrayType);
 
808
    if (rc.rc != CMPI_RC_ERR_INVALID_HANDLE)
 
809
    {
 
810
        return 1;
 
811
    }
 
812
 
 
813
    CMGetArrayElementAt(arr_ptr, 5, &rc);
 
814
    if (rc.rc != CMPI_RC_ERR_INVALID_HANDLE)
 
815
    {
 
816
        return 1;
 
817
    }
 
818
    arr_ptr->ft->clone(arr_ptr, &rc);
 
819
    if (rc.rc != CMPI_RC_ERR_INVALID_HANDLE)
 
820
    {
 
821
        return 1;
 
822
    }
 
823
 
 
824
    rc = arr_ptr->ft->release(arr_ptr);
 
825
    if (rc.rc != CMPI_RC_ERR_INVALID_HANDLE)
 
826
    {
 
827
        return 1;
 
828
    }
 
829
 
 
830
    arr_ptr->hdl = aptr;
 
831
 
 
832
    CMGetArrayElementAt(arr_ptr, 5, &rc);
 
833
    if (rc.rc != CMPI_RC_ERR_NO_SUCH_PROPERTY)
 
834
    {
 
835
        return 1;
 
836
    }
 
837
 
 
838
    rc = CMSetArrayElementAt(arr_ptr, 2, &value, initErrArrayType);
 
839
    if (rc.rc != CMPI_RC_ERR_TYPE_MISMATCH)
 
840
    {
 
841
        return 1;
 
842
    }
 
843
 
 
844
    rc = arr_ptr->ft->release(arr_ptr);
 
845
    return 0;
 
846
}
 
847
 
 
848
static int _testCMPIcontext (const CMPIContext* ctx)
 
849
{
 
850
    CMPIStatus rc = { CMPI_RC_OK, NULL };
 
851
    CMPIValue value;
 
852
    CMPIData data;
 
853
    CMPIUint32 count = 0;
 
854
    CMPIUint32  count_for_new_context = 0;
 
855
    count = CMGetContextEntryCount(ctx, &rc);
 
856
    value.uint32 = 40;
 
857
    rc = CMAddContextEntry(ctx, "name1", &value, CMPI_uint32);
 
858
    value.real32 = (CMPIReal32)40.123;
 
859
    rc = CMAddContextEntry(ctx, "name2", &value, CMPI_real32);
 
860
    data = CMGetContextEntry(ctx, "name1", &rc);
 
861
    data = CMGetContextEntry(ctx, "name2", &rc);
 
862
    count_for_new_context = CMGetContextEntryCount(ctx, &rc);
 
863
    CMGetContextEntry(ctx, "noEntry", &rc);
 
864
    if (rc.rc != CMPI_RC_ERR_NO_SUCH_PROPERTY)
 
865
    {
 
866
        return 1;
 
867
    }
 
868
 
 
869
    return 0;
 
870
}
 
871
 
 
872
static int _testCMPIDateTime ()
 
873
{
 
874
    CMPIStatus rc = { CMPI_RC_OK, NULL };
 
875
 
 
876
    CMPIBoolean isInterval = 0;
 
877
    CMPIBoolean interval = 0;
 
878
    CMPIBoolean cloneSuccessful = 0;
 
879
    CMPIBoolean binaryDateTimeEqual = 0;
 
880
 
 
881
    CMPIDateTime *dateTime = NULL;
 
882
    CMPIDateTime *new_dateTime = NULL;
 
883
    CMPIDateTime *clonedDateTime = NULL;
 
884
    CMPIDateTime *dateTimeFromBinary = NULL;
 
885
 
 
886
    CMPIUint64 dateTimeInBinary = UINT64_LITERAL(1150892800000000); 
 
887
    CMPIUint64 returnedDateTimeInBinary = 0;
 
888
 
 
889
    CMPIString* stringDate = NULL;
 
890
    CMPIString* clonedStringDate = NULL;
 
891
 
 
892
    const char *normalString = NULL;
 
893
    const char *clonedString = NULL;
 
894
    void *dtptr;
 
895
 
 
896
    dateTime = CMNewDateTime(_broker, &rc);
 
897
    if (dateTime == NULL)
 
898
    {
 
899
        return 1;
 
900
    }
 
901
 
 
902
    dateTimeFromBinary = CMNewDateTimeFromBinary(
 
903
        _broker, dateTimeInBinary, interval, &rc);
 
904
    returnedDateTimeInBinary = CMGetBinaryFormat(dateTimeFromBinary, &rc);
 
905
    if (dateTimeInBinary == returnedDateTimeInBinary)
 
906
    {
 
907
        binaryDateTimeEqual = 1;
 
908
    }
 
909
    isInterval = CMIsInterval(dateTime, &rc);
 
910
    interval = 1;
 
911
    new_dateTime = CMNewDateTimeFromBinary(
 
912
        _broker, dateTimeInBinary, interval,&rc);
 
913
    isInterval = CMIsInterval(new_dateTime, &rc);
 
914
    clonedDateTime = dateTime->ft->clone(dateTime, &rc);
 
915
    stringDate = CMGetStringFormat(dateTime, &rc);
 
916
    clonedStringDate = CMGetStringFormat(clonedDateTime, &rc);
 
917
    rc = clonedDateTime->ft->release(clonedDateTime);
 
918
    normalString = CMGetCharsPtr(stringDate, &rc);
 
919
    clonedString = CMGetCharsPtr(clonedStringDate, &rc);
 
920
    if (strcmp(normalString,clonedString) == 0)
 
921
    {
 
922
        cloneSuccessful = 1;
 
923
    }
 
924
    dtptr = dateTime->hdl;
 
925
    dateTime->hdl = NULL;
 
926
 
 
927
    CMGetBinaryFormat(dateTime, &rc);
 
928
    if (rc.rc != CMPI_RC_ERR_INVALID_HANDLE)
 
929
    {
 
930
        return 1;
 
931
    }
 
932
 
 
933
    dateTime->ft->clone(dateTime, &rc);
 
934
    if (rc.rc != CMPI_RC_ERR_INVALID_HANDLE)
 
935
    {
 
936
        return 1;
 
937
    }
 
938
 
 
939
    CMGetStringFormat(dateTime, &rc);
 
940
    if (rc.rc != CMPI_RC_ERR_INVALID_HANDLE)
 
941
    {
 
942
        return 1;
 
943
    }
 
944
 
 
945
    rc = dateTime->ft->release(dateTime);
 
946
    if (rc.rc != CMPI_RC_ERR_INVALID_HANDLE)
 
947
    {
 
948
        return 1;
 
949
    }
 
950
 
 
951
    dateTime->hdl = dtptr;
 
952
    rc = dateTime->ft->release(dateTime);
 
953
    return 0;
 
954
}
 
955
 
 
956
static int _testCMPIInstance ()
 
957
{
 
958
    CMPIStatus rc = { CMPI_RC_OK, NULL };
 
959
 
 
960
    CMPIInstance* instance = NULL;
 
961
    CMPIInstance* clonedInstance = NULL;
 
962
    CMPIObjectPath* objPath = NULL;
 
963
    CMPIObjectPath* newObjPath = NULL;
 
964
    CMPIObjectPath* returnedObjPath = NULL;
 
965
 
 
966
    CMPIData returnedData1;
 
967
    CMPIData returnedData2;
 
968
    CMPIData clonedData1;
 
969
 
 
970
    CMPIString* returnedName = NULL;
 
971
    unsigned int count = 0;
 
972
    const char* name1 = "firstPropertyName";
 
973
    CMPIValue value1;
 
974
    const char* name2 = "secondPropertyName";
 
975
    CMPIValue value2;
 
976
    CMPIType type = CMPI_uint64;
 
977
    CMPIBoolean dataEqual = 0;
 
978
    CMPIBoolean objectPathEqual = 0;
 
979
    CMPIBoolean cloneSuccessful = 0;
 
980
    CMPIString* beforeObjPath = NULL;
 
981
    CMPIString* afterObjPath = NULL;
 
982
    const char* beforeString = NULL;
 
983
    const char* afterString = NULL;
 
984
    objPath = make_ObjectPath(_broker, _Namespace, _ClassName);
 
985
    instance = make_Instance(objPath);
 
986
    value1.uint32 = 10;
 
987
    rc = CMSetProperty(instance, name1, &value1, type);
 
988
    value2.uint32 = 20;
 
989
    rc = CMSetProperty(instance, name2, &value2, type);
 
990
    count = CMGetPropertyCount(instance, &rc);
 
991
    returnedData1 = CMGetProperty(instance, name1, &rc);
 
992
    if (returnedData1.value.uint32 == 10)
 
993
    {
 
994
        dataEqual = 1 ;
 
995
    }
 
996
    returnedData2 = CMGetPropertyAt(instance, 2, &returnedName, &rc);
 
997
    if (returnedData2.value.uint32 == 20)
 
998
    {
 
999
        dataEqual = 1 ;
 
1000
    }
 
1001
    newObjPath = make_ObjectPath(_broker, _Namespace, _ClassName);
 
1002
    returnedObjPath = CMGetObjectPath(instance, &rc);
 
1003
    beforeObjPath = CMObjectPathToString(returnedObjPath, &rc);
 
1004
    beforeString = CMGetCharsPtr(beforeObjPath, &rc);
 
1005
    rc = CMSetNameSpace(newObjPath, "newNamespace");
 
1006
    rc = CMSetObjectPath(instance, newObjPath);
 
1007
    returnedObjPath = CMGetObjectPath(instance, &rc);
 
1008
    afterObjPath = CMObjectPathToString(returnedObjPath, &rc);
 
1009
    afterString = CMGetCharsPtr(afterObjPath,&rc);
 
1010
    afterString = CMGetCharsPtr(CMGetNameSpace(returnedObjPath, &rc), &rc);
 
1011
    if (strcmp("newNamespace",afterString) == 0)
 
1012
    {
 
1013
        objectPathEqual = 1;
 
1014
    }
 
1015
    clonedInstance = instance->ft->clone(instance, &rc);
 
1016
    clonedData1 = CMGetProperty(clonedInstance, name1, &rc);
 
1017
    rc = clonedInstance->ft->release(clonedInstance);
 
1018
    if (returnedData1.value.uint32 == clonedData1.value.uint32)
 
1019
    {
 
1020
        cloneSuccessful = 1;
 
1021
    }
 
1022
    else
 
1023
    {
 
1024
        cloneSuccessful = 0;
 
1025
    }
 
1026
    CMGetProperty(instance, "noProperty", &rc);
 
1027
    if (rc.rc != CMPI_RC_ERR_NO_SUCH_PROPERTY)
 
1028
    {
 
1029
        return 1;
 
1030
    }
 
1031
 
 
1032
    CMGetPropertyAt(instance, 100, &returnedName, &rc);
 
1033
    if (rc.rc != CMPI_RC_ERR_NO_SUCH_PROPERTY)
 
1034
    {
 
1035
        return 1;
 
1036
    }
 
1037
    rc = instance->ft->release(instance);
 
1038
    return 0;
 
1039
}
 
1040
 
 
1041
static int _testCMPIObjectPath ()
 
1042
{
 
1043
    CMPIStatus rc = { CMPI_RC_OK, NULL };
 
1044
 
 
1045
    CMPIObjectPath* objPath = NULL;
 
1046
    CMPIObjectPath* clonedObjPath = NULL;
 
1047
    CMPIObjectPath* otherObjPath = NULL;
 
1048
    CMPIObjectPath *fakeObjPath  = NULL;
 
1049
 
 
1050
    const char* hostName = "HOSTNAME";
 
1051
    const char* nameSpace = "root/dummy";
 
1052
    const char* className = "classname";
 
1053
 
 
1054
    CMPIString* returnedHostname = NULL;
 
1055
    CMPIBoolean equalHostname = 0;
 
1056
    CMPIString* returnedNamespace = NULL;
 
1057
    CMPIBoolean equalNamespace = 0;
 
1058
    CMPIString* returnedClassName;
 
1059
    CMPIBoolean equalClassName = 0;
 
1060
    CMPIString* returnedObjectPath;
 
1061
    CMPIBoolean cloneSuccessful = 0;
 
1062
    CMPIBoolean getKeySuccessful = 0;
 
1063
    CMPIBoolean getKeyCountSuccessful = 0;
 
1064
    CMPIBoolean getKeyAtSuccessful = 0;
 
1065
    const char* objectPath1 = NULL;
 
1066
    const char* objectPath2 = NULL;
 
1067
    CMPIData data;
 
1068
    CMPIValue value;
 
1069
    unsigned int keyCount = 0;
 
1070
    objPath = make_ObjectPath(_broker, _Namespace, _ClassName);
 
1071
    rc = CMSetHostname(objPath, hostName);
 
1072
    returnedHostname = CMGetHostname(objPath, &rc);
 
1073
    if (strcmp(hostName,CMGetCharsPtr(returnedHostname,&rc)) == 0)
 
1074
    {
 
1075
        equalHostname = 1;
 
1076
    }
 
1077
    rc = CMSetNameSpace(objPath, nameSpace);
 
1078
    returnedNamespace = CMGetNameSpace(objPath, &rc);
 
1079
    if (strcmp(nameSpace, CMGetCharsPtr(returnedNamespace, &rc)) == 0)
 
1080
    {
 
1081
        equalNamespace = 1;
 
1082
    }
 
1083
    rc = CMSetClassName(objPath, className);
 
1084
    returnedClassName = CMGetClassName(objPath, &rc);
 
1085
    if (strcmp(className,CMGetCharsPtr(returnedClassName, &rc)) == 0)
 
1086
    {
 
1087
        equalClassName = 1;
 
1088
    }
 
1089
    otherObjPath = make_ObjectPath(_broker, _Namespace, _ClassName);
 
1090
    returnedNamespace = CMGetNameSpace(otherObjPath, &rc);
 
1091
    rc = CMSetNameSpaceFromObjectPath(otherObjPath, objPath);
 
1092
    returnedNamespace = CMGetNameSpace(otherObjPath, &rc);
 
1093
    if (strcmp(nameSpace,CMGetCharsPtr(returnedNamespace, &rc)) == 0)
 
1094
    {
 
1095
        equalNamespace = 1;
 
1096
    }
 
1097
    returnedHostname = CMGetHostname(otherObjPath, &rc);
 
1098
    rc = CMSetHostAndNameSpaceFromObjectPath(otherObjPath,objPath);
 
1099
    returnedHostname = CMGetHostname(otherObjPath, &rc);
 
1100
    if (strcmp(hostName,CMGetCharsPtr(returnedHostname,&rc)) == 0)
 
1101
    {
 
1102
        equalHostname = 1;
 
1103
    }
 
1104
    returnedObjectPath = CMObjectPathToString(objPath, &rc);
 
1105
    objectPath1 = CMGetCharsPtr(returnedObjectPath, &rc);
 
1106
    clonedObjPath = objPath->ft->clone(objPath, &rc);
 
1107
    returnedObjectPath = CMObjectPathToString(clonedObjPath, &rc);
 
1108
    rc = clonedObjPath->ft->release(clonedObjPath);
 
1109
    objectPath2 = CMGetCharsPtr(returnedObjectPath, &rc);
 
1110
    if (strcmp(objectPath1,objectPath2) == 0)
 
1111
    {
 
1112
        cloneSuccessful = 1;
 
1113
    }
 
1114
    else
 
1115
    {
 
1116
        cloneSuccessful = 0;
 
1117
    }
 
1118
    fakeObjPath = CMNewObjectPath (_broker, "root#cimv2",
 
1119
        "Sample_Instance", &rc);
 
1120
    rc = CMAddKey (fakeObjPath, "ElementName",
 
1121
        (CMPIValue *) "Fake", CMPI_chars);
 
1122
    rc = CMAddKey (otherObjPath, "ElementName1",
 
1123
        (CMPIValue *) "otherObjPath", CMPI_chars);
 
1124
    data = CMGetKey(fakeObjPath, "ElementName", &rc);
 
1125
    if (strcmp(CMGetCharsPtr(data.value.string, &rc),"Fake") == 0)
 
1126
    {
 
1127
        getKeySuccessful = 1;
 
1128
    }
 
1129
    keyCount = CMGetKeyCount(fakeObjPath, &rc);
 
1130
    if (keyCount == 1)
 
1131
    {
 
1132
        getKeyCountSuccessful = 1;
 
1133
    }
 
1134
    data = CMGetKeyAt(fakeObjPath, 0, NULL, &rc);
 
1135
    if (rc.rc == 0)
 
1136
    {
 
1137
        getKeyAtSuccessful = 1;
 
1138
    }
 
1139
    value.uint16 = 67;
 
1140
    rc = CMAddKey (fakeObjPath, "Numeric_key_unsigned",
 
1141
        (CMPIValue *) &value, CMPI_uint16);
 
1142
    data = CMGetKey(fakeObjPath, "Numeric_key_unsigned", &rc);
 
1143
    value.sint16 = -67;
 
1144
    rc = CMAddKey (fakeObjPath, "Numeric_key_signed",
 
1145
        (CMPIValue *) &value, CMPI_sint16);
 
1146
    data = CMGetKey(fakeObjPath, "Numeric_key_signed", &rc);
 
1147
    value.boolean = 1;
 
1148
    rc = CMAddKey (fakeObjPath, "Boolean_key",
 
1149
        (CMPIValue *) &value, CMPI_boolean);
 
1150
    data = CMGetKey(fakeObjPath, "Boolean_key", &rc);
 
1151
    CMGetKeyAt(objPath, 500, NULL, &rc);
 
1152
    if (rc.rc != CMPI_RC_ERR_NO_SUCH_PROPERTY)
 
1153
    {
 
1154
        return 1;
 
1155
    }
 
1156
    rc = objPath->ft->release(objPath);
 
1157
    rc = fakeObjPath->ft->release(fakeObjPath);
 
1158
    return 0;
 
1159
}
 
1160
 
 
1161
static int _testCMPIResult (const CMPIResult *rslt)
 
1162
{
 
1163
    CMPIStatus rc = { CMPI_RC_OK, NULL };
 
1164
 
 
1165
    CMPIValue value;
 
1166
    CMPIType type;
 
1167
    const CMPIObjectPath* objPath = NULL;
 
1168
    CMPIBoolean returnDataSuccessful = 0;
 
1169
    value.uint32 = 10;
 
1170
    type = CMPI_uint32;
 
1171
    rc = CMReturnData(rslt, &value, type);
 
1172
    if (rc.rc == CMPI_RC_OK)
 
1173
    {
 
1174
        returnDataSuccessful = 1;
 
1175
    }
 
1176
    objPath = make_ObjectPath(_broker, _Namespace, _ClassName);
 
1177
    rc = CMReturnObjectPath(rslt, objPath);
 
1178
    rc = CMReturnDone(rslt);
 
1179
    rc = CMReturnData(rslt, NULL, type);
 
1180
    if (rc.rc != CMPI_RC_ERR_INVALID_PARAMETER)
 
1181
    {
 
1182
        return 1;
 
1183
    }
 
1184
 
 
1185
    return 0;
 
1186
}
 
1187
 
 
1188
static int _testCMPIString()
 
1189
{
 
1190
    CMPIStatus rc = { CMPI_RC_OK, NULL };
 
1191
 
 
1192
    CMPIString* string = NULL;
 
1193
    CMPIString* clonedString = NULL;
 
1194
    const char* actual_string = NULL;
 
1195
    const char* cloned_string = NULL;
 
1196
    const char *data = "dataString";
 
1197
    CMPIBoolean cloneSuccessful = 0;
 
1198
    void *string_ptr;
 
1199
    string = CMNewString(_broker, data, &rc);
 
1200
    actual_string = CMGetCharsPtr(string, &rc);
 
1201
    clonedString = string->ft->clone(string, &rc);
 
1202
    cloned_string = CMGetCharsPtr(clonedString, &rc);
 
1203
    if (strcmp(actual_string,cloned_string) == 0)
 
1204
    {
 
1205
        cloneSuccessful = 1;
 
1206
    }
 
1207
    rc = clonedString->ft->release(clonedString);
 
1208
    string_ptr = string->hdl;
 
1209
    string->hdl = NULL;
 
1210
 
 
1211
    string->ft->clone(string, &rc);
 
1212
    if (rc.rc != CMPI_RC_ERR_INVALID_HANDLE)
 
1213
    {
 
1214
        return 1;
 
1215
    }
 
1216
 
 
1217
    rc = string->ft->release(string);
 
1218
    if (rc.rc != CMPI_RC_ERR_INVALID_HANDLE)
 
1219
    {
 
1220
        return 1;
 
1221
    }
 
1222
 
 
1223
    CMGetCharsPtr(string, &rc);
 
1224
    if (rc.rc != CMPI_RC_ERR_INVALID_HANDLE)
 
1225
    {
 
1226
        return 1;
 
1227
    }
 
1228
 
 
1229
    string->hdl = string_ptr;
 
1230
    rc = string->ft->release(string);
 
1231
    return 0;
 
1232
}
 
1233
 
 
1234
static int _testCMPIArgs()
 
1235
{
 
1236
    CMPIStatus rc = { CMPI_RC_OK, NULL };
 
1237
 
 
1238
    CMPIArgs* args = NULL;
 
1239
    CMPIArgs* clonedArgs = NULL;
 
1240
    CMPIUint32 count = 0;
 
1241
    CMPIType type = CMPI_uint32;
 
1242
    char *arg1 = "arg1";
 
1243
    char *arg2 = "arg2";
 
1244
    CMPIValue value;
 
1245
    CMPIData data;
 
1246
    CMPIData clonedData;
 
1247
    CMPIBoolean cloneSuccessful = 0;
 
1248
    CMPIBoolean getArgCountSuccessful = 0;
 
1249
    args = CMNewArgs(_broker, &rc);
 
1250
    value.uint32 = 10;
 
1251
    rc = CMAddArg(args, arg1, &value, type);
 
1252
    count = CMGetArgCount(args, &rc);
 
1253
    if (count == 1)
 
1254
    {
 
1255
        getArgCountSuccessful = 1;
 
1256
    }
 
1257
    value.uint32 = 20;
 
1258
    rc = CMAddArg(args, arg2, &value, type);
 
1259
    count = CMGetArgCount(args, &rc);
 
1260
    if (count == 2)
 
1261
    {
 
1262
        getArgCountSuccessful = 1;
 
1263
    }
 
1264
    data = CMGetArg(args, arg2, &rc);
 
1265
    rc = CMAddArg(args, arg1, &value, type);
 
1266
    clonedArgs = args->ft->clone(args, &rc);
 
1267
    clonedData = CMGetArg(clonedArgs, arg2, &rc);
 
1268
    rc = clonedArgs->ft->release(clonedArgs);
 
1269
    if (data.value.uint32 == clonedData.value.uint32)
 
1270
    {
 
1271
        cloneSuccessful = 1;
 
1272
    }
 
1273
    rc = args->ft->release(args);
 
1274
    return 0;
 
1275
}
 
1276
 
 
1277
/* ---------------------------------------------------------------------------*/
 
1278
/*                        Method Provider Interface                           */
 
1279
/* ---------------------------------------------------------------------------*/
 
1280
CMPIStatus
 
1281
TestMiscProviderMethodCleanup (CMPIMethodMI * mi, const CMPIContext * ctx, CMPIBoolean terminate)
 
1282
{
 
1283
  CMReturn(CMPI_RC_OK);
 
1284
}
 
1285
 
 
1286
CMPIStatus
 
1287
TestMiscProviderInvokeMethod (CMPIMethodMI * mi,
 
1288
                                    const CMPIContext * ctx,
 
1289
                                    const CMPIResult * rslt,
 
1290
                                    const CMPIObjectPath * ref,
 
1291
                                    const char *methodName,
 
1292
                                    const CMPIArgs * in, CMPIArgs * out)
 
1293
{
 
1294
  CMPIString *class = NULL;
 
1295
  CMPIStatus rc = { CMPI_RC_OK, NULL };
 
1296
  CMPIData data;
 
1297
  CMPIValue value;
 
1298
  char *result = NULL;
 
1299
 
 
1300
  if (strncmp ("testReturn", methodName, strlen ("testReturn")) == 0)
 
1301
  {
 
1302
      value.uint32 = 2;
 
1303
      CMReturnData (rslt, &value, CMPI_uint32);
 
1304
      CMReturnDone (rslt);
 
1305
      return rc;
 
1306
  }
 
1307
 
 
1308
  class = CMGetClassName (ref, &rc);
 
1309
  if (strncmp(
 
1310
      CMGetCharsPtr (class,NULL),
 
1311
      _ClassName,
 
1312
      strlen (_ClassName)) == 0)
 
1313
    {
 
1314
      if (strncmp ("TestCMPIBroker", methodName, strlen ("TestCMPIBroker")) ==
 
1315
          0)
 
1316
        {
 
1317
          // Parse the CMPIArgs in to figure out which operation it is.
 
1318
          // There are six of them:
 
1319
          //   ValueMap { "1", "2", "3"},
 
1320
          //   Values {"CMGetMessage","CMLogMessage","CDTraceMessage"}]
 
1321
          //    uint32 Operation,
 
1322
          //    [OUT]string Result);
 
1323
          data = CMGetArg (in, "Operation", &rc);
 
1324
 
 
1325
          if (data.type == CMPI_uint32)
 
1326
            {
 
1327
              switch (data.value.uint32)
 
1328
                {
 
1329
                case 1:
 
1330
                  value.uint32 = _CMGetMessage (&result);
 
1331
                  break;
 
1332
                case 2:
 
1333
                  value.uint32 = _CMLogMessage (&result);
 
1334
                  break;
 
1335
                case 3:
 
1336
                  value.uint32 = _CMTraceMessage (&result);
 
1337
                  break;
 
1338
                case 4:
 
1339
                    value.uint32 = _testCMPIEnumeration (ctx);
 
1340
                    result=strdup("_testCMPIEnumeration ");
 
1341
                    break;
 
1342
                case 5:
 
1343
                    value.uint32 = _testCMPIArray ();
 
1344
                    result=strdup("_testCMPIArray ");
 
1345
                    break;
 
1346
                case 6:
 
1347
                    value.uint32 = _testCMPIcontext (ctx);
 
1348
                    result=strdup("_testCMPIContext ");
 
1349
                    break;
 
1350
                case 7:
 
1351
                    value.uint32 = _testCMPIDateTime ();
 
1352
                    result=strdup("_testCMPIDateTime ");
 
1353
                    break;
 
1354
                case 8:
 
1355
                    value.uint32 = _testCMPIInstance ();
 
1356
                    result=strdup("_testCMPIInstance ");
 
1357
                    break;
 
1358
                case 9:
 
1359
                    value.uint32 = _testCMPIObjectPath ();
 
1360
                    result=strdup("_testCMPIObjectPath ");
 
1361
                    break;
 
1362
                case 10:
 
1363
                    value.uint32 = _testCMPIResult (rslt);
 
1364
                    result=strdup("_testCMPIResult ");
 
1365
                    break;
 
1366
                case 11:
 
1367
                    value.uint32 = _testCMPIString ();
 
1368
                    result=strdup("_testCMPIString ");
 
1369
                    break;
 
1370
                case 12:
 
1371
                    value.uint32 = _testCMPIArgs ();
 
1372
                    result=strdup("_testCMPIArgs ");
 
1373
                    break;
 
1374
                default:
 
1375
                  break;
 
1376
                }
 
1377
              CMReturnData (rslt, &value, CMPI_uint32);
 
1378
              CMReturnDone (rslt);
 
1379
              rc = CMAddArg (out, "Result", (CMPIValue *) result, CMPI_chars);
 
1380
              free (result);
 
1381
            }
 
1382
          else                 
 
1383
            {
 
1384
              value.uint32 = 1;
 
1385
              CMReturnData (rslt, &value, CMPI_uint32);
 
1386
              CMReturnDone (rslt);
 
1387
            }
 
1388
        }
 
1389
 
 
1390
      else if (strncmp ("returnString", methodName, strlen ("returnString"))
 
1391
               == 0)
 
1392
        {
 
1393
          result = strdup ("Returning string");
 
1394
          CMReturnData (rslt, (CMPIValue *) result, CMPI_chars);
 
1395
          CMReturnDone (rslt);
 
1396
          free(result);
 
1397
        }
 
1398
      else if (strncmp ("returnUint32", methodName, strlen ("returnUint32"))
 
1399
               == 0)
 
1400
        {
 
1401
          value.uint32 = 42;
 
1402
 
 
1403
          CMReturnData (rslt, &value, CMPI_uint32);
 
1404
          CMReturnDone (rslt);
 
1405
        }
 
1406
      else if (
 
1407
          strncmp("returnDateTime", methodName, strlen("returnDateTime")) == 0)
 
1408
        {
 
1409
          CMPIUint64 ret_val = 0;
 
1410
          CMPIStatus dateTimeRc={CMPI_RC_OK, NULL};
 
1411
 
 
1412
          CMPIDateTime *dateTime = CMNewDateTime(_broker, &dateTimeRc);
 
1413
          // Checking the date.
 
1414
          ret_val = CMGetBinaryFormat (dateTime, &dateTimeRc);
 
1415
          if (ret_val == 0) {} 
 
1416
 
 
1417
          CMReturnData (rslt, (CMPIValue *) & dateTime, CMPI_dateTime);
 
1418
          CMReturnDone (rslt);
 
1419
        }
 
1420
    else if (
 
1421
        strncmp("testArrayTypes", methodName, strlen ("testArrayTypes"))== 0)
 
1422
    {
 
1423
        value.uint32 = _testArrayTypes();
 
1424
        CMReturnData (rslt, &value, CMPI_uint32);
 
1425
        CMReturnDone (rslt);
 
1426
    }
 
1427
    else if (
 
1428
        strncmp("testErrorPaths", methodName, strlen ("testErrorPaths")) == 0)
 
1429
    {
 
1430
        value.uint32 = _testErrorPaths();
 
1431
        CMReturnData (rslt, &value, CMPI_uint32);
 
1432
        CMReturnDone (rslt);
 
1433
    }
 
1434
    else if (
 
1435
        strncmp("testSimpleTypes", methodName, strlen ("testSimpleTypes")) == 0)
 
1436
    {
 
1437
        value.uint32 = _testSimpleTypes();
 
1438
        CMReturnData (rslt, &value, CMPI_uint32);
 
1439
        CMReturnDone (rslt);
 
1440
    }
 
1441
    else if (strncmp ("methodNotInMof", methodName, strlen ("methodNotInMof"))
 
1442
        == 0)
 
1443
    {
 
1444
        value.uint32 = 42;
 
1445
        CMReturnData (rslt, &value, CMPI_uint32);
 
1446
        CMReturnDone (rslt);
 
1447
    }
 
1448
      else
 
1449
        {
 
1450
          CMSetStatusWithChars (_broker, &rc,
 
1451
                                CMPI_RC_ERR_NOT_FOUND, methodName);
 
1452
        }
 
1453
    }
 
1454
  return rc;
 
1455
}
 
1456
 
 
1457
/* ---------------------------------------------------------------------------*/
 
1458
/*                              Provider Factory                              */
 
1459
/* ---------------------------------------------------------------------------*/
 
1460
 
 
1461
 
 
1462
CMMethodMIStub (TestMiscProvider,
 
1463
                TestMiscProvider, _broker, CMNoHook)
 
1464
 
 
1465
/* ---------------------------------------------------------------------------*/
 
1466
/*             end of TestCMPIProvider                      */
 
1467
/* ---------------------------------------------------------------------------*/