rubywbem 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,1495 @@
1
+ #
2
+ # Copyright 2006, Red Hat, Inc
3
+ # Scott Seago <sseago@redhat.com>
4
+ #
5
+ # derived from pywbem, written by Tim Potter <tpot@hp.com>, Martin Pool <mbp@hp.com>
6
+ #
7
+ # This program is free software; you can redistribute it and/or modify
8
+ # it under the terms of the GNU General Public License as published by
9
+ # the Free Software Foundation; either version 2 of the License, or
10
+ # (at your option) any later version.
11
+ #
12
+ # You should have received a copy of the GNU General Public License
13
+ # along with this program; if not, write to the Free Software
14
+ # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15
+ #
16
+
17
+ #
18
+ # Exercise routines in cim_xml by creating xml document fragments and
19
+ # passing them through a validator.
20
+ #
21
+ # TODO: Currently this forks of an instance of xmllint which is a
22
+ # little slow. It would be nicer to have an in-process validator.
23
+ #
24
+ # TODO: A bunch of tests are still unimplemented for bits of the
25
+ # schema that PyWBEM doesn't use right now.
26
+ #
27
+
28
+ require "comfychair"
29
+ require "validate"
30
+ require "wbem"
31
+
32
+ module WBEM
33
+ module Test
34
+ def WBEM.LOCALNAMESPACEPATH()
35
+ return LOCALNAMESPACEPATH.new([NAMESPACE.new('root'),
36
+ NAMESPACE.new('cimv2')])
37
+ end
38
+
39
+ def WBEM.NAMESPACEPATH()
40
+ return NAMESPACEPATH.new(
41
+ HOST.new('leonardo'), WBEM.LOCALNAMESPACEPATH())
42
+ end
43
+
44
+ def WBEM.CLASSNAME()
45
+ return CLASSNAME.new('CIM_Foo')
46
+ end
47
+
48
+ def WBEM.INSTANCENAME()
49
+ return INSTANCENAME.new(
50
+ 'CIM_Pet',
51
+ [KEYBINDING.new('type', KEYVALUE.new('dog', 'string')),
52
+ KEYBINDING.new('age', KEYVALUE.new('2', 'numeric'))])
53
+ end
54
+
55
+ class CIMXMLTest < Comfychair::TestCase
56
+ include Validate
57
+ #"""Run validate. script against an xml document fragment."""
58
+
59
+ def initialize
60
+ super
61
+ @xml = []
62
+ end
63
+ attr_reader :xml
64
+
65
+ def validate(xml, expectedResult = 0)
66
+ self.log(xml)
67
+ self.assert_(validate_xml(xml, dtd_directory = '../..'))
68
+ end
69
+
70
+ def runtest
71
+ # Test xml fragments pass validation
72
+ self.xml.each do |x|
73
+ self.validate(x.toxml)
74
+ end
75
+ end
76
+ end
77
+
78
+ class UnimplementedTest < CIMXMLTest
79
+ def runtest
80
+ raise Comfychair::NotRunError, 'unimplemented'
81
+ end
82
+ end
83
+
84
+ #################################################################
85
+ # 3.2.1. Top Level Elements
86
+ #################################################################
87
+
88
+ # 3.2.1.1. CIM
89
+
90
+ class CIM < CIMXMLTest
91
+ def setup
92
+ self.xml << WBEM::CIM.new(
93
+ MESSAGE.new(
94
+ SIMPLEREQ.new(
95
+ IMETHODCALL.new(
96
+ 'IntrinsicMethod',
97
+ WBEM.LOCALNAMESPACEPATH())),
98
+ '1001', '1.0'),
99
+ '2.0', '2.0')
100
+ end
101
+ end
102
+
103
+ #################################################################
104
+ # 3.2.2. Declaration Elements
105
+ #################################################################
106
+
107
+ # 3.2.2.1. DECLARATION
108
+ # 3.2.2.2. DECLGROUP
109
+ # 3.2.2.3. DECLGROUP.WITHNAME
110
+ # 3.2.2.4. DECLGROUP.WITHPATH
111
+ # 3.2.2.5. QUALIFIER.DECLARATION
112
+ # 3.2.2.6. SCOPE
113
+
114
+
115
+ class Declaration < UnimplementedTest
116
+ # """
117
+ # <!ELEMENT DECLARATION (DECLGROUP|DECLGROUP.WITHNAME|DECLGROUP.WITHPATH)+>
118
+ # """
119
+ end
120
+
121
+ class DeclGroup < UnimplementedTest
122
+ # """
123
+ # <!ELEMENT DECLGROUP ((LOCALNAMESPACEPATH|NAMESPACEPATH)?,
124
+ # QUALIFIER.DECLARATION*,VALUE.OBJECT*)>
125
+ # """
126
+ end
127
+
128
+ class DeclGroupWithName < UnimplementedTest
129
+ # """
130
+ # <!ELEMENT DECLGROUP.WITHNAME ((LOCALNAMESPACEPATH|NAMESPACEPATH)?,
131
+ # QUALIFIER.DECLARATION*,VALUE.NAMEDOBJECT*)>
132
+ # """
133
+ end
134
+
135
+ class DeclGroupWithPath < UnimplementedTest
136
+ # """
137
+ # <!ELEMENT DECLGROUP.WITHPATH (VALUE.OBJECTWITHPATH|
138
+ # VALUE.OBJECTWITHLOCALPATH)*>
139
+ # """
140
+ end
141
+
142
+ class QualifierDeclaration < UnimplementedTest
143
+ # """
144
+ # <!ELEMENT QUALIFIER.DECLARATION (SCOPE?, (VALUE | VALUE.ARRAY)?)>
145
+ # <!ATTLIST QUALIFIER.DECLARATION
146
+ # %CIMName;
147
+ # %CIMType; #REQUIRED
148
+ # ISARRAY (true|false) #IMPLIED
149
+ # %ArraySize;
150
+ # %QualifierFlavor;>
151
+ # """
152
+ end
153
+
154
+ class Scope < CIMXMLTest
155
+ # """
156
+ # <!ELEMENT SCOPE EMPTY>
157
+ # <!ATTLIST SCOPE
158
+ # CLASS (true|false) 'false'
159
+ # ASSOCIATION (true|false) 'false'
160
+ # REFERENCE (true|false) 'false'
161
+ # PROPERTY (true|false) 'false'
162
+ # METHOD (true|false) 'false'
163
+ # PARAMETER (true|false) 'false'
164
+ # INDICATION (true|false) 'false'>
165
+ # """
166
+ def setup
167
+ self.xml << SCOPE.new()
168
+ end
169
+ end
170
+
171
+ #################################################################
172
+ # 3.2.3. Value Elements
173
+ #################################################################
174
+
175
+ # 3.2.3.1. VALUE
176
+ # 3.2.3.2. VALUE.ARRAY
177
+ # 3.2.3.3. VALUE.REFERENCE
178
+ # 3.2.3.4. VALUE.REFARRAY
179
+ # 3.2.3.5. VALUE.OBJECT
180
+ # 3.2.3.6. VALUE.NAMEDINSTANCE
181
+ # 3.2.3.7. VALUE.NAMEDOBJECT
182
+ # 3.2.3.8. VALUE.OBJECTWITHPATH
183
+ # 3.2.3.9. VALUE.OBJECTWITHLOCALPATH
184
+ # 3.2.3.10. VALUE.NULL
185
+
186
+ class Value < CIMXMLTest
187
+ # """
188
+ # <!ELEMENT VALUE (#PCDATA)>
189
+ # """
190
+ def setup
191
+ self.xml << VALUE.new('dog')
192
+ self.xml << VALUE.new(nil)
193
+ self.xml << VALUE.new('')
194
+ end
195
+ end
196
+
197
+ class ValueArray < CIMXMLTest
198
+ # """
199
+ # <!ELEMENT VALUE.ARRAY (VALUE*)>
200
+ # """
201
+ def setup
202
+ self.xml << VALUE_ARRAY.new([])
203
+ self.xml << VALUE_ARRAY.new([VALUE.new('cat'), VALUE.new('dog')])
204
+ end
205
+ end
206
+
207
+ class ValueReference < CIMXMLTest
208
+ # """
209
+ # <!ELEMENT VALUE.REFERENCE (CLASSPATH|LOCALCLASSPATH|CLASSNAME|
210
+ # INSTANCEPATH|LOCALINSTANCEPATH|INSTANCENAME)>
211
+ # """
212
+ def setup
213
+
214
+ # CLASSPATH
215
+ self.xml << VALUE_REFERENCE.new(CLASSPATH.new(WBEM.NAMESPACEPATH(), WBEM.CLASSNAME()))
216
+
217
+ # LOCALCLASSPATH
218
+ self.xml << VALUE_REFERENCE.new(LOCALCLASSPATH.new(WBEM.LOCALNAMESPACEPATH(),
219
+ WBEM.CLASSNAME()))
220
+
221
+ # CLASSNAME
222
+ self.xml << VALUE_REFERENCE.new(WBEM.CLASSNAME())
223
+
224
+ # INSTANCEPATH
225
+ self.xml << VALUE_REFERENCE.new(INSTANCEPATH.new(WBEM.NAMESPACEPATH(),
226
+ WBEM.INSTANCENAME()))
227
+
228
+ # LOCALINSTANCEPATH
229
+ self.xml << VALUE_REFERENCE.new(LOCALINSTANCEPATH.new(WBEM.LOCALNAMESPACEPATH(),
230
+ WBEM.INSTANCENAME()))
231
+
232
+ # INSTANCENAME
233
+ self.xml << VALUE_REFERENCE.new(WBEM.INSTANCENAME())
234
+ end
235
+ end
236
+
237
+ class ValueRefArray < CIMXMLTest
238
+ # """
239
+ # <!ELEMENT VALUE.REFARRAY (VALUE.REFERENCE*)>
240
+ # """
241
+
242
+ def setup
243
+
244
+ # Empty
245
+ self.xml << VALUE_REFARRAY.new([])
246
+
247
+ # VALUE.REFARRAY
248
+ self.xml << VALUE_REFARRAY.new(
249
+ [VALUE_REFERENCE.new(WBEM.CLASSNAME()),
250
+ VALUE_REFERENCE.new(LOCALCLASSPATH.new(WBEM.LOCALNAMESPACEPATH(),
251
+ WBEM.CLASSNAME()))])
252
+ end
253
+ end
254
+
255
+ class ValueObject < CIMXMLTest
256
+ # """
257
+ # <!ELEMENT VALUE.OBJECT (CLASS|INSTANCE)>
258
+ # """
259
+ def setup
260
+
261
+ # CLASS
262
+ self.xml << VALUE_OBJECT.new(CLASS.new('CIM_Foo'))
263
+
264
+ # INSTANCE
265
+ self.xml << VALUE_OBJECT.new(INSTANCE.new('CIM_Pet', []))
266
+ end
267
+ end
268
+
269
+ class ValueNamedInstance < CIMXMLTest
270
+ # """
271
+ # <!ELEMENT VALUE.NAMEDINSTANCE (INSTANCENAME,INSTANCE)>
272
+ # """
273
+ def setup
274
+ self.xml << VALUE_NAMEDINSTANCE.new(WBEM.INSTANCENAME(),
275
+ INSTANCE.new('CIM_Pet', []))
276
+ end
277
+ end
278
+
279
+ class ValueNamedObject < CIMXMLTest
280
+ # """
281
+ # <!ELEMENT VALUE.NAMEDOBJECT (CLASS|(INSTANCENAME,INSTANCE))>
282
+ # """
283
+ def setup
284
+
285
+ # CLASS
286
+ self.xml << VALUE_NAMEDOBJECT.new(CLASS.new('CIM_Foo'))
287
+
288
+ # INSTANCENAME, INSTANCE
289
+ self.xml << VALUE_NAMEDOBJECT.new([WBEM.INSTANCENAME(),
290
+ INSTANCE.new('CIM_Pet', [])])
291
+ end
292
+ end
293
+
294
+ class ValueObjectWithPath < CIMXMLTest
295
+ # """
296
+ # <!ELEMENT VALUE.OBJECTWITHPATH ((CLASSPATH,CLASS)|
297
+ # (INSTANCEPATH,INSTANCE))>
298
+ # """
299
+
300
+ def setup
301
+
302
+ # (CLASSPATH, CLASS)
303
+ self.xml << VALUE_OBJECTWITHPATH.new(CLASSPATH.new(WBEM.NAMESPACEPATH(),
304
+ WBEM.CLASSNAME()),
305
+ CLASS.new('CIM_Foo'))
306
+
307
+ # (INSTANCEPATH, INSTANCE)
308
+ self.xml << VALUE_OBJECTWITHPATH.new(INSTANCEPATH.new(WBEM.NAMESPACEPATH(),
309
+ WBEM.INSTANCENAME()),
310
+ INSTANCE.new('CIM_Pet', []))
311
+ end
312
+ end
313
+
314
+ class ValueObjectWithLocalPath < CIMXMLTest
315
+ # """
316
+ # <!ELEMENT VALUE.OBJECTWITHLOCALPATH ((LOCALCLASSPATH,CLASS)|
317
+ # (LOCALINSTANCEPATH,INSTANCE))>
318
+ # """
319
+
320
+ def setup
321
+
322
+ # (LOCALCLASSPATH, CLASS)
323
+ self.xml << VALUE_OBJECTWITHLOCALPATH.new(LOCALCLASSPATH.new(WBEM.LOCALNAMESPACEPATH(),
324
+ WBEM.CLASSNAME()),
325
+ CLASS.new('CIM_Foo'))
326
+
327
+ # (LOCALINSTANCEPATH, INSTANCE)
328
+ self.xml << VALUE_OBJECTWITHLOCALPATH.new(LOCALINSTANCEPATH.new(WBEM.LOCALNAMESPACEPATH(),
329
+ WBEM.INSTANCENAME()),
330
+ INSTANCE.new('CIM_Pet', []))
331
+ end
332
+ end
333
+
334
+ class ValueNull < UnimplementedTest
335
+ # """
336
+ # <!ELEMENT VALUE.NULL EMPTY>
337
+ # """
338
+ end
339
+
340
+ #################################################################
341
+ # 3.2.4. Naming and Location Elements
342
+ #################################################################
343
+
344
+ # 3.2.4.1. NAMESPACEPATH
345
+ # 3.2.4.2. LOCALNAMESPACEPATH
346
+ # 3.2.4.3. HOST
347
+ # 3.2.4.4. NAMESPACE
348
+ # 3.2.4.5. CLASSPATH
349
+ # 3.2.4.6. LOCALCLASSPATH
350
+ # 3.2.4.7. CLASSNAME
351
+ # 3.2.4.8. INSTANCEPATH
352
+ # 3.2.4.9. LOCALINSTANCEPATH
353
+ # 3.2.4.10. INSTANCENAME
354
+ # 3.2.4.11. OBJECTPATH
355
+ # 3.2.4.12. KEYBINDING
356
+ # 3.2.4.13. KEYVALUE
357
+
358
+ class NamespacePath < CIMXMLTest
359
+ # """
360
+ # <!ELEMENT NAMESPACEPATH (HOST,LOCALNAMESPACEPATH)>
361
+ # """
362
+ def setup
363
+ self.xml << WBEM.NAMESPACEPATH()
364
+ end
365
+ end
366
+
367
+ class LocalNamespacePath < CIMXMLTest
368
+ # """
369
+ # <!ELEMENT LOCALNAMESPACEPATH (NAMESPACE+)>
370
+ # """
371
+ def setup
372
+ self.xml << WBEM.LOCALNAMESPACEPATH()
373
+ end
374
+ end
375
+
376
+ class Host < CIMXMLTest
377
+ # """
378
+ # <!ELEMENT HOST (#PCDATA)>
379
+ # """
380
+ def setup
381
+ self.xml << HOST.new('leonardo')
382
+ end
383
+ end
384
+
385
+ class Namespace < CIMXMLTest
386
+ # """
387
+ # <!ELEMENT NAMESPACE EMPTY>
388
+ # <!ATTLIST NAMESPACE
389
+ # %CIMName;>
390
+ # """
391
+ def setup
392
+ self.xml << NAMESPACE.new('root')
393
+ end
394
+ end
395
+
396
+ class ClassPath < CIMXMLTest
397
+ # """
398
+ # <!ELEMENT CLASSPATH (NAMESPACEPATH,CLASSNAME)>
399
+ # """
400
+ def setup
401
+ self.xml << CLASSPATH.new(WBEM.NAMESPACEPATH(), WBEM.CLASSNAME())
402
+ end
403
+ end
404
+
405
+ class LocalClassPath < CIMXMLTest
406
+ # """
407
+ # <!ELEMENT LOCALCLASSPATH (LOCALNAMESPACEPATH, CLASSNAME)>
408
+ # """
409
+ def setup
410
+ self.xml << LOCALCLASSPATH.new(WBEM.LOCALNAMESPACEPATH(), WBEM.CLASSNAME())
411
+ end
412
+ end
413
+
414
+ class ClassName < CIMXMLTest
415
+ # """
416
+ # <!ELEMENT CLASSNAME EMPTY>
417
+ # <!ATTLIST CLASSNAME
418
+ # %CIMName;>
419
+ # """
420
+ def setup
421
+ self.xml << WBEM.CLASSNAME()
422
+ end
423
+ end
424
+
425
+ class InstancePath < CIMXMLTest
426
+ # """
427
+ # <!ELEMENT INSTANCEPATH (NAMESPACEPATH,INSTANCENAME)>
428
+ # """
429
+ def setup
430
+ self.xml << INSTANCEPATH.new(WBEM.NAMESPACEPATH(), WBEM.INSTANCENAME())
431
+ end
432
+ end
433
+
434
+ class LocalInstancePath < CIMXMLTest
435
+ # """
436
+ # <!ELEMENT LOCALINSTANCEPATH (LOCALNAMESPACEPATH,INSTANCENAME)>
437
+ # """
438
+ def setup
439
+ self.xml << LOCALINSTANCEPATH.new(WBEM.LOCALNAMESPACEPATH(),
440
+ WBEM.INSTANCENAME())
441
+ end
442
+ end
443
+
444
+ class InstanceName < CIMXMLTest
445
+ # """
446
+ # <!ELEMENT INSTANCENAME (KEYBINDING*|KEYVALUE?|VALUE.REFERENCE?)>
447
+ # <!ATTLIST INSTANCENAME
448
+ # %ClassName;>
449
+ # """
450
+ def setup
451
+
452
+ # Empty
453
+ self.xml << INSTANCENAME.new('CIM_Pet', nil)
454
+
455
+ # KEYBINDING
456
+ self.xml << WBEM.INSTANCENAME()
457
+
458
+ # KEYVALUE
459
+ self.xml << INSTANCENAME.new('CIM_Pet', KEYVALUE.new('FALSE', 'boolean'))
460
+
461
+ # VALUE.REFERENCE
462
+ self.xml << INSTANCENAME.new('CIM_Pet',
463
+ VALUE_REFERENCE.new(WBEM.INSTANCENAME()))
464
+ end
465
+ end
466
+
467
+ class ObjectPath < CIMXMLTest
468
+ # """
469
+ # <!ELEMENT OBJECTPATH (INSTANCEPATH|CLASSPATH)>
470
+ # """
471
+
472
+ def setup
473
+
474
+ self.xml << OBJECTPATH.new(INSTANCEPATH.new(WBEM.NAMESPACEPATH(),
475
+ WBEM.INSTANCENAME()))
476
+
477
+ self.xml << OBJECTPATH.new(CLASSPATH.new(WBEM.NAMESPACEPATH(),
478
+ WBEM.CLASSNAME()))
479
+ end
480
+ end
481
+
482
+ class KeyBinding < CIMXMLTest
483
+ # """
484
+ # <!ELEMENT KEYBINDING (KEYVALUE|VALUE.REFERENCE)>
485
+ # <!ATTLIST KEYBINDING
486
+ # %CIMName;>
487
+ # """
488
+ def setup
489
+
490
+ self.xml << KEYBINDING.new('pet', KEYVALUE.new('dog', 'string'))
491
+
492
+ self.xml << KEYBINDING.new(
493
+ 'CIM_Foo',
494
+ VALUE_REFERENCE.new(
495
+ CLASSPATH.new(WBEM.NAMESPACEPATH(), WBEM.CLASSNAME())))
496
+ end
497
+ end
498
+
499
+ class KeyValue < CIMXMLTest
500
+ # """
501
+ # <!ELEMENT KEYVALUE (#PCDATA)>
502
+ # <!ATTLIST KEYVALUE
503
+ # VALUETYPE (string|boolean|numeric) 'string'
504
+ # %CIMType; #IMPLIED>
505
+ # """
506
+ def setup
507
+ self.xml << KEYVALUE.new('dog', 'string')
508
+ self.xml << KEYVALUE.new('2', 'numeric')
509
+ self.xml << KEYVALUE.new('FALSE', 'boolean')
510
+ self.xml << KEYVALUE.new('2', 'numeric', 'uint16')
511
+ self.xml << KEYVALUE.new(nil)
512
+ end
513
+ end
514
+
515
+ #################################################################
516
+ # 3.2.5. Object Definition Elements
517
+ #################################################################
518
+
519
+ # 3.2.5.1. CLASS
520
+ # 3.2.5.2. INSTANCE
521
+ # 3.2.5.3. QUALIFIER
522
+ # 3.2.5.4. PROPERTY
523
+ # 3.2.5.5. PROPERTY.ARRAY
524
+ # 3.2.5.6. PROPERTY.REFERENCE
525
+ # 3.2.5.7. METHOD
526
+ # 3.2.5.8. PARAMETER
527
+ # 3.2.5.9. PARAMETER.REFERENCE
528
+ # 3.2.5.10. PARAMETER.ARRAY
529
+ # 3.2.5.11. PARAMETER.REFARRAY
530
+ # 3.2.5.12. TABLECELL.DECLARATION
531
+ # 3.2.5.13. TABLECELL.REFERENCE
532
+ # 3.2.5.14. TABLEROW.DECLARATION
533
+ # 3.2.5.15. TABLE
534
+ # 3.2.5.16. TABLEROW
535
+
536
+ class Class < CIMXMLTest
537
+ # """
538
+ # <!ELEMENT CLASS (QUALIFIER*,(PROPERTY|PROPERTY.ARRAY|PROPERTY.REFERENCE)*,
539
+ # METHOD*)>
540
+ # <!ATTLIST CLASS
541
+ # %CIMName;
542
+ # %SuperClass;>
543
+ # """
544
+ def setup
545
+
546
+ # Empty
547
+ self.xml << CLASS.new('CIM_Foo')
548
+
549
+ # PROPERTY
550
+ self.xml << CLASS.new('CIM_Foo', [PROPERTY.new('Dog', 'string',
551
+ VALUE.new('Spotty'))])
552
+
553
+ # QUALIFIER + PROPERTY
554
+ self.xml << CLASS.new('CIM_Foo',
555
+ [PROPERTY.new('Dog', 'string', VALUE.new('Spotty'))],
556
+ [],
557
+ [QUALIFIER.new('IMPISH', 'string', VALUE.new('true'))])
558
+
559
+ # PROPERTY.ARRAY
560
+
561
+ self.xml << CLASS.new('CIM_Foo',
562
+ [PROPERTY_ARRAY.new('Dogs', 'string', nil)])
563
+
564
+ # PROPERTY.REFERENCE
565
+
566
+ self.xml << CLASS.new('CIM_Foo',
567
+ [PROPERTY_REFERENCE.new('Dogs', nil)])
568
+
569
+ # METHOD
570
+
571
+ self.xml << CLASS.new('CIM_Foo', [],
572
+ [METHOD.new('FooMethod')])
573
+ end
574
+ end
575
+
576
+ class Instance < CIMXMLTest
577
+ # """
578
+ # <!ELEMENT INSTANCE (QUALIFIER*,(PROPERTY|PROPERTY.ARRAY|
579
+ # PROPERTY.REFERENCE)*)>
580
+ # <!ATTLIST INSTANCE
581
+ # %ClassName;
582
+ # xml:lang NMTOKEN #IMPLIED>
583
+ # """
584
+ def setup
585
+
586
+ # Empty
587
+ self.xml << INSTANCE.new('CIM_Foo', [])
588
+
589
+ # PROPERTY
590
+ self.xml << INSTANCE.new(
591
+ 'CIM_Foo',
592
+ [PROPERTY.new('Dog', 'string', VALUE.new('Spotty')),
593
+ PROPERTY.new('Cat', 'string', VALUE.new('Bella'))])
594
+
595
+ # PROPERTY + QUALIFIER
596
+
597
+ self.xml << INSTANCE.new(
598
+ 'CIM_Foo',
599
+ [PROPERTY.new('Dog', 'string', VALUE.new('Spotty')),
600
+ PROPERTY.new('Cat', 'string', VALUE.new('Bella'))],
601
+ [QUALIFIER.new('IMPISH', 'string', VALUE.new('true'))])
602
+
603
+ # PROPERTY.ARRAY
604
+ self.xml << INSTANCE.new(
605
+ 'CIM_Pets',
606
+ [PROPERTY_ARRAY.new(
607
+ 'Dogs',
608
+ 'string',
609
+ VALUE_ARRAY.new([VALUE.new('Spotty'),
610
+ VALUE.new('Bronte')])),
611
+ PROPERTY_ARRAY.new(
612
+ 'Cats',
613
+ 'string',
614
+ VALUE_ARRAY.new([VALUE.new('Bella'),
615
+ VALUE.new('Faux Lily')]))])
616
+
617
+ # PROPERTY.REFERENCE
618
+ self.xml << INSTANCE.new(
619
+ 'CIM_Pets',
620
+ [PROPERTY_REFERENCE.new(
621
+ 'Dog',
622
+ VALUE_REFERENCE.new(CLASSNAME.new('CIM_Dog'))),
623
+ PROPERTY_REFERENCE.new(
624
+ 'Cat',
625
+ VALUE_REFERENCE.new(CLASSNAME.new('CIM_Cat')))])
626
+ end
627
+ end
628
+
629
+ class Qualifier < CIMXMLTest
630
+ # """
631
+ # <!ELEMENT QUALIFIER (VALUE | VALUE.ARRAY)>
632
+ # <!ATTLIST QUALIFIER
633
+ # %CIMName;
634
+ # %CIMType; #REQUIRED
635
+ # %Propagated;
636
+ # %QualifierFlavor;
637
+ # xml:lang NMTOKEN #IMPLIED>
638
+ # """
639
+ def setup
640
+
641
+ # Note: DTD 2.2 allows qualifier to be empty
642
+
643
+ # VALUE
644
+ self.xml << QUALIFIER.new('IMPISH', 'string', VALUE.new('true'))
645
+
646
+ # VALUE + attributes
647
+ self.xml << QUALIFIER.new('Key', 'string', VALUE.new('true'),
648
+ nil, 'true')
649
+ self.xml << QUALIFIER.new('Description', 'string', VALUE.new('blahblah'),
650
+ nil, nil, nil, 'true')
651
+ self.xml << QUALIFIER.new('Version', 'string', VALUE.new('foorble'),
652
+ nil, 'false', nil, 'true')
653
+
654
+ # VALUE.ARRAY
655
+ self.xml << QUALIFIER.new('LUCKYNUMBERS', 'uint32',
656
+ VALUE_ARRAY.new([VALUE.new('1'), VALUE.new('2')]))
657
+ end
658
+ end
659
+
660
+ class Property < CIMXMLTest
661
+ # """
662
+ # <!ELEMENT PROPERTY (QUALIFIER*,VALUE?)>
663
+ # <!ATTLIST PROPERTY
664
+ # %CIMName;
665
+ # %CIMType; #REQUIRED
666
+ # %ClassOrigin;
667
+ # %Propagated;
668
+ # xml:lang NMTOKEN #IMPLIED>
669
+ # """
670
+ def setup
671
+
672
+ # Empty
673
+ self.xml << PROPERTY.new('PropertyName', 'string', nil)
674
+
675
+ # PROPERTY
676
+ self.xml << PROPERTY.new('PropertyName', 'string', VALUE.new('dog'))
677
+
678
+ # PROPERTY + attributes
679
+ self.xml << PROPERTY.new('PropertyName', 'string', VALUE.new('dog'),
680
+ 'CIM_Pets', 'true')
681
+
682
+ # PROPERTY + QUALIFIER
683
+ self.xml << PROPERTY.new('PropertyName', 'string', VALUE.new('dog'),
684
+ nil, nil, [QUALIFIER.new('IMPISH', 'string',
685
+ VALUE.new('true'))])
686
+ end
687
+ end
688
+
689
+ class PropertyArray < CIMXMLTest
690
+ # """
691
+ # <!ELEMENT PROPERTY.ARRAY (QUALIFIER*,VALUE.ARRAY?)>
692
+ # <!ATTLIST PROPERTY.ARRAY
693
+ # %CIMName;
694
+ # %CIMType; #REQUIRED
695
+ # %ArraySize;
696
+ # %ClassOrigin;
697
+ # %Propagated;
698
+ # xml:lang NMTOKEN #IMPLIED>
699
+ #
700
+ # """
701
+ def setup
702
+
703
+ # Empty
704
+ self.xml << PROPERTY_ARRAY.new('Dogs', 'string')
705
+
706
+ # VALUE.ARRAY
707
+ self.xml << PROPERTY_ARRAY.new('Dogs', 'string',
708
+ VALUE_ARRAY.new([VALUE.new('Spotty'),
709
+ VALUE.new('Bronte')]))
710
+
711
+ # VALUE.ARRAY + attributes
712
+ self.xml << PROPERTY_ARRAY.new('Dogs', 'string',
713
+ VALUE_ARRAY.new([VALUE.new('Spotty'),
714
+ VALUE.new('Bronte')]),
715
+ '2', 'CIM_Dog')
716
+
717
+ self.xml << PROPERTY_ARRAY.new('Dogs', 'string', nil)
718
+
719
+ # QUALIFIER + VALUE.ARRAY
720
+ self.xml << PROPERTY_ARRAY.new('Dogs', 'string',
721
+ VALUE_ARRAY.new([VALUE.new('Spotty'),
722
+ VALUE.new('Bronte')]),
723
+ nil, nil, nil,
724
+ [QUALIFIER.new('IMPISH', 'string',
725
+ VALUE.new('true'))])
726
+ end
727
+ end
728
+
729
+ class PropertyReference < CIMXMLTest
730
+ # """
731
+ # <!ELEMENT PROPERTY.REFERENCE (QUALIFIER*,VALUE.REFERENCE?)>
732
+ # <!ATTLIST PROPERTY.REFERENCE
733
+ # %CIMName;
734
+ # %ReferenceClass;
735
+ # %ClassOrigin;
736
+ # %Propagated;>
737
+ # """
738
+ def setup
739
+
740
+ # Empty
741
+ self.xml << PROPERTY_REFERENCE.new('Dogs', nil)
742
+
743
+ # VALUE.REFERENCE
744
+ self.xml << PROPERTY_REFERENCE.new('Dogs',
745
+ VALUE_REFERENCE.new(CLASSNAME.new('CIM_Dog')))
746
+
747
+ # VALUE.REFERENCE + attributes
748
+ self.xml << PROPERTY_REFERENCE.new('Dogs',
749
+ VALUE_REFERENCE.new(CLASSNAME.new('CIM_Dog')),
750
+ 'CIM_Dog', 'CIM_Dog', 'true')
751
+
752
+ # QUALIFIER + VALUE.REFERENCE
753
+ self.xml << PROPERTY_REFERENCE.new('Dogs',
754
+ VALUE_REFERENCE.new(CLASSNAME.new('CIM_Dog')),
755
+ nil, nil, nil,
756
+ [QUALIFIER.new('IMPISH', 'string', VALUE.new('true'))])
757
+ end
758
+ end
759
+
760
+ class Method < CIMXMLTest
761
+ # """
762
+ # <!ELEMENT METHOD (QUALIFIER*,(PARAMETER|PARAMETER.REFERENCE|
763
+ # PARAMETER.ARRAY|PARAMETER.REFARRAY)*)>
764
+ # <!ATTLIST METHOD
765
+ # %CIMName;
766
+ # %CIMType; #IMPLIED
767
+ # %ClassOrigin;
768
+ # %Propagated;>
769
+ # """
770
+ def setup
771
+
772
+ # Empty
773
+ self.xml << METHOD.new('FooMethod')
774
+
775
+ # PARAMETER
776
+ self.xml << METHOD.new('FooMethod', [PARAMETER.new('arg', 'string')])
777
+
778
+ # PARAMETER.REFERENCE
779
+ self.xml << METHOD.new('FooMethod', [PARAMETER_REFERENCE.new('arg', 'CIM_Foo')])
780
+
781
+ # PARAMETER.ARRAY
782
+ self.xml << METHOD.new('FooMethod', [PARAMETER_ARRAY.new('arg', 'string')])
783
+
784
+ # PARAMETER.REFARRAY
785
+ self.xml << METHOD.new('FooMethod', [PARAMETER_REFARRAY.new('arg', 'CIM_Foo')])
786
+
787
+ # PARAMETER + attributes
788
+ self.xml << METHOD.new('FooMethod', [PARAMETER.new('arg', 'string')],
789
+ 'uint32', 'CIM_Foo', 'true')
790
+
791
+ # QUALIFIER + PARAMETER
792
+ self.xml << METHOD.new('FooMethod', [PARAMETER.new('arg', 'string')],
793
+ nil, nil, nil,
794
+ [QUALIFIER.new('IMPISH', 'string', VALUE.new('true'))])
795
+ end
796
+ end
797
+
798
+ class Parameter < CIMXMLTest
799
+ # """
800
+ # <!ELEMENT PARAMETER (QUALIFIER*)>
801
+ # <!ATTLIST PARAMETER
802
+ # %CIMName;
803
+ # %CIMType; #REQUIRED>
804
+ # """
805
+ def setup
806
+
807
+ # Empty
808
+ self.xml << PARAMETER.new('arg', 'string')
809
+
810
+ # QUALIFIER
811
+ self.xml << PARAMETER.new('arg', 'string',
812
+ [QUALIFIER.new('IMPISH', 'string',
813
+ VALUE.new('true'))])
814
+ end
815
+ end
816
+
817
+ class ParameterReference < CIMXMLTest
818
+ # """
819
+ # <!ELEMENT PARAMETER.REFERENCE (QUALIFIER*)>
820
+ # <!ATTLIST PARAMETER.REFERENCE
821
+ # %CIMName;
822
+ # %ReferenceClass;>
823
+ # """
824
+ def setup
825
+
826
+ # Empty
827
+ self.xml << PARAMETER_REFERENCE.new('arg')
828
+
829
+ # QUALIFIER + attributes
830
+ self.xml << PARAMETER_REFERENCE.new('arg', 'CIM_Foo',
831
+ [QUALIFIER.new('IMPISH', 'string', VALUE.new('true'))])
832
+ end
833
+ end
834
+
835
+ class ParameterArray < CIMXMLTest
836
+ # """
837
+ # <!ELEMENT PARAMETER.ARRAY (QUALIFIER*)>
838
+ # <!ATTLIST PARAMETER.ARRAY
839
+ # %CIMName;
840
+ # %CIMType; #REQUIRED
841
+ # %ArraySize;>
842
+ # """
843
+ def setup
844
+
845
+ # Empty
846
+ self.xml << PARAMETER_ARRAY.new('arg', 'string')
847
+
848
+ # QUALIFIERS + attributes
849
+ self.xml << PARAMETER_ARRAY.new('arg', 'string', '0',
850
+ [QUALIFIER.new('IMPISH', 'string', VALUE.new('true'))])
851
+ end
852
+ end
853
+
854
+ class ParameterReferenceArray < CIMXMLTest
855
+ # """
856
+ # <!ELEMENT PARAMETER.REFARRAY (QUALIFIER*)>
857
+ # <!ATTLIST PARAMETER.REFARRAY
858
+ # %CIMName;
859
+ # %ReferenceClass;
860
+ # %ArraySize;>
861
+ # """
862
+ def setup
863
+
864
+ # Empty
865
+ self.xml << PARAMETER_REFARRAY.new('arg')
866
+
867
+ # QUALIFIERS + attributes
868
+ self.xml << PARAMETER_REFARRAY.new('arg', 'CIM_Foo', '0',
869
+ [QUALIFIER.new('IMPISH', 'string', VALUE.new('true'))])
870
+ end
871
+ end
872
+
873
+ # New in v2.2 of the DTD
874
+
875
+ # TABLECELL.DECLARATION
876
+ # TABLECELL.REFERENCE
877
+ # TABLEROW.DECLARATION
878
+ # TABLE
879
+ # TABLEROW
880
+
881
+ #################################################################
882
+ # 3.2.6. Message Elements
883
+ #################################################################
884
+
885
+ # 3.2.6.1. MESSAGE
886
+ # 3.2.6.2. MULTIREQ
887
+ # 3.2.6.3. SIMPLEREQ
888
+ # 3.2.6.4. METHODCALL
889
+ # 3.2.6.5. PARAMVALUE
890
+ # 3.2.6.6. IMETHODCALL
891
+ # 3.2.6.7. IPARAMVALUE
892
+ # 3.2.6.8. MULTIRSP
893
+ # 3.2.6.9. SIMPLERSP
894
+ # 3.2.6.10. METHODRESPONSE
895
+ # 3.2.6.11. IMETHODRESPONSE
896
+ # 3.2.6.12. ERROR
897
+ # 3.2.6.13. RETURNVALUE
898
+ # 3.2.6.14. IRETURNVALUE
899
+ # 3.2.6.15 MULTIEXPREQ
900
+ # 3.2.6.16 SIMPLEEXPREQ
901
+ # 3.2.6.17 EXPMETHODCALL
902
+ # 3.2.6.18 MULTIEXPRSP
903
+ # 3.2.6.19 SIMPLEEXPRSP
904
+ # 3.2.6.20 EXPMETHODRESPONSE
905
+ # 3.2.6.21 EXPPARAMVALUE
906
+ # 3.2.6.22 RESPONSEDESTINATION
907
+ # 3.2.6.23 SIMPLEREQACK
908
+
909
+ class Message < CIMXMLTest
910
+ # """
911
+ # <!ELEMENT MESSAGE (SIMPLEREQ | MULTIREQ | SIMPLERSP | MULTIRSP |
912
+ # SIMPLEEXPREQ | MULTIEXPREQ | SIMPLEEXPRSP |
913
+ # MULTIEXPRSP)>
914
+ # <!ATTLIST MESSAGE
915
+ # ID CDATA #REQUIRED
916
+ # PROTOCOLVERSION CDATA #REQUIRED>
917
+ # """
918
+ def setup
919
+
920
+ # SIMPLEREQ
921
+ self.xml << MESSAGE.new(
922
+ SIMPLEREQ.new(
923
+ IMETHODCALL.new(
924
+ 'FooMethod',
925
+ WBEM.LOCALNAMESPACEPATH())),
926
+ '1001', '1.0')
927
+
928
+ # MULTIREQ
929
+ self.xml << MESSAGE.new(
930
+ MULTIREQ.new(
931
+ [SIMPLEREQ.new(IMETHODCALL.new(
932
+ 'FooMethod',
933
+ WBEM.LOCALNAMESPACEPATH())),
934
+ SIMPLEREQ.new(IMETHODCALL.new(
935
+ 'FooMethod',
936
+ WBEM.LOCALNAMESPACEPATH()))]),
937
+ '1001', '1.0')
938
+
939
+ # SIMPLERSP
940
+ self.xml << MESSAGE.new(
941
+ SIMPLERSP.new(
942
+ IMETHODRESPONSE.new('FooMethod')),
943
+ '1001', '1.0')
944
+
945
+ # MULTIRSP
946
+ self.xml << MESSAGE.new(
947
+ MULTIRSP.new(
948
+ [SIMPLERSP.new(IMETHODRESPONSE.new('FooMethod')),
949
+ SIMPLERSP.new(IMETHODRESPONSE.new('FooMethod'))]),
950
+ '1001', '1.0')
951
+ end
952
+ end
953
+
954
+ # TODO:
955
+
956
+ # SIMPLEEXPREQ
957
+ # MULTIEXPREQ
958
+ # SIMPLEEXPRSP
959
+ # MULTIEXPRSP
960
+
961
+ class MultiReq < CIMXMLTest
962
+ # """
963
+ # <!ELEMENT MULTIREQ (SIMPLEREQ, SIMPLEREQ+)>
964
+ # """
965
+ def setup
966
+ self.xml << MULTIREQ.new(
967
+ [SIMPLEREQ.new(IMETHODCALL.new(
968
+ 'FooMethod',
969
+ WBEM.LOCALNAMESPACEPATH())),
970
+ SIMPLEREQ.new(IMETHODCALL.new(
971
+ 'FooMethod',
972
+ WBEM.LOCALNAMESPACEPATH()))])
973
+ end
974
+ end
975
+
976
+ class MultiExpReq < CIMXMLTest
977
+ # """
978
+ # <!ELEMENT MULTIEXPREQ (SIMPLEEXPREQ, SIMPLEEXPREQ+)>
979
+ # """
980
+ def setup
981
+ self.xml << MULTIEXPREQ.new(
982
+ [SIMPLEEXPREQ.new(EXPMETHODCALL.new('FooMethod')),
983
+ SIMPLEEXPREQ.new(EXPMETHODCALL.new('FooMethod'))])
984
+ end
985
+ end
986
+
987
+ class SimpleReq < CIMXMLTest
988
+ # """
989
+ # <!ELEMENT SIMPLEREQ (IMETHODCALL | METHODCALL)>
990
+ # """
991
+ def setup
992
+
993
+ # IMETHODCALL
994
+ self.xml << SIMPLEREQ.new(
995
+ IMETHODCALL.new('FooIMethod', WBEM.LOCALNAMESPACEPATH()))
996
+
997
+ # METHODCALL
998
+ self.xml << SIMPLEREQ.new(
999
+ METHODCALL.new(
1000
+ 'FooMethod',
1001
+ LOCALCLASSPATH.new(WBEM.LOCALNAMESPACEPATH(), WBEM.CLASSNAME())))
1002
+ end
1003
+ end
1004
+
1005
+ class SimpleExpReq < CIMXMLTest
1006
+ # """
1007
+ # <!ELEMENT SIMPLEEXPREQ (EXPMETHODCALL)>
1008
+ # """
1009
+ def setup
1010
+ self.xml << SIMPLEEXPREQ.new(
1011
+ EXPMETHODCALL.new('FooMethod'))
1012
+ end
1013
+ end
1014
+
1015
+ class IMethodCall < CIMXMLTest
1016
+ # """
1017
+ # <!ELEMENT IMETHODCALL (LOCALNAMESPACEPATH, IPARAMVALUE*,
1018
+ # RESPONSEDESTINATION?)>
1019
+ # <!ATTLIST IMETHODCALL
1020
+ # %CIMName;>
1021
+ # """
1022
+
1023
+ def setup
1024
+
1025
+ self.xml << IMETHODCALL.new('FooMethod', WBEM.LOCALNAMESPACEPATH())
1026
+ self.xml << IMETHODCALL.new(
1027
+ 'FooMethod2', WBEM.LOCALNAMESPACEPATH(),
1028
+ [IPARAMVALUE.new('Dog', VALUE.new('Spottyfoot'))])
1029
+ end
1030
+ end
1031
+
1032
+ # TODO: RESPONSEDESTINATION
1033
+
1034
+ class MethodCall < CIMXMLTest
1035
+ # """
1036
+ # <!ELEMENT METHODCALL ((LOCALINSTANCEPATH | LOCALCLASSPATH), PARAMVALUE*,
1037
+ # RESPONSEDESTINATION?>
1038
+ # <!ATTLIST METHODCALL
1039
+ # %CIMName;>
1040
+ # """
1041
+
1042
+ def setup
1043
+
1044
+ # LOCALINSTANCEPATH
1045
+ self.xml << METHODCALL.new('FooMethod',
1046
+ LOCALINSTANCEPATH.new(WBEM.LOCALNAMESPACEPATH(), WBEM.INSTANCENAME()))
1047
+
1048
+ # LOCALCLASSPATH
1049
+ self.xml << METHODCALL.new('FooMethod',
1050
+ LOCALCLASSPATH.new(WBEM.LOCALNAMESPACEPATH(), WBEM.CLASSNAME()))
1051
+
1052
+ # PARAMVALUEs
1053
+ self.xml << METHODCALL.new('FooMethod',
1054
+ LOCALINSTANCEPATH.new(WBEM.LOCALNAMESPACEPATH(), WBEM.INSTANCENAME()),
1055
+ [PARAMVALUE.new('Dog', VALUE.new('Spottyfoot'))])
1056
+ end
1057
+ end
1058
+
1059
+ # TODO: RESPONSEDESTINATION
1060
+
1061
+ class ExpMethodCall < CIMXMLTest
1062
+ # """
1063
+ # <!ELEMENT EXPMETHODCALL (EXPPARAMVALUE*)>
1064
+ # <!ATTLIST EXPMETHODCALL
1065
+ # %CIMName;>
1066
+ # """
1067
+ def setup
1068
+ self.xml << EXPMETHODCALL.new('FooMethod')
1069
+ self.xml << EXPMETHODCALL.new('FooMethod', [EXPPARAMVALUE.new('Dog')])
1070
+ end
1071
+ end
1072
+
1073
+ class ParamValue < CIMXMLTest
1074
+ # """
1075
+ # <!ELEMENT PARAMVALUE (VALUE | VALUE.REFERENCE | VALUE.ARRAY |
1076
+ # VALUE.REFARRAY)?>
1077
+ # <!ATTLIST PARAMVALUE
1078
+ # %CIMName;
1079
+ # %ParamType; #IMPLIED>
1080
+ # """
1081
+ def setup
1082
+
1083
+ # Empty
1084
+ self.xml << PARAMVALUE.new('Pet')
1085
+
1086
+ # VALUE
1087
+ self.xml << PARAMVALUE.new('Pet', VALUE.new('Dog'), 'string')
1088
+
1089
+ # VALUE.REFERENCE
1090
+ self.xml << PARAMVALUE.new('Pet',
1091
+ VALUE_REFERENCE.new(CLASSPATH.new(WBEM.NAMESPACEPATH(),
1092
+ WBEM.CLASSNAME())))
1093
+
1094
+ # VALUE.ARRAY
1095
+ self.xml << PARAMVALUE.new('Pet', VALUE_ARRAY.new([]))
1096
+
1097
+ # VALUE.REFARRAY
1098
+ self.xml << PARAMVALUE.new('Pet', VALUE_REFARRAY.new([]))
1099
+ end
1100
+ end
1101
+
1102
+ class IParamValue < CIMXMLTest
1103
+ # """
1104
+ # <!ELEMENT IPARAMVALUE (VALUE | VALUE.ARRAY | VALUE.REFERENCE |
1105
+ # INSTANCENAME | CLASSNAME | QUALIFIER.DECLARATION |
1106
+ # CLASS | INSTANCE | VALUE.NAMEDINSTANCE)?>
1107
+ # <!ATTLIST IPARAMVALUE
1108
+ # %CIMName;>
1109
+ # """
1110
+ def setup
1111
+
1112
+ # Empty
1113
+ self.xml << IPARAMVALUE.new('Bird')
1114
+
1115
+ # VALUE
1116
+ self.xml << IPARAMVALUE.new('Pet', VALUE.new('Dog'))
1117
+
1118
+ # VALUE.ARRAY
1119
+ self.xml << IPARAMVALUE.new('Pet', VALUE_ARRAY.new([]))
1120
+
1121
+ # VALUE.REFERENCE
1122
+ self.xml << IPARAMVALUE.new('Pet',
1123
+ VALUE_REFERENCE.new(
1124
+ CLASSPATH.new(WBEM.NAMESPACEPATH(), WBEM.CLASSNAME())))
1125
+
1126
+ # INSTANCENAME
1127
+ self.xml << IPARAMVALUE.new('Pet', WBEM.INSTANCENAME())
1128
+
1129
+ # CLASSNAME
1130
+ self.xml << IPARAMVALUE.new('Pet', WBEM.CLASSNAME())
1131
+
1132
+ # TODO: QUALIFIER.DECLARATION
1133
+
1134
+ # CLASS
1135
+ self.xml << IPARAMVALUE.new('Pet', CLASS.new('CIM_Foo'))
1136
+
1137
+ # INSTANCE
1138
+ self.xml << IPARAMVALUE.new('Pet', INSTANCE.new('CIM_Pet', []))
1139
+
1140
+ # VALUE.NAMEDINSTANCE
1141
+ self.xml << IPARAMVALUE.new('Pet',
1142
+ VALUE_NAMEDINSTANCE.new(WBEM.INSTANCENAME(), INSTANCE.new('CIM_Pet', [])))
1143
+ end
1144
+ end
1145
+
1146
+ class ExpParamValue < CIMXMLTest
1147
+ # """
1148
+ # <!ELEMENT EXPPARAMVALUE (INSTANCE? | VALUE? | METHODRESPONSE? |
1149
+ # IMETHODRESPONSE?)>
1150
+ # <!ATTLIST EXPPARAMVALUE
1151
+ # %CIMName;
1152
+ # %ParamType; #IMPLIED>
1153
+ # """
1154
+ def setup
1155
+ self.xml << EXPPARAMVALUE.new('FooParam')
1156
+ self.xml << EXPPARAMVALUE.new('FooParam', INSTANCE.new('CIM_Pet', []))
1157
+ end
1158
+ end
1159
+
1160
+ class MultiRsp < CIMXMLTest
1161
+ # """
1162
+ # <!ELEMENT MULTIRSP (SIMPLERSP, SIMPLERSP+)>
1163
+ # """
1164
+ def setup
1165
+ self.xml << MULTIRSP.new([SIMPLERSP.new(IMETHODRESPONSE.new('FooMethod')),
1166
+ SIMPLERSP.new(IMETHODRESPONSE.new('FooMethod'))])
1167
+ end
1168
+ end
1169
+
1170
+ class MultiExpRsp < CIMXMLTest
1171
+ # """
1172
+ # <!ELEMENT MULTIEXPRSP (SIMPLEEXPRSP, SIMPLEEXPRSP+)>
1173
+ # """
1174
+ def setup
1175
+ self.xml << MULTIEXPRSP.new([SIMPLEEXPRSP.new(EXPMETHODRESPONSE.new('FooMethod')),
1176
+ SIMPLEEXPRSP.new(EXPMETHODRESPONSE.new('FooMethod'))])
1177
+ end
1178
+ end
1179
+
1180
+ class SimpleRsp < CIMXMLTest
1181
+ # """
1182
+ # <!ELEMENT SIMPLERSP (METHODRESPONSE | IMETHODRESPONSE | SIMPLEREQACK>
1183
+ # """
1184
+ def setup
1185
+
1186
+ # METHODRESPONSE
1187
+ self.xml << SIMPLERSP.new(METHODRESPONSE.new('FooMethod'))
1188
+
1189
+ # IMETHODRESPONSE
1190
+ self.xml << SIMPLERSP.new(IMETHODRESPONSE.new('FooMethod'))
1191
+ end
1192
+ end
1193
+ # TODO: SIMPLEREQACK
1194
+
1195
+ class SimpleExpRsp < CIMXMLTest
1196
+ # """
1197
+ # <!ELEMENT SIMPLEEXPRSP (EXPMETHODRESPONSE)>
1198
+ # """
1199
+ def setup
1200
+ self.xml << SIMPLEEXPRSP.new(EXPMETHODRESPONSE.new('FooMethod'))
1201
+ end
1202
+ end
1203
+
1204
+ class MethodResponse < CIMXMLTest
1205
+ # """
1206
+ # <!ELEMENT METHODRESPONSE (ERROR | (RETURNVALUE?, PARAMVALUE*))>
1207
+ # <!ATTLIST METHODRESPONSE
1208
+ # %CIMName;>
1209
+ # """
1210
+ def setup
1211
+
1212
+ # ERROR
1213
+ self.xml << METHODRESPONSE.new('FooMethod', ERROR.new('123'))
1214
+
1215
+ # Empty
1216
+ self.xml << METHODRESPONSE.new('FooMethod')
1217
+
1218
+ # RETURNVALUE
1219
+ self.xml << METHODRESPONSE.new('FooMethod',
1220
+ PARAMVALUE.new('Dog', VALUE.new('Spottyfoot')))
1221
+
1222
+ # PARAMVALUE
1223
+ self.xml << METHODRESPONSE.new('FooMethod',
1224
+ PARAMVALUE.new('Dog', VALUE.new('Spottyfoot')))
1225
+
1226
+ # RETURNVALUE + PARAMVALUE
1227
+ self.xml << METHODRESPONSE.new('FooMethod',
1228
+ [RETURNVALUE.new(VALUE.new('Dog')),
1229
+ PARAMVALUE.new('Dog', VALUE.new('Spottyfoot'))])
1230
+ end
1231
+ end
1232
+
1233
+ class ExpMethodResponse < CIMXMLTest
1234
+ # """
1235
+ # <!ELEMENT EXPMETHODRESPONSE (ERROR | IRETURNVALUE?)>
1236
+ # <!ATTLIST EXPMETHODRESPONSE
1237
+ # %CIMName;>
1238
+ # """
1239
+ def setup
1240
+
1241
+ # Empty
1242
+ self.xml << EXPMETHODRESPONSE.new('FooMethod')
1243
+
1244
+ # ERROR
1245
+ self.xml << EXPMETHODRESPONSE.new('FooMethod', ERROR.new('123'))
1246
+
1247
+ # IRETURNVALUE
1248
+ self.xml << EXPMETHODRESPONSE.new('FooMethod',
1249
+ IRETURNVALUE.new(VALUE.new('Dog')))
1250
+ end
1251
+ end
1252
+
1253
+ class IMethodResponse < CIMXMLTest
1254
+ # """
1255
+ # <!ELEMENT IMETHODRESPONSE (ERROR | IRETURNVALUE?)>
1256
+ # <!ATTLIST IMETHODRESPONSE
1257
+ # %CIMName;>
1258
+ # """
1259
+ def setup
1260
+
1261
+ # Empty
1262
+ self.xml << IMETHODRESPONSE.new('FooMethod')
1263
+
1264
+ # ERROR
1265
+ self.xml << IMETHODRESPONSE.new('FooMethod', ERROR.new('123'))
1266
+
1267
+ # IRETURNVALUE
1268
+ self.xml << IMETHODRESPONSE.new('FooMethod',
1269
+ IRETURNVALUE.new(VALUE.new('Dog')))
1270
+ end
1271
+ end
1272
+
1273
+ class Error < CIMXMLTest
1274
+ # """
1275
+ # <!ELEMENT ERROR (INSTANCE*)>
1276
+ # <!ATTLIST ERROR
1277
+ # CODE CDATA #REQUIRED
1278
+ # DESCRIPTION CDATA #IMPLIED>
1279
+ # """
1280
+ def setup
1281
+ self.xml << ERROR.new('1')
1282
+ self.xml << ERROR.new('1', 'Foo not found')
1283
+ # TODO: INSTANCE*
1284
+ end
1285
+ end
1286
+
1287
+ class ReturnValue < CIMXMLTest
1288
+ # """
1289
+ # <!ELEMENT RETURNVALUE (VALUE | VALUE.REFERENCE)>
1290
+ # <!ATTLIST RETURNVALUE
1291
+ # %ParamType; #IMPLIED>
1292
+ # """
1293
+ def setup
1294
+
1295
+ # VALUE
1296
+ self.xml << RETURNVALUE.new(VALUE.new('Dog'))
1297
+
1298
+ # VALUE.REFERENCE
1299
+ self.xml << RETURNVALUE.new(VALUE_REFERENCE.new(
1300
+ CLASSPATH.new(WBEM.NAMESPACEPATH(), WBEM.CLASSNAME())))
1301
+
1302
+ # TODO: PARAMTYPE
1303
+ end
1304
+ end
1305
+
1306
+ class IReturnValue < CIMXMLTest
1307
+ # """
1308
+ # <!ELEMENT IRETURNVALUE (CLASSNAME* | INSTANCENAME* | VALUE* |
1309
+ # VALUE.OBJECTWITHPATH* |
1310
+ # VALUE.OBJECTWITHLOCALPATH* | VALUE.OBJECT* |
1311
+ # OBJECTPATH* | QUALIFIER.DECLARATION* |
1312
+ # VALUE.ARRAY? | VALUE.REFERENCE? | CLASS* |
1313
+ # INSTANCE* | VALUE.NAMEDINSTANCE*)>
1314
+ # """
1315
+ def setup
1316
+
1317
+ # Empty
1318
+ self.xml << IRETURNVALUE.new(nil)
1319
+
1320
+ # CLASSNAME
1321
+ self.xml << IRETURNVALUE.new(WBEM.CLASSNAME())
1322
+
1323
+ # INSTANCENAME
1324
+ self.xml << IRETURNVALUE.new(WBEM.INSTANCENAME())
1325
+
1326
+ # VALUE
1327
+ self.xml << IRETURNVALUE.new(VALUE.new('Dog'))
1328
+
1329
+ # VALUE.OBJECTWITHPATH
1330
+ self.xml << IRETURNVALUE.new(
1331
+ VALUE_OBJECTWITHPATH.new(
1332
+ CLASSPATH.new(WBEM.NAMESPACEPATH(), WBEM.CLASSNAME()),
1333
+ CLASS.new('CIM_Foo')))
1334
+
1335
+ # VALUE.OBJECTWITHLOCALPATH
1336
+ self.xml << IRETURNVALUE.new(
1337
+ VALUE_OBJECTWITHLOCALPATH.new(
1338
+ LOCALCLASSPATH.new(WBEM.LOCALNAMESPACEPATH(), WBEM.CLASSNAME()),
1339
+ CLASS.new('CIM_Foo')))
1340
+
1341
+ # VALUE.OBJECT
1342
+ self.xml << IRETURNVALUE.new(VALUE_OBJECT.new(INSTANCE.new('CIM_Pet', [])))
1343
+
1344
+ # OBJECTPATH
1345
+ self.xml << IRETURNVALUE.new(
1346
+ OBJECTPATH.new(INSTANCEPATH.new(
1347
+ WBEM.NAMESPACEPATH(), WBEM.INSTANCENAME())))
1348
+
1349
+ # TODO: QUALIFIER.DECLARATION
1350
+
1351
+ # VALUE.ARRAY
1352
+ self.xml << IRETURNVALUE.new(VALUE_ARRAY.new([]))
1353
+
1354
+ # VALUE.REFERENCE
1355
+ self.xml << IRETURNVALUE.new(
1356
+ VALUE_REFERENCE.new(
1357
+ CLASSPATH.new(WBEM.NAMESPACEPATH(), WBEM.CLASSNAME())))
1358
+
1359
+ # CLASS
1360
+ self.xml << IRETURNVALUE.new(CLASS.new('CIM_Foo'))
1361
+
1362
+ # INSTANCE
1363
+ self.xml << IRETURNVALUE.new(INSTANCE.new('CIM_Pet', []))
1364
+
1365
+ # VALUE.NAMEDINSTANCE
1366
+ self.xml << IRETURNVALUE.new(
1367
+ VALUE_NAMEDINSTANCE.new(WBEM.INSTANCENAME(),
1368
+ INSTANCE.new('CIM_Pet', [])))
1369
+ end
1370
+ end
1371
+
1372
+ class ResponseDestination < UnimplementedTest
1373
+ # """
1374
+ # The RESPONSEDESTINATION element contains an instance that
1375
+ # describes the desired destination for the response.
1376
+ #
1377
+ # <!ELEMENT RESPONSEDESTINATON (INSTANCE)>
1378
+ # """
1379
+ end
1380
+
1381
+ class SimpleReqAck < UnimplementedTest
1382
+ # """
1383
+ #
1384
+ # The SIMPLEREQACK defines the acknowledgement response to a Simple
1385
+ # CIM Operation asynchronous request. The ERROR subelement is used
1386
+ # to report a fundamental error which prevented the asynchronous
1387
+ # request from being initiated.
1388
+ #
1389
+ # <!ELEMENT SIMPLEREQACK (ERROR?)>
1390
+ # <!ATTLIST SIMPLEREQACK
1391
+ # INSTANCEID CDATA #REQUIRED>
1392
+ # """
1393
+ end
1394
+
1395
+ #################################################################
1396
+ # Root element
1397
+ #################################################################
1398
+
1399
+
1400
+ #################################################################
1401
+ # Main function
1402
+ #################################################################
1403
+
1404
+ TESTS = [
1405
+
1406
+ # Root element
1407
+
1408
+ CIM, # CIM
1409
+
1410
+ # Object declaration elements
1411
+
1412
+ Declaration, # DECLARATION
1413
+ DeclGroup, # DECLGROUP
1414
+ DeclGroupWithName, # DECLGROUP.WITHNAME
1415
+ DeclGroupWithPath, # DECLGROUP.WITHPATH
1416
+ QualifierDeclaration, # QUALIFIER.DECLARATION
1417
+ Scope, # SCOPE
1418
+
1419
+ # Object value elements
1420
+
1421
+ Value, # VALUE
1422
+ ValueArray, # VALUE.ARRAY
1423
+ ValueReference, # VALUE.REFERENCE
1424
+ ValueRefArray, # VALUE.REFARRAY
1425
+ ValueObject, # VALUE.OBJECT
1426
+ ValueNamedInstance, # VALUE.NAMEDINSTANCE
1427
+ ValueNamedObject, # VALUE.NAMEDOBJECT
1428
+ ValueObjectWithLocalPath, # VALUE.OBJECTWITHLOCALPATH
1429
+ ValueObjectWithPath, # VALUE.OBJECTWITHPATH
1430
+ ValueNull, # VALUE.NULL
1431
+
1432
+ # Object naming and locating elements
1433
+
1434
+ NamespacePath, # NAMESPACEPATH
1435
+ LocalNamespacePath, # LOCALNAMESPACEPATH
1436
+ Host, # HOST
1437
+ Namespace, # NAMESPACE
1438
+ ClassPath, # CLASSPATH
1439
+ LocalClassPath, # LOCALCLASSPATH
1440
+ ClassName, # CLASSNAME
1441
+ InstancePath, # INSTANCEPATH
1442
+ LocalInstancePath, # LOCALINSTANCEPATH
1443
+ InstanceName, # INSTANCENAME
1444
+ ObjectPath, # OBJECTPATH
1445
+ KeyBinding, # KEYBINDING
1446
+ KeyValue, # KEYVALUE
1447
+
1448
+ # Object definition elements
1449
+
1450
+ Class, # CLASS
1451
+ Instance, # INSTANCE
1452
+ Qualifier, # QUALIFIER
1453
+ Property, # PROPERTY
1454
+ PropertyArray, # PROPERTY.ARRY
1455
+ PropertyReference, # PROPERTY.REFERENCE
1456
+ Method, # METHOD
1457
+ Parameter, # PARAMETER
1458
+ ParameterReference, # PARAMETER.REFERENCE
1459
+ ParameterArray, # PARAMETER.ARRAY
1460
+ ParameterReferenceArray, # PARAMETER.REFARRAY
1461
+
1462
+ # Message elements
1463
+
1464
+ Message, # MESSAGE
1465
+ MultiReq, # MULTIREQ
1466
+ MultiExpReq, # MULTIEXPREQ
1467
+ SimpleReq, # SIMPLEREQ
1468
+ SimpleExpReq, # SIMPLEEXPREQ
1469
+ IMethodCall, # IMETHODCALL
1470
+ MethodCall, # METHODCALL
1471
+ ExpMethodCall, # EXPMETHODCALL
1472
+ ParamValue, # PARAMVALUE
1473
+ IParamValue, # IPARAMVALUE
1474
+ ExpParamValue, # EXPPARAMVALUE
1475
+ MultiRsp, # MULTIRSP
1476
+ MultiExpRsp, # MULTIEXPRSP
1477
+ SimpleRsp, # SIMPLERSP
1478
+ SimpleExpRsp, # SIMPLEEXPRSP
1479
+ MethodResponse, # METHODRESPONSE
1480
+ ExpMethodResponse, # EXPMETHODRESPONSE
1481
+ IMethodResponse, # IMETHODRESPONSE
1482
+ Error, # ERROR
1483
+ ReturnValue, # RETURNVALUE
1484
+ IReturnValue, # IRETURNVALUE
1485
+ ResponseDestination, # RESPONSEDESTINATION
1486
+ SimpleReqAck # SIMPLEREQACK
1487
+ ]
1488
+
1489
+ if __FILE__ == $0
1490
+
1491
+ Comfychair.main(TESTS)
1492
+ end
1493
+
1494
+ end
1495
+ end