?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
**** Merged from MCS ****
[mono-project.git] / mcs / class / System.XML / Test / System.Xml / nist_dom / fundamental / CharacterData / CharacterData.cs
blobf2b8377607b99b4336b7c37892d23a79d74fb3bb
1 //**************************************************************************
2 //
3 //
4 // National Institute Of Standards and Technology
5 // DTS Version 1.0
6 //
7 // CharacterData Interface
8 //
9 // Written by: Carmelo Montanez
10 // Modified by: Mary Brady
11 //
12 // Ported to System.Xml by: Mizrahi Rafael rafim@mainsoft.com
13 // Mainsoft Corporation (c) 2003-2004
14 //**************************************************************************
15 using System;
16 using System.Xml;
17
18 using nist_dom;
19 using NUnit.Framework;
20
21 namespace nist_dom.fundamental
22 {
23 [TestFixture]
24 public class CharacterDataTest : Assertion//,ITest
25 {
26 public static int i = 2;
27 /*
28 public testResults[] RunTests()
29 {
30 testResults[] tests = new testResults[] {core0001C(), core0002C(), core0003C(),core0004C(),
31 core0005C(), core0006C(), core0007C(), core0008C(),
32 core0009C(), core0010C(), core0011C(), core0012C(),
33 core0013C(), core0014C(), core0015C(),
34 core0016C(), core0017C(), core0018C(), core0019C(),
35 core0020C(), core0021C(), core0022C(), core0023C(),
36 core0024C(), core0025C(), core0026C(), core0027C(),
37 core0028C(), core0029C(), core0030C(), core0031C(),
38 core0032C(), core0033C(), core0034C(), core0035C(),
39 core0036C()};
40
41 return tests;
42 }
43 */
44 //------------------------ test case core-0001C ------------------------
45 //
46 // Testing feature - The "data" attribute is the character data that
47 // implements this interface.
48 //
49 // Testing approach - Retrieve the character data from the second child of
50 // the first employee and invoke its "data" attribute. The
51 // attribute should return the actual data.
52 //
53 // Semantic Requirements: 1
54 //
55 //----------------------------------------------------------------------------
56
57 [Test]
58 public void core0001C()
59 {
60 string computedValue = "";
61 string expectedValue = "Margaret Martin";
62 System.Xml.XmlNode testNode = null;
63 System.Xml.XmlCharacterData testNodeData = null;
64
65 testResults results = new testResults("Core0001C");
66 try
67 {
68 results.description = "The \"data\" attribute is the character data that " +
69 "implements this interface.";
70 //
71 // Access the targeted data.
72 //
73 testNode = util.nodeObject(util.FIRST,util.SECOND);
74 testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
75 computedValue = testNodeData.Data;
76 }
77 catch(System.Exception ex)
78 {
79 computedValue = "Exception " + ex.Message;
80 }
81 //
82 // Write out results
83 //
84 results.expected = expectedValue;
85 results.actual = computedValue;
86
87 AssertEquals (results.expected, results.actual);
88 }
89
90 //------------------------ End test case core-0001C --------------------------
91 //
92 //--------------------------- test case core-0002C ---------------------------
93 //
94 // Testing feature - The "length" attribute contains the number of 16-bit
95 // units that are available through the data attribute and
96 // the substringData method. Test for the "data" attribute.
97 //
98 // Testing approach - Retrieve the character data from the second child of
99 // the first employee and access its data by using the
100 // "data" attribute. Finally the "length" attribute
101 // is used on the character data returned by the "data"
102 // attribute to determine the number of 16 bit units in
103 // the data.
104 //
105 // Semantic Requirements: 2
106 //
107 //----------------------------------------------------------------------------
108
109 [Test]
110 public void core0002C()
111 {
112 string computedValue = "";
113 string expectedValue = "15";
114 System.Xml.XmlNode testNode = null;
115 System.Xml.XmlCharacterData testNodeData = null;
116
117 testResults results = new testResults("Core0002C");
118 try
119 {
120 results.description = "The \"length\" attribute is the number of 16-bit units " +
121 "that are available through the \"data\" attribute " +
122 "and the \"substringData\" method (test for \"data\").";
123 //
124 // Retrieve the targeted data and invoke its "data" attribute.
125 //
126 testNode = util.nodeObject(util.FIRST,util.SECOND);
127 testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
128 computedValue = testNodeData.Length.ToString();
129 }
130 catch(System.Exception ex)
131 {
132 computedValue = "Exception " + ex.Message;
133 }
134 //
135 // Write out results
136 //
137 results.expected = expectedValue;
138 results.actual = computedValue;
139
140 AssertEquals (results.expected, results.actual);
141 }
142
143 //------------------------ End test case core-0002C --------------------------
144 //
145 //--------------------------- test case core-0003C ---------------------------
146 //
147 // Testing feature - The "length" attribute contains the number of 16-bit units
148 // that are available through the data attribute and the
149 // substringData method. Test for the "substringData"
150 // method.
151 //
152 // Testing approach - Retrieve the character data of the second child of the
153 // first employee and access part of the data by using the
154 // "substringData(offset,count)" method. Finally the
155 // "length" attribute is used on the character data
156 // returned by the "substringData(offset,count)" method
157 // to determine the number of 16-bit units in the data.
158 //
159 // Semantic Requirements: 2
160 //
161 //----------------------------------------------------------------------------
162
163 [Test]
164 public void core0003C()
165 {
166 string computedValue = "";
167 string expectedValue = "8";
168 System.Xml.XmlNode testNode = null;
169 System.Xml.XmlCharacterData testNodeData = null;
170 string subString = "";
171
172 testResults results = new testResults("Core0003C");
173 try
174 {
175 results.description = "The \"length\" attribute is the number of 16-bit units " +
176 "that are available through the \"data\" attribute " +
177 "and the \"substringData\" method (test for \"substringData\").";
178 //
179 // Retrieve the targeted data and invoke its "substringData" method.
180 //
181 testNode = util.nodeObject(util.FIRST,util.SECOND);
182 testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
183 subString = testNodeData.Substring(0,8);
184 computedValue = subString.Length.ToString();
185 }
186 catch(System.Exception ex)
187 {
188 computedValue = "Exception " + ex.Message;
189 }
190 //
191 // write out results
192 //
193 results.expected = expectedValue;
194 results.actual = computedValue;
195
196 AssertEquals (results.expected, results.actual);
197 }
198
199 //------------------------ End test case core-0003C --------------------------
200 //
201 //--------------------------- test case core-0004C ---------------------------
202 //
203 // Testing feature - The "substringData(offset,count)" method returns the
204 // specified substring.
205 //
206 // Testing approach - Retrieve the character data from the second child of the
207 // first employee and access part of the data by using the
208 // "substringData(offset,count)" method. The method should
209 // return the specified substring starting at position
210 // "offset" and extract "count" characters. The method
211 // method should return the string "Margaret".
212 //
213 // Semantic Requirements: 3
214 //
215 //----------------------------------------------------------------------------
216
217 [Test]
218 public void core0004C()
219 {
220 //string testName = "core-0004C";
221 string computedValue = "";
222 string expectedValue = "Margaret";
223 System.Xml.XmlNode testNode = null;
224 System.Xml.XmlCharacterData testNodeData = null;
225
226 testResults results = new testResults("Core0004C");
227 try
228 {
229 results.description = "The \"substringData(offset,count)\" method returns the " +
230 "specified substring.";
231 //
232 // Retrieve the targeted data and invoke its "substringData" method.
233 //
234 testNode = util.nodeObject(util.FIRST,util.SECOND);
235 testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
236 computedValue = testNodeData.Substring(0,8);
237 }
238 catch(System.Exception ex)
239 {
240 computedValue = "Exception " + ex.Message;
241 }
242 //
243 // Write out results
244 //
245 results.expected = expectedValue;
246 results.actual = computedValue;
247
248 AssertEquals (results.expected, results.actual);
249 }
250
251 //------------------------ End test case core-0004C --------------------------
252 //
253 //--------------------------- test case core-0005C ---------------------------
254 //
255 // Testing feature - If the sum of "offset" and "count" exceeds "length" then
256 // the substringData(offset,count) method returns all
257 // the 16-bit units to the end of the data.
258 //
259 // Testing approach - Retrieve the character data from the second child of the
260 // first employee and access part of the data by using the
261 // "substringData(offset,count)" method with offset = 9 and
262 // count = 10. The method should return the substring
263 // "Martin" since offset + count > length (19 > 15).
264 //
265 // Semantic Requirements: 4
266 //
267 //----------------------------------------------------------------------------
268
269 [Test]
270 public void core0005C()
271 {
272 string computedValue = "";
273 string expectedValue = "Martin";
274 System.Xml.XmlNode testNode = null;
275 System.Xml.XmlCharacterData testNodeData = null;
276
277 testResults results = new testResults("Core0005C");
278 try
279 {
280 results.description = "If the sum of \"offset\" and \"count\" exceeds " +
281 "the value of the \"length\" attribute then the " +
282 "\"substringData(offset,count)\" method returns all " +
283 "the 16-bit units to the end of the data.";
284 //
285 // Retrieve the targeted data and invoke its "substringData" method.
286 //
287 testNode = util.nodeObject(util.FIRST,util.SECOND);
288 testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
289 computedValue = testNodeData.Substring(9,10);
290 }
291 catch(System.Exception ex)
292 {
293 computedValue = "Exception " + ex.Message;
294 }
295
296 //
297 // Write out results
298 //
299 results.expected = expectedValue;
300 results.actual = computedValue;
301
302 AssertEquals (results.expected, results.actual);
303 }
304
305 //------------------------ End test case core-0005C --------------------------
306 //
307 //--------------------------- test case core-0006C ---------------------------
308 //
309 // Testing feature - The "appendData(arg)" method appends a string to the end
310 // of the character data of the node.
311 //
312 // Testing approach - Retrieve the character data from the second child of the
313 // first employee. The "appendData(arg)" method is then
314 // called with arg = ", Esquire". The method should append
315 // the specified data to the already existing character
316 // data. The new value of the "length" attribute should
317 // be 24.
318 //
319 // Semantic Requirements: 5
320 //
321 //----------------------------------------------------------------------------
322
323 [Test]
324 public void core0006C()
325 {
326 string computedValue = "";
327 string expectedValue = "24";
328 System.Xml.XmlNode testNode = null;
329 System.Xml.XmlCharacterData testNodeData = null;
330
331 testResults results = new testResults("Core0006C");
332 try
333 {
334 results.description = "The \"appendData(arg)\" method appends the specified " +
335 "string to the end of the character data of the node.";
336 //
337 // Retrieve targeted data and invoke the "appendData" method.
338 //
339 testNode = util.nodeObject(util.FIRST,util.SECOND);
340 testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
341 testNodeData.AppendData(", Esquire");;
342 computedValue = testNodeData.Length.ToString();
343 }
344 catch(System.Exception ex)
345 {
346 computedValue = "Exception " + ex.Message;
347 }
348 //
349 // Write out results
350 //
351 results.expected = expectedValue;
352 results.actual = computedValue;
353
354 util.resetData();
355
356 AssertEquals (results.expected, results.actual);
357 }
358
359 //------------------------ End test case core-0006C --------------------------
360 //
361 //--------------------------- test case core-0007C ---------------------------
362 //
363 // Testing feature - Upon successful invocation of the "appendData(arg)"
364 // method, the "data" attribute provides access to the
365 // concatenation of data and the specified DOMString.
366 //
367 // Testing approach - Retrieve the character data from the second child of
368 // the first employee. The "appendData(arg)" method is
369 // then called with arg = ", Esquire". The method should
370 // append the specified data to the already existing
371 // character data. The new value of the "data" attribute
372 // should be "Margaret Martin, Esquire".
373 //
374 // Semantic Requirements: 6
375 //
376 //----------------------------------------------------------------------------
377
378 [Test]
379 public void core0007C()
380 {
381 string computedValue = "";
382 string expectedValue = "Margaret Martin, Esquire";
383 System.Xml.XmlNode testNode = null;
384 System.Xml.XmlCharacterData testNodeData = null;
385
386 testResults results = new testResults("Core0007C");
387 try
388 {
389 results.description = "Upon successful invocation of the \"appendData(arg)\" " +
390 "method ,the \"data\" attribute provides access " +
391 "to the concatenation of \"data\" and the specified DOMString.";
392 //
393 // Retrieve targeted data and invoke its "appendData" method.
394 //
395 testNode = util.nodeObject(util.FIRST,util.SECOND);
396 testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
397 testNodeData.AppendData(", Esquire");
398 computedValue = testNodeData.Data;
399 }
400 catch(System.Exception ex)
401 {
402 computedValue = "Exception " + ex.Message;
403 }
404 //
405 // Write out results
406 //
407 results.expected = expectedValue;
408 results.actual = computedValue;
409
410 util.resetData();
411
412 AssertEquals (results.expected, results.actual);
413 }
414
415 //------------------------ End test case core-0007C --------------------------
416 //
417 //--------------------------- test case core-0008C ---------------------------
418 //
419 // Testing feature - The "insertData(offset,arg)" method insert a string at the
420 // specified 16-bit unit offset. Insert at the beginning of
421 // the character data.
422 //
423 // Testing approach - Retrieve the character data from the second child of
424 // the first employee. The "insertData(offset,arg)"
425 // method is then called with offset = 0 and arg = "Mss.".
426 // The method should insert the string "Mss." at position
427 // 0. The new value of the character data should be "Mss.
428 // Margaret Martin".
429 //
430 // Semantic Requirements: 7
431 //
432 //----------------------------------------------------------------------------
433
434 [Test]
435 public void core0008C()
436 {
437 string computedValue = "";
438 string expectedValue = "Mss. Margaret Martin";
439 System.Xml.XmlNode testNode = null;
440 System.Xml.XmlCharacterData testNodeData = null;
441
442 testResults results = new testResults("Core0008C");
443 try
444 {
445 results.description = "Insert a string at the beginning of character data.";
446 //
447 // Retrieve the targeted data and invoke its "insertData" method.
448 //
449 testNode = util.nodeObject(util.FIRST,util.SECOND);
450 testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
451 testNodeData.InsertData(0,"Mss. ");
452 computedValue = testNodeData.Data;
453 }
454 catch(System.Exception ex)
455 {
456 computedValue = "Exception " + ex.Message;
457 }
458 //
459 // Write out results
460 //
461 results.expected = expectedValue;
462 results.actual = computedValue;
463
464 util.resetData();
465
466 AssertEquals (results.expected, results.actual);
467 }
468
469 //------------------------ End test case core-0008C --------------------------
470 //
471 //--------------------------- test case core-0009C ---------------------------
472 //
473 // Testing feature - The "insertData(offset,arg)" method insert a string at the
474 // specified 16-bit units offset. Insert in the middle of
475 // the character data.
476 //
477 // Testing approach - Retrieve the character data from the second child of the
478 // first employee. The "insertData(offset,arg)" method is
479 // then called with offset = 9 and arg = "Ann". The
480 // method should insert the string "Ann" at position 9.
481 // The new value of the character data should be
482 // "Margaret Ann Martin".
483 //
484 // Semantic Requirements: 7
485 //
486 //----------------------------------------------------------------------------
487
488 [Test]
489 public void core0009C()
490 {
491 string computedValue = "";//0;
492 string expectedValue = "Margaret Ann Martin";
493 System.Xml.XmlNode testNode = null;
494 System.Xml.XmlCharacterData testNodeData = null;
495
496 testResults results = new testResults("Core0009C");
497 try
498 {
499 results.description = "Insert a character string in the middle of character data.";
500 //
501 // Retrieve targeted data and invoke its "insertData" method.
502 //
503 testNode = util.nodeObject(util.FIRST,util.SECOND);
504 testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
505 testNodeData.InsertData(9,"Ann ");
506 computedValue = testNodeData.Data;
507 }
508 catch(System.Exception ex)
509 {
510 computedValue = "Exception " + ex.Message;
511 }
512 //
513 // Write out results
514 //
515 results.expected = expectedValue;
516 results.actual = computedValue;
517
518 util.resetData();
519
520 AssertEquals (results.expected, results.actual);
521 }
522
523 //------------------------ End test case core-0009C --------------------------
524 //
525 //--------------------------- test case core-0010C ---------------------------
526 //
527 // Testing feature - The "insertData(offset,arg)" method insert a string at the
528 // specified 16-bit units offset. Insert at the end of the
529 // character data.
530 //
531 // Testing approach - Retrieve the character data from the second child of the
532 // first employee. The "insertData(offset,arg)" method
533 // is then called with offset = 14 and arg = ", Esquire".
534 // The method should insert the string ", Esquire" at
535 // position 14. The new value of the character data
536 // should be "Margaret Martin, Esquire"
537 //
538 // Semantic Requirements: 7
539 //
540 //----------------------------------------------------------------------------
541
542 [Test]
543 public void core0010C()
544 {
545 string computedValue = "";
546 string expectedValue = "Margaret Martin, Esquire";
547 System.Xml.XmlNode testNode = null;
548 System.Xml.XmlCharacterData testNodeData = null;
549
550 testResults results = new testResults("Core0010C");
551 try
552 {
553 results.description = "Insert a string at the end of character data.";
554 //
555 // Retrieve the targeted data and invoke its "insertData" method.
556 //
557 testNode = util.nodeObject(util.FIRST,util.SECOND);
558 testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
559 testNodeData.InsertData(15,", Esquire");
560 computedValue = testNodeData.Data;
561 }
562 catch(System.Exception ex)
563 {
564 computedValue = "Exception " + ex.Message;
565 }
566 //
567 // Write out results
568 //
569 results.expected = expectedValue;
570 results.actual = computedValue;
571
572 util.resetData();
573
574 AssertEquals (results.expected, results.actual);
575 }
576
577 //------------------------ End test case core-0010C --------------------------
578 //
579 //--------------------------- test case core-0011C ---------------------------
580 //
581 // Testing feature - The "deleteData(offset,count)" method removes a range of
582 // 16-bit units from the node. Delete at the beginning of the
583 // character data.
584 //
585 // Testing approach - Retrieve the character data from the last child of the
586 // first employee. The "deleteData(offset,count)"
587 // method is then called with offset = 0 and count = 16.
588 // The method should delete the characters from position 0
589 // thru position 16. The new value of the character data
590 // should be "Dallas, Texas 98551".
591 //
592 // Semantic Requirements: 8, 9
593 //
594 //----------------------------------------------------------------------------
595
596 [Test]
597 public void core0011C()
598 {
599 string computedValue = "";
600 string expectedValue = "Dallas, Texas 98551";
601 System.Xml.XmlNode testNode = null;
602 System.Xml.XmlCharacterData testNodeData = null;
603
604 testResults results = new testResults("Core0011C");
605 try
606 {
607 results.description = "Delete character string from beginning of character data.";
608 //
609 // Retrieve the targeted data and invoke its "deleteData" method..
610 //
611 testNode = util.nodeObject(util.FIRST,util.SIXTH);
612 testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
613 testNodeData.DeleteData(0,16);
614 computedValue = testNodeData.Data;
615 }
616 catch(System.Exception ex)
617 {
618 computedValue = "Exception " + ex.Message;
619 }
620 //
621 // Write out results
622 //
623 results.expected = expectedValue;
624 results.actual = computedValue;
625
626 util.resetData();
627
628 AssertEquals (results.expected, results.actual);
629 }
630
631 //------------------------ End test case core-0011C --------------------------
632 //
633 //--------------------------- test case core-0012C ---------------------------
634 //
635 // Testing feature - The "deleteData(offset,count)" method removes a range of
636 // 16-bit units from the node. Delete in the middle of
637 // the character data.
638 //
639 // Testing approach - Retrieve the character data from the last child of
640 // the first employee. The "deleteData(offset,count)"
641 // method is then called with offset = 16 and count = 8.
642 // The method should delete the characters from position 16
643 // thru position 24. The new value of the character data
644 // should be "1230 North Ave. Texas 98551".
645 //
646 // Semantic Requirements: 8, 9
647 //
648 //----------------------------------------------------------------------------
649
650 [Test]
651 public void core0012C()
652 {
653 string computedValue = "";
654 string expectedValue = "1230 North Ave. Texas 98551";
655 System.Xml.XmlNode testNode = null;
656 System.Xml.XmlCharacterData testNodeData = null;
657
658 testResults results = new testResults("Core0012C");
659 try
660 {
661 results.description = "Delete character string from the middle of character data.";
662 //
663 // Retrieve the targeted data and invoke its "deleteData" method.
664 //
665 testNode = util.nodeObject(util.FIRST,util.SIXTH);
666 testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
667 testNodeData.DeleteData(16,8);
668 computedValue = testNodeData.Data;
669 }
670 catch(System.Exception ex)
671 {
672 computedValue = "Exception " + ex.Message;
673 }
674 //
675 // Write out results
676 //
677 results.expected = expectedValue;
678 results.actual = computedValue;
679
680 util.resetData();
681
682 AssertEquals (results.expected, results.actual);
683 }
684
685 //------------------------ End test case core-0012C --------------------------
686 //
687 //--------------------------- test case core-0013C ---------------------------
688 //
689 // Testing feature - The "deleteData(offset,count)" method removes a range of
690 // 16-bit units from the node. Delete at the end of the
691 // character data.
692 //
693 // Testing approach - Retrieve the character data from the last child of
694 // the first employee. The "deleteData(offset,count)"
695 // method is then called with offset = 30 and count = 5.
696 // The method should delete the characters from position 30
697 // thru position 35. The new value of the character data
698 // should be "1230 North Ave. Dallas, Texas".
699 //
700 // Semantic Requirements: 8, 9
701 //
702 //----------------------------------------------------------------------------
703
704 [Test]
705 public void core0013C()
706 {
707 string computedValue = "";
708 string expectedValue = "1230 North Ave. Dallas, Texas ";
709 System.Xml.XmlNode testNode = null;
710 System.Xml.XmlCharacterData testNodeData = null;
711
712 testResults results = new testResults("Core0013C");
713 try
714 {
715 results.description = "Delete character string from the end of character data.";
716 //
717 // Retrieve the targeted data and invoke its "deleteData" method.
718 //
719 testNode = util.nodeObject(util.FIRST,util.SIXTH);
720 testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
721 testNodeData.DeleteData(30,5);
722 computedValue = testNodeData.Data;
723 }
724 catch(System.Exception ex)
725 {
726 computedValue = "Exception " + ex.Message;
727 }
728 //
729 // Write out results
730 //
731 results.expected = expectedValue;
732 results.actual = computedValue;
733
734 util.resetData();
735
736 AssertEquals (results.expected, results.actual);
737 }
738
739 //------------------------ End test case core-0013C --------------------------
740 //
741 //--------------------------- test case core-0014C ---------------------------
742 //
743 // Testing feature - Upon successful invocation of the
744 // "deleteData(offset,count)" method, the data and length
745 // attributes reflect that change.
746 //
747 // Testing approach - Retrieve the character data of the last child of the
748 // first employee. The "deleteData(offset,count)"
749 // method is then called with offset = 30 and count = 5.
750 // The method should delete the characters from position 30
751 // thru position 35. The new value of the character data
752 // should be "1230 North Ave. Dallas, Texas" (the data
753 // attribute) and its length attribute should be 30. This
754 // new values should be reflected immediately upon
755 // its invocation.
756 //
757 // Semantic Requirements: 9
758 //
759 //----------------------------------------------------------------------------
760
761 [Test]
762 public void core0014C()
763 {
764 string computedValue = "";
765 string expectedValue = "1230 North Ave. Dallas, Texas 30";
766 System.Xml.XmlNode testNode = null;
767 System.Xml.XmlCharacterData testNodeData = null;
768
769 testResults results = new testResults("Core0014C");
770 try
771 {
772 results.description = "Data and length attributes are updated as a result " +
773 "of the \"deleteData(offset, count)\" method.";
774 //
775 // Retrieve the targeted data and invoke its "deleteData" attribute.
776 //
777 testNode = util.nodeObject(util.FIRST,util.SIXTH);
778 testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
779 testNodeData.DeleteData(30,5);
780 computedValue += testNodeData.Data;
781 computedValue += testNodeData.Length;
782 }
783 catch(System.Exception ex)
784 {
785 computedValue = "Exception " + ex.Message;
786 }
787
788 //
789 // Write out results
790 //
791 results.expected = expectedValue;
792 results.actual = computedValue;
793
794 util.resetData();
795
796 AssertEquals (results.expected, results.actual);
797 }
798
799 //------------------------ End test case core-0014C --------------------------
800 //
801 //--------------------------- test case core-0015C ---------------------------
802 //
803 // Testing feature - If the sum of the offset and count attributes (from the
804 // deleteData method) is greater than the length of the
805 // character data then all the 16-bit units from the offset
806 // to the end of the data are deleted.
807 //
808 // Testing approach - Retrieve the character data from the last child of the
809 // first employee. The "deleteData(offset,count)"
810 // method is then called with offset = 4 and count = 50.
811 // The method should delete the characters from position 4
812 // to the end of the data since offset + count (50+4) is
813 // greater than the length of the character data (35).
814 // The new value for the character data should be "1230".
815 //
816 // Semantic Requirements: 10
817 //
818 //----------------------------------------------------------------------------
819
820 [Test]
821 public void core0015C()
822 {
823 string computedValue = "";
824 string expectedValue = "1230";
825 System.Xml.XmlNode testNode = null;
826 System.Xml.XmlCharacterData testNodeData = null;
827
828 testResults results = new testResults("Core0015C");
829 try
830 {
831 results.description = "If the sum of \"offset\" and \"count\" exceeds the " +
832 "length of the character data then all the " +
833 "16-bit units from the offset thru the end of the " +
834 "data are removed.<br>";
835 //
836 // Retrieve the targeted data and invoke its "deleteData" method.
837 //
838 testNode = util.nodeObject(util.FIRST,util.SIXTH);
839 testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
840 testNodeData.DeleteData(4,50);
841 computedValue = testNodeData.Data;
842 }
843 catch(System.Exception ex)
844 {
845 computedValue = "Exception " + ex.Message;
846 }
847
848 //
849 // Write out results
850 //
851 results.expected = expectedValue;
852 results.actual = computedValue;
853
854 util.resetData();
855
856 AssertEquals (results.expected, results.actual);
857 }
858
859 //------------------------ End test case core-0015C --------------------------
860 //
861 //--------------------------- test case core-0016C ---------------------------
862 //
863 // Testing feature - The "replaceData(offset,count,arg)" method replace the
864 // characters starting at the specified 16-bit units with the
865 // specified string. Test for replacement at the
866 // beginning of the data.
867 //
868 // Testing approach - Retrieve the character data from the last child of the
869 // first employee. The "replaceData(offset,count,arg)"
870 // method is then called with offset = 0 and count = 4 and
871 // arg = "2500". The method should replace the first four
872 // characters of the character data with "2500".
873 //
874 // Semantic Requirements: 11
875 //
876 //----------------------------------------------------------------------------
877
878 [Test]
879 public void core0016C()
880 {
881 string computedValue = "";//0;
882 string expectedValue = "2500 North Ave. Dallas, Texas 98551";
883 System.Xml.XmlNode testNode = null;
884 System.Xml.XmlCharacterData testNodeData = null;
885
886 testResults results = new testResults("Core0016C");
887 try
888 {
889 results.description = "Replace a character string at the beginning of character data.";
890 //
891 // Retrieve the targeted data and invoke its "replaceData" method .
892 //
893 testNode = util.nodeObject(util.FIRST,util.SIXTH);
894 testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
895 testNodeData.ReplaceData(0,4,"2500");
896 computedValue = testNodeData.Data;
897 }
898 catch(System.Exception ex)
899 {
900 computedValue = "Exception " + ex.Message;
901 }
902
903 //
904 // Write out results
905 //
906 results.expected = expectedValue;
907 results.actual = computedValue;
908
909 util.resetData();
910
911 AssertEquals (results.expected, results.actual);
912 }
913
914 //------------------------ End test case core-0016C --------------------------
915 //
916 //--------------------------- test case core-0017C ---------------------------
917 // Testing feature - The "replaceData(offset,count,arg)" method replace the
918 // characters starting at the specified 16-bit units with the
919 // specified string. Test for replacement in the
920 // middle of the data.
921 //
922 // Testing approach - Retrieve the character data from the last child of the
923 // first employee. The "replaceData(offset,count,arg)"
924 // method is then called with offset = 5 and count = 5 and
925 // arg = "South". The method should replace characters
926 // five thru nine of the character data with "South".
927 //
928 // Semantic Requirements: 11
929 //
930 //----------------------------------------------------------------------------
931
932 [Test]
933 public void core0017C()
934 {
935 string computedValue = "";
936 string expectedValue = "1230 South Ave. Dallas, Texas 98551";
937 System.Xml.XmlNode testNode = null;
938 System.Xml.XmlCharacterData testNodeData = null;
939
940 testResults results = new testResults("Core0017C");
941 try
942 {
943 results.description = "Replace a character string in the middle of character data.";
944 //
945 // Retrieve the targeted data and invoke its "replaceData" method.
946 //
947 testNode = util.nodeObject(util.FIRST,util.SIXTH);
948 testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
949 testNodeData.ReplaceData(5,5,"South");
950 computedValue = testNodeData.Data;
951 }
952 catch(System.Exception ex)
953 {
954 computedValue = "Exception " + ex.Message;
955 }
956
957 //
958 // Write out results
959 //
960 results.expected = expectedValue;
961 results.actual = computedValue;
962
963 util.resetData();
964
965 AssertEquals (results.expected, results.actual);
966 }
967
968 //------------------------ End test case core-0017C --------------------------
969 //
970 //--------------------------- test case core-0018C ---------------------------
971 //
972 // Testing feature - The "replaceData(offset,count,arg)" method replace the
973 // characters starting at the specified 16-bit units with the
974 // specified string. Test for replacement at the
975 // end of the data.
976 //
977 // Testing approach - Retrieve the character data from the last child of the
978 // first employee. The "replaceData(offset,count,arg)"
979 // method is then called with offset = 30 and count = 5 and
980 // arg = "98665". The method should replace characters
981 // 30 thru 34 of the character data with "98665".
982 //
983 // Semantic Requirements: 11
984 //
985 //----------------------------------------------------------------------------
986
987 [Test]
988 public void core0018C()
989 {
990 string computedValue = "";//0;
991 string expectedValue = "1230 North Ave. Dallas, Texas 98665";
992 System.Xml.XmlNode testNode = null;
993 System.Xml.XmlCharacterData testNodeData = null;
994
995 testResults results = new testResults("Core0018C");
996 try
997 {
998 results.description = "Replace a character substring at the end of character data.";
999 //
1000 // Retrieve the targeted data and invoke its "replaceData" method.
1001 //
1002 testNode = util.nodeObject(util.FIRST,util.SIXTH);
1003 testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
1004 testNodeData.ReplaceData(30,5,"98665");
1005 computedValue = testNodeData.Data;
1006 }
1007 catch(System.Exception ex)
1008 {
1009 computedValue = "Exception " + ex.Message;
1010 }
1011
1012 //
1013 // Write out results
1014 //
1015 results.expected = expectedValue;
1016 results.actual = computedValue;
1017
1018 util.resetData();
1019
1020 AssertEquals (results.expected, results.actual);
1021 }
1022
1023 //------------------------ End test case core-0018C --------------------------
1024 //
1025 //--------------------------- test case core-0019C ---------------------------
1026 //
1027 // Testing feature - The "replaceData(offset,count,arg)" method replace the
1028 // characters starting at the specified 16-bit units with the
1029 // specified string. Test situation where the length of
1030 // the arg string is greater than the specified offset.
1031 //
1032 // Testing approach - Retrieve the character data from the last child of the
1033 // first employee. The "replaceData(offset,count,arg)"
1034 // method is then called with offset = 0 and count = 4 and
1035 // arg = "260030". The method should replace characters
1036 // one thru four with the string "260030". Note that the
1037 // length of the specified string is greater than the
1038 // specified offset.
1039 //
1040 // Semantic Requirements: 11
1041 //
1042 //----------------------------------------------------------------------------
1043
1044 [Test]
1045 public void core0019C()
1046 {
1047 string computedValue = "";
1048 string expectedValue = "260030 North Ave. Dallas, Texas 98551";
1049 System.Xml.XmlNode testNode = null;
1050 System.Xml.XmlCharacterData testNodeData = null;
1051
1052 testResults results = new testResults("Core0019C");
1053 try
1054 {
1055 results.description = "Checks \"replaceData(offset,count,arg)\" method when " +
1056 "length of arg > count.";
1057 //
1058 // Retrieve targeted data and invoke its "replaceData" method.
1059 //
1060 testNode = util.nodeObject(util.FIRST,util.SIXTH);
1061 testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
1062 testNodeData.ReplaceData(0,4,"260030");
1063 computedValue = testNodeData.Data;
1064 }
1065 catch(System.Exception ex)
1066 {
1067 computedValue = "Exception " + ex.Message;
1068 }
1069
1070 //
1071 // Write out results
1072 //
1073 results.expected = expectedValue;
1074 results.actual = computedValue;
1075
1076 util.resetData();
1077
1078 AssertEquals (results.expected, results.actual);
1079 }
1080
1081 //------------------------ End test case core-0019C --------------------------
1082 //
1083 //--------------------------- test case core-0020C ---------------------------
1084 //
1085 // Testing feature - If the sum of offset and count exceeds length then all
1086 // the 16-bit units to the end of data are replaced.
1087 //
1088 // Testing approach - Retrieve the character data from the last child of the
1089 // first employee. The "replaceData(offset,count,arg)"
1090 // method is then called with offset = 0 and count = 50 and
1091 // arg = "2600". The method should replace all the
1092 // characters in the character data with "2600". This
1093 // is because the sum of offset and count exceeds the
1094 // length of the character data.
1095 //
1096 // Semantic Requirements: 12
1097 //
1098 //----------------------------------------------------------------------------
1099
1100 [Test]
1101 public void core0020C()
1102 {
1103 //string testName = "core-0020C";
1104 string computedValue = "";
1105 string expectedValue = "2600";
1106 System.Xml.XmlNode testNode = null;
1107 System.Xml.XmlCharacterData testNodeData = null;
1108
1109 testResults results = new testResults("Core0020C");
1110 try
1111 {
1112 results.description = "If the sum of offset and count exceeds the length " +
1113 "of the character data then the \"replaceData(offset,count,arg)\" " +
1114 "method replaces all the 16-bit units to the end of the data.";
1115 //
1116 // Retrieve the targeted data and invoke its "replaceData" method.
1117 //
1118 testNode = util.nodeObject(util.FIRST,util.SIXTH);
1119 testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
1120 testNodeData.ReplaceData(0,50,"2600");
1121 computedValue = testNodeData.Data;
1122 }
1123 catch(System.Exception ex)
1124 {
1125 computedValue = "Exception " + ex.Message;
1126 }
1127
1128 //
1129 // Write out results
1130 //
1131 results.expected = expectedValue;
1132 results.actual = computedValue;
1133
1134 util.resetData();
1135
1136 AssertEquals (results.expected, results.actual);
1137 }
1138
1139 //------------------------ End test case core-0020C --------------------------
1140 //
1141 //--------------------------- test case core-0021C ---------------------------
1142 //
1143 // Testing feature - The "data" attribute raises a
1144 // NO_MODIFICATION_ALLOWED_ERR Exception when
1145 // this node is readonly.
1146 //
1147 // Testing approach - Retrieve the character data from the first
1148 // EntityReference node of the last child of the second
1149 // employee and attempt to set its "data" attribute. Since
1150 // the the descendants of EntityReference nodes are readonly,
1151 // the desired exception should be raised.
1152 //
1153 // Semantic Requirements: 13
1154 //
1155 //----------------------------------------------------------------------------
1156
1157 [Test]
1158 public void core0021C()
1159 {
1160 string computedValue = "";
1161 System.Xml.XmlNode testNode = null;
1162 System.Xml.XmlText readOnlyText = null;
1163 string expectedValue = "System.ArgumentException";//util.NO_MODIFICATION_ALLOWED_ERR;
1164
1165 testResults results = new testResults("Core0021C");
1166 try
1167 {
1168 results.description = "The \"data\" attribute raises a NO_MODIFICATION_ALLOWED_ERR " +
1169 "DOMException when this node is readonly.";
1170 //
1171 // Retrieve targeted data.
1172 //
1173 testNode = util.nodeObject(util.SECOND,util.SIXTH);
1174 readOnlyText = (System.Xml.XmlText)testNode.FirstChild.FirstChild;
1175 //
1176 // Attempt to modify the "data" attribute should raise exception.
1177 //
1178 try
1179 {
1180 readOnlyText.Data = "ABCD";
1181 }
1182 catch (ArgumentException ex)
1183 {
1184 computedValue = ex.GetType ().FullName;
1185 }
1186 }
1187 catch(InvalidOperationException ex)
1188 {
1189 computedValue = "Exception " + ex.Message;
1190 }
1191
1192 results.expected = expectedValue;
1193 results.actual = computedValue;
1194
1195 util.resetData();
1196
1197 AssertEquals (results.expected, results.actual);
1198 }
1199
1200 //------------------------ End test case core-0021C --------------------------
1201 //
1202 //--------------------------- test case core-0022C ---------------------------
1203 //
1204 // Testing feature - The "appendData(arg) method raises a
1205 // NO_MODIFICATION_ALLOWED_ERR Exception when
1206 // this node is readonly.
1207 //
1208 // Testing approach - Retrieve the textual data from the the first
1209 // EntityReference node of the last child of the
1210 // second employee and attempt to append data to it.
1211 // Descendants of EntityReference nodes are readonly
1212 // nodes and therefore the desired exception should be
1213 // raised.
1214 //
1215 // Semantic Requirements: 14
1216 //
1217 //----------------------------------------------------------------------------
1218
1219 [Test]
1220 public void core0022C()
1221 {
1222 string computedValue = "";
1223 System.Xml.XmlNode testNode = null;
1224 System.Xml.XmlCharacterData readOnlyNode = null;
1225 string expectedValue = "System.ArgumentException";//util.NO_MODIFICATION_ALLOWED_ERR;
1226
1227 testResults results = new testResults("Core0022C");
1228 try
1229 {
1230 results.description = "The \"appendData(arg)\" method raises a " +
1231 "NO_MODIFICATION_ALLOWED_ERR Exception when this " +
1232 "node is readonly.";
1233 //
1234 // Retrieve the targeted data.
1235 //
1236 testNode = util.nodeObject(util.SECOND,util.SIXTH);
1237 readOnlyNode = (System.Xml.XmlCharacterData)testNode.FirstChild.FirstChild;
1238 //
1239 // Attempt to append data to a readonly node should raise an exception.
1240 //
1241 try
1242 {
1243 readOnlyNode.AppendData("002");
1244 }
1245 catch(ArgumentException ex)
1246 {
1247 computedValue = ex.GetType ().FullName;
1248 }
1249 }
1250 catch(System.Exception ex)
1251 {
1252 computedValue = "Exception " + ex.Message;
1253 }
1254
1255 results.expected = expectedValue;
1256 results.actual = computedValue;
1257
1258 util.resetData();
1259
1260 AssertEquals (results.expected, results.actual);
1261 }
1262
1263 //------------------------ End test case core-0022C --------------------------
1264 //
1265 //--------------------------- test case core-0023C ---------------------------
1266 //
1267 // Testing feature - The "insertData(offset,arg) method raises a
1268 // NO_MODIFICATION_ALLOWED_ERR Exception when
1269 // this node is readonly.
1270 //
1271 // Testing approach - Retrieve the Text data of the first EntityReference
1272 // node from the last child of the second employee and
1273 // attempt to insert data into it. Since the descendants
1274 // of EntityReference nodes are readonly, the desired
1275 // exception should be raised.
1276 //
1277 // Semantic Requirements: 15
1278 //
1279 //----------------------------------------------------------------------------
1280
1281 [Test]
1282 public void core0023C()
1283 {
1284 string computedValue = "";
1285 System.Xml.XmlNode testNode = null;
1286 System.Xml.XmlCharacterData readOnlyNode = null;
1287 string expectedValue = "System.ArgumentException";//util.NO_MODIFICATION_ALLOWED_ERR;
1288
1289 testResults results = new testResults("Core0023C");
1290 try
1291 {
1292 results.description = "The \"insertData(offset,arg)\" method raises a " +
1293 "NO_MODIFICATION_ALLOWED_ERR Exception when this " +
1294 "node is readonly.";
1295 //
1296 // Retrieve the targeted data
1297 //
1298 testNode = util.nodeObject(util.SECOND,util.SIXTH);
1299 readOnlyNode = (System.Xml.XmlCharacterData)testNode.FirstChild.FirstChild;
1300 //
1301 // Attempt to insert data into a readonly node should raise an exception.
1302 //
1303 try
1304 {
1305 readOnlyNode.InsertData(2,"ABCD");
1306 }
1307 catch(ArgumentException ex)
1308 {
1309 computedValue = ex.GetType ().FullName;
1310 }
1311 }
1312 catch(System.Exception ex)
1313 {
1314 computedValue = "Exception " + ex.Message;
1315 }
1316
1317 results.expected = expectedValue;
1318 results.actual = computedValue;
1319
1320 util.resetData();
1321
1322 AssertEquals (results.expected, results.actual);
1323 }
1324
1325 //------------------------ End test case core-0023C --------------------------
1326 //
1327 //--------------------------- test case core-0024C ---------------------------
1328 //
1329 // Testing feature - The "deleteData(offset,count) method raises a
1330 // NO_MODIFICATION_ALLOWED_ERR Exception when
1331 // ths is readonly.
1332 //
1333 // Testing approach - Retrieve the textual data of the the first
1334 // EntityReference node from the last child of the
1335 // second employee and attempt to delete data from it.
1336 // Since the descendants of EntityReference nodes are
1337 // readonly, the desired exception should be raised.
1338 //
1339 // Semantic Requirements: 16
1340 //
1341 //----------------------------------------------------------------------------
1342
1343 [Test]
1344 public void core0024C()
1345 {
1346 string computedValue = "";
1347 System.Xml.XmlCharacterData readOnlyNode = null;
1348 System.Xml.XmlNode testNode = null;
1349 string expectedValue = "System.ArgumentException";//util.NO_MODIFICATION_ALLOWED_ERR;
1350
1351 testResults results = new testResults("Core0024C");
1352 try
1353 {
1354 results.description = "The \"deleteData(offset,count)\" method raises a " +
1355 "NO_MODIFICATION_ALLOWED_ERR Exception when this " +
1356 "node is readonly.";
1357 //
1358 // Retrieve the targeted data.
1359 //
1360 testNode = util.nodeObject(util.SECOND,util.SIXTH);
1361 readOnlyNode = (System.Xml.XmlCharacterData)testNode.FirstChild.FirstChild;
1362 //
1363 // Attempt to delete data from a readonly node should raise an
1364 // exception.
1365 //
1366 try
1367 {
1368 readOnlyNode.DeleteData(2,4);
1369 }
1370 catch(System.Exception ex)
1371 {
1372 computedValue = ex.GetType ().FullName;
1373 }
1374 }
1375 catch(System.Exception ex)
1376 {
1377 computedValue = "Exception " + ex.Message;
1378 }
1379
1380 results.expected = expectedValue;
1381 results.actual = computedValue;
1382
1383 util.resetData();
1384
1385 AssertEquals (results.expected, results.actual);
1386 }
1387
1388 //------------------------ End test case core-0024C --------------------------
1389 //
1390 //--------------------------- test case core-0025C ---------------------------
1391 //
1392 // Testing feature - The "replaceData(offset,count,arg) method raises a
1393 // NO_MODIFICATION_ALLOWED_ERR Exception when
1394 // this node is readonly.
1395 //
1396 // Testing approach - Retrieve the textual data of the first EntityReference
1397 // node from the last child of the second employee and
1398 // attempt to replace data from it. Since the descendants
1399 // of EntityReference nodes are readonly, the desired
1400 // exception should be raised.
1401 //
1402 // Semantic Requirements: 17
1403 //
1404 //----------------------------------------------------------------------------
1405
1406 [Test]
1407 public void core0025C()
1408 {
1409 string computedValue = "";
1410 System.Xml.XmlCharacterData readOnlyNode = null;
1411 System.Xml.XmlNode testNode = null;
1412 string expectedValue = "System.ArgumentException";//util.NO_MODIFICATION_ALLOWED_ERR;
1413
1414 testResults results = new testResults("Core0025C");
1415 try
1416 {
1417 results.description = "The \"replaceData(offset,count,arg)\" method raises a " +
1418 "NO_MODIFICATION_ALLOWED_ERR Exception " +
1419 "when this node is readonly.";
1420 //
1421 // Retrieve the targeted data.
1422 //
1423 testNode = util.nodeObject(util.SECOND,util.SIXTH);
1424 readOnlyNode = (System.Xml.XmlCharacterData)testNode.FirstChild.FirstChild;
1425 //
1426 // Attempt to replace data from a readonly node should raise an
1427 // exception.
1428 //
1429 try
1430 {
1431 readOnlyNode.ReplaceData(2,4,"ABCD");
1432 }
1433 catch(System.Exception ex)
1434 {
1435 computedValue = ex.GetType ().FullName;
1436 }
1437 }
1438 catch(System.Exception ex)
1439 {
1440 computedValue = "Exception " + ex.Message;
1441 }
1442
1443 results.expected = expectedValue;
1444 results.actual = computedValue;
1445
1446 util.resetData();
1447
1448 AssertEquals (results.expected, results.actual);
1449 }
1450
1451 //------------------------ End test case core-0025C --------------------------
1452 //
1453 //--------------------------- test case core-0026C ---------------------------
1454 //
1455 // Testing feature - The "substringData(offset,count)" method raises an
1456 // INDEX_SIZE_ERR Exception if the specified offset is
1457 // negative.
1458 //
1459 // Testing approach - Retrieve the character data of the last child of the
1460 // of the first employee and invoke its
1461 // "substringData(offset,count)" method with offset = -5
1462 // count = 3. It should raise the desired exception since
1463 // the offset is negative.
1464 //
1465 // Semantic Requirements: 19
1466 //
1467 //----------------------------------------------------------------------------
1468
1469 [Test]
1470 public void core0026C()
1471 {
1472 string computedValue = "";
1473 string returnedValue = "";
1474 System.Xml.XmlNode testNode = null;
1475 System.Xml.XmlCharacterData testNodeData = null;
1476 string expectedValue = "System.ArgumentOutOfRangeException";//util.INDEX_SIZE_ERR;
1477
1478 testResults results = new testResults("Core0026C");
1479 try
1480 {
1481 results.description = "The \"substringData(offset,count)\" method raises an " +
1482 "INDEX_SIZE_ERR Exception if the specified " +
1483 "offset is negative.";
1484 //
1485 // Retrieve the targeted data.
1486 //
1487 testNode = util.nodeObject(util.FIRST,util.SIXTH);
1488 testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
1489 //
1490 // A negative offset value should raise and exception.
1491 //
1492 try
1493 {
1494 returnedValue = testNodeData.Substring(-5,3);
1495 }
1496 catch(System.Exception ex)
1497 {
1498 computedValue = ex.GetType ().FullName;
1499 }
1500 }
1501 catch(System.Exception ex)
1502 {
1503 computedValue = "Exception " + ex.Message;
1504 }
1505
1506 results.expected = expectedValue;
1507 results.actual = computedValue;
1508
1509 AssertEquals (results.expected, results.actual);
1510 }
1511
1512 //------------------------ End test case core-0026C --------------------------
1513 //
1514 //--------------------------- test case core-0027C ---------------------------
1515 //
1516 // Testing feature - The "substringData(offset,count)" method raises an
1517 // INDEX_SIZE_ERR Exception if the specified offset is
1518 // greater than the number of 16-bit units in the "data"
1519 // attribute.
1520 //
1521 // Testing approach - Retrieve the character data of the last child of the
1522 // first employee and invoke its
1523 // "substringData(offset,count)" method with offset = 40 and
1524 // count = 3. The value of the offset is greater than that
1525 // one of the "data" attribute, therefore the desired
1526 // exception should be raised.
1527 //
1528 // Semantic Requirements: 20
1529 //
1530 //----------------------------------------------------------------------------
1531
1532 [Test]
1533 public void core0027C()
1534 {
1535 string computedValue = "";
1536 string returnedValue = "";
1537 System.Xml.XmlNode testNode = null;
1538 System.Xml.XmlCharacterData testNodeData = null;
1539 string expectedValue = "System.ArgumentOutOfRangeException";
1540
1541 testResults results = new testResults("Core0027C");
1542 try
1543 {
1544 results.description = "The \"substringData(offset,count)\" method raises an " +
1545 "ArgumentOutOfRangeException Exception if the specified " +
1546 "offset is greater than the number of 16-bit units " +
1547 "in the \"data\" attribute.";
1548 //
1549 // Retrieve the targeted data.
1550 //
1551 testNode = util.nodeObject(util.FIRST,util.SIXTH);
1552 testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
1553 //
1554 // Offset greater than number of characters in data should raise an
1555 // exception.
1556 //
1557 try
1558 {
1559 returnedValue = testNodeData.Substring(40,3);
1560 }
1561 catch(System.Exception ex)
1562 {
1563 computedValue = ex.GetType().ToString();
1564 }
1565 }
1566 catch(System.Exception ex)
1567 {
1568 computedValue = "Exception " + ex.Message;
1569 }
1570 results.expected = expectedValue;
1571 results.actual = computedValue;
1572
1573 AssertEquals (results.expected, results.actual);
1574 }
1575
1576 //------------------------ End test case core-0027C --------------------------
1577 //
1578 //--------------------------- test case core-0028C ---------------------------
1579 //
1580 // Testing feature - The "substringData(offset,count)" method raises an
1581 // INDEX_SIZE_ERR Exception if the count is negative
1582 //
1583 // Testing approach - Retrieve the character data of the last child of the
1584 // first employee and invoke its
1585 // "substringData(offset,count)" method with offset = 10
1586 // and count = -3. Since the value of count is negative,
1587 // the desired exception should be raised.
1588 //
1589 // Semantic Requirements: 21
1590 //
1591 //----------------------------------------------------------------------------
1592
1593 [Test]
1594 public void core0028C()
1595 {
1596 string computedValue = "";
1597 string returnedValue = "";
1598 System.Xml.XmlNode testNode = null;
1599 System.Xml.XmlCharacterData testNodeData = null;
1600 string expectedValue = "System.ArgumentOutOfRangeException";
1601
1602 testResults results = new testResults("Core0028C");
1603 try
1604 {
1605 results.description = "The \"substringData(offset,count)\" method raises an " +
1606 "INDEX_SIZE_ERR Exception if the count is negative.";
1607 //
1608 // Retrieve the targeted data.
1609 //
1610 testNode = util.nodeObject(util.FIRST,util.SIXTH);
1611 testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
1612 //
1613 // A negative value for "count" should raise an exception.
1614 //
1615 try
1616 {
1617 returnedValue = testNodeData.Substring(10,-3);
1618 }
1619 catch(System.Exception ex)
1620 {
1621 computedValue = ex.GetType().ToString();
1622 }
1623 }
1624 catch(System.Exception ex)
1625 {
1626 computedValue = "Exception " + ex.Message;
1627 }
1628 results.expected = expectedValue;
1629 results.actual = computedValue;
1630
1631 AssertEquals (results.expected, results.actual);
1632 }
1633
1634 //------------------------ End test case core-0028C --------------------------
1635 //
1636 //--------------------------- test case core-0029C ---------------------------
1637 //
1638 // Testing feature - The "deleteData(offset,count)" method raises an
1639 // ArgumentOutOfRangeException if the specified offset is
1640 // negative.
1641 //
1642 // Testing approach - Retrieve the character data of the last child of the
1643 // first employee and invoke its "deleteData(offset,count)"
1644 // method with offset = -5 and count = 3. The value of the
1645 // offset is negative and therefore the desired exception
1646 // should be raised.
1647 //
1648 // Semantic Requirements: 22
1649 //
1650 //----------------------------------------------------------------------------
1651
1652 [Test]
1653 public void core0029C()
1654 {
1655 string computedValue = "";
1656 System.Xml.XmlNode testNode = null;
1657 System.Xml.XmlCharacterData testNodeData = null;
1658 string expectedValue = "System.ArgumentOutOfRangeException";
1659
1660 testResults results = new testResults("Core0029C");
1661 try
1662 {
1663 results.description = "The \"deleteData(offset,count)\" method raises an " +
1664 "ArgumentOutOfRangeException if the specified " +
1665 "offset is negative.";
1666 //
1667 // Retrieve the targeted data.
1668 //
1669 testNode = util.nodeObject(util.FIRST,util.SIXTH);
1670 testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
1671 //
1672 // Invoke "deleteData(offset,count)" method with negative offset should
1673 // should raise an excetion.
1674 //
1675 try
1676 {
1677 testNodeData.DeleteData(-5,3);
1678 }
1679 catch(System.Exception ex)
1680 {
1681 computedValue = ex.GetType().ToString();
1682 }
1683 }
1684 catch(System.Exception ex)
1685 {
1686 computedValue = "Exception " + ex.Message;
1687 }
1688 results.expected = expectedValue;
1689 results.actual = computedValue;
1690
1691 util.resetData();
1692
1693 AssertEquals (results.expected, results.actual);
1694 }
1695
1696 //------------------------ End test case core-0029C --------------------------
1697 //
1698 //--------------------------- test case core-0030C ---------------------------
1699 //
1700 // Testing feature - The "deleteData(offset,count)" method raises an
1701 // ArgumentOutOfRangeException if the specified offset is
1702 // greater than the number of characters in the "data"
1703 // attribute.
1704 //
1705 // Testing approach - Retrieve the character data of the last child of the
1706 // first employee and invoke its "deleteData(offset,count)"
1707 // method with offset = 40 and count = 3. The value of the
1708 // offset is greater than the number of characters in the
1709 // "data" attribute (35) and therefore the intended
1710 // exception should be raised.
1711 //
1712 // Semantic Requirements: 23
1713 //
1714 //----------------------------------------------------------------------------
1715
1716 [Test]
1717 public void core0030C()
1718 {
1719 string computedValue = "";
1720 System.Xml.XmlNode testNode = null;
1721 System.Xml.XmlCharacterData testNodeData = null;
1722 string expectedValue = "System.ArgumentOutOfRangeException";
1723
1724 testResults results = new testResults("Core0030C");
1725 try
1726 {
1727 results.description = "The \"deleteData(offset,count)\" method raises an " +
1728 "ArgumentOutOfRangeException if the specified " +
1729 "offset is greater than the number of characters " +
1730 "in the \"data\" attribute.";
1731 //
1732 // Retrieve the targeted data.
1733 //
1734 testNode = util.nodeObject(util.FIRST,util.SIXTH);
1735 testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
1736 //
1737 // Invocation of "deleteData(offset,count)" method with offset > data
1738 // attribute should raise and exception.
1739 //
1740 try
1741 {
1742 testNodeData.DeleteData(40,3);
1743 }
1744 catch(System.Exception ex)
1745 {
1746 computedValue = ex.GetType().ToString();
1747 }
1748 }
1749 catch(System.Exception ex)
1750 {
1751 computedValue = "Exception " + ex.Message;
1752 }
1753
1754 results.expected = expectedValue;
1755 results.actual = computedValue;
1756
1757 util.resetData();
1758
1759 AssertEquals (results.expected, results.actual);
1760 }
1761
1762 //------------------------ End test case core-0030C --------------------------
1763 //
1764 //--------------------------- test case core-0031C ---------------------------
1765 //
1766 // Testing feature - The "deleteData(offset,count)" method raises an
1767 // ArgumentOutOfRangeException if the specified count is
1768 // negative.
1769 //
1770 // Testing approach - Retrieve the character data of the last child of the
1771 // first employee and invoke its "deleteData(offset,count)"
1772 // method with offset = 10 and count = -3. The value
1773 // of the specified count is negative and therefore the
1774 // intended exception should be raised.
1775 //
1776 // Semantic Requirements: 24
1777 //
1778 //----------------------------------------------------------------------------
1779
1780 [Test]
1781 public void core0031C()
1782 {
1783 string computedValue = "";
1784 System.Xml.XmlNode testNode = null;
1785 System.Xml.XmlCharacterData testNodeData = null;
1786 string expectedValue = "System.ArgumentOutOfRangeException";
1787
1788 testResults results = new testResults("Core0031C");
1789 try
1790 {
1791 results.description = "The \"deleteData(offset,count)\" method raises an " +
1792 "ArgumentOutOfRangeException if the specified " +
1793 "count is negative.";
1794 //
1795 // Retrieve the targeted data.
1796 //
1797 testNode = util.nodeObject(util.FIRST,util.SIXTH);
1798 testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
1799 //
1800 // Invocation of "deleteData(offset,count)" method with count < 0
1801 // should raise and exception.
1802 //
1803 try
1804 {
1805 testNodeData.DeleteData(10,-3);
1806 }
1807 catch(System.Exception ex)
1808 {
1809 computedValue = ex.GetType().ToString();
1810 }
1811 }
1812 catch(System.Exception ex)
1813 {
1814 computedValue = "Exception " + ex.Message;
1815 }
1816
1817 results.expected = expectedValue;
1818 results.actual = computedValue;
1819
1820 util.resetData();
1821
1822 AssertEquals (results.expected, results.actual);
1823 }
1824
1825 //------------------------ End test case core-0031C --------------------------
1826 //
1827 //--------------------------- test case core-0032C ---------------------------
1828 //
1829 // Testing feature - The "replaceData(offset,count,arg)" method raises an
1830 // ArgumentOutOfRangeException if the specified offset is
1831 // negative.
1832 //
1833 // Testing approach - Retrieve the character data of the last child of the
1834 // first employee and invoke its
1835 // "replaceData(offset,count,arg)" method with
1836 // offset = -5 and count = 3 and arg = "ABC". The value
1837 // of the offset is negative and therefore the desired
1838 // exception should be raised.
1839 //
1840 // Semantic Requirements: 25
1841 //
1842 //----------------------------------------------------------------------------
1843
1844 [Test]
1845 public void core0032C()
1846 {
1847 string computedValue = "";
1848 System.Xml.XmlNode testNode = null;
1849 System.Xml.XmlCharacterData testNodeData = null;
1850 string expectedValue = "System.ArgumentOutOfRangeException";
1851
1852 testResults results = new testResults("Core0032C");
1853 try
1854 {
1855 results.description = "The \"replaceData(offset,count,arg)\" method raises an " +
1856 "ArgumentOutOfRangeException if the specified " +
1857 "offset is negative.";
1858 //
1859 // Retrieve the targeted data.
1860 //
1861 testNode = util.nodeObject(util.FIRST,util.SIXTH);
1862 testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
1863 //
1864 // Invocation of "replaceData(offset,count,arg)" method offset < 0
1865 // should raise an exception.
1866 //
1867 try
1868 {
1869 testNodeData.ReplaceData(-5,3,"ABC");
1870 }
1871 catch(System.Exception ex)
1872 {
1873 computedValue = ex.GetType().ToString();
1874 }
1875 }
1876 catch(System.Exception ex)
1877 {
1878 computedValue = "Exception " + ex.Message;
1879 }
1880
1881 results.expected = expectedValue;
1882 results.actual = computedValue;
1883
1884 util.resetData();
1885
1886 AssertEquals (results.expected, results.actual);
1887 }
1888
1889 //------------------------ End test case core-0032C --------------------------
1890 //
1891 //--------------------------- test case core-0033C ---------------------------
1892 //
1893 // Testing feature - The "replaceData(offset,count,arg)" method raises an
1894 // INDEX_RANGE_ERR Exception if the specified offset is
1895 // greater than the number of 16-bit units in the "data"
1896 // attribute.
1897 //
1898 // Testing approach - Retrieve the character data of the last child of the
1899 // first employee and invoke its
1900 // "replaceData(offset,count,arg)" method with offset = 40,
1901 // count = 3 and arg = "ABC". The value of the offset is
1902 // greater than the number of characters in the "data"
1903 // attribute (35) and therefore the intended exception
1904 // should be raised.
1905 //
1906 // Semantic Requirements: 26
1907 //
1908 //----------------------------------------------------------------------------
1909
1910 [Test]
1911 public void core0033C()
1912 {
1913 string computedValue = "";
1914 System.Xml.XmlNode testNode = null;
1915 System.Xml.XmlCharacterData testNodeData = null;
1916 string expectedValue = "System.ArgumentOutOfRangeException";
1917
1918 testResults results = new testResults("Core0033C");
1919 try
1920 {
1921 results.description = "The \"replaceData(offset,count,arg)\" method raises an " +
1922 "ArgumentOutOfRangeException if the specified " +
1923 "offset is greater than the number of 16-bit units " +
1924 "in the \"data\" attribute.";
1925 //
1926 // Retrieve the targeted data.
1927 //
1928 testNode = util.nodeObject(util.FIRST,util.SIXTH);
1929 testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
1930 //
1931 // Invocation of "replaceData(offset,count,arg)" method with offset > data
1932 // attribute should raise and exception.
1933 //
1934 try
1935 {
1936 testNodeData.ReplaceData(40,3,"ABC");
1937 }
1938 catch(System.Exception ex)
1939 {
1940 computedValue = ex.GetType().ToString();
1941 }
1942 }
1943 catch(System.Exception ex)
1944 {
1945 computedValue = "Exception " + ex.Message;
1946 }
1947
1948 results.expected = expectedValue;
1949 results.actual = computedValue;
1950
1951 util.resetData();
1952
1953 AssertEquals (results.expected, results.actual);
1954 }
1955
1956 //------------------------ End test case core-0033C --------------------------
1957 //
1958 //--------------------------- test case core-0034C ---------------------------
1959 //
1960 // Testing feature - The "replaceData(offset,count,arg)" method raises an
1961 // ArgumentOutOfRangeException if the specified count is
1962 // negative.
1963 //
1964 // Testing approach - Retrieve the character data of the last child of the
1965 // first employee and invoke its
1966 // "replaceData(offset,count,arg)" method with offset = 10,
1967 // count = -3 and arg = "ABC". The value of the specified
1968 // count is negative and therefore the intended exception
1969 // should be raised.
1970 //
1971 // Semantic Requirements: 27
1972 //
1973 //----------------------------------------------------------------------------
1974
1975 [Test]
1976 public void core0034C()
1977 {
1978 string computedValue = "";
1979 System.Xml.XmlNode testNode = null;
1980 System.Xml.XmlCharacterData testNodeData = null;
1981 string expectedValue = "System.ArgumentOutOfRangeException";
1982
1983 testResults results = new testResults("Core0034C");
1984 try
1985 {
1986 results.description = "The \"replaceData(offset,count,arg)\" method raises an " +
1987 "ArgumentOutOfRangeException if the specified " +
1988 "count is negative.";
1989 //
1990 // Retrieve the targeted data.
1991 //
1992 testNode = util.nodeObject(util.FIRST,util.SIXTH);
1993 testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
1994 //
1995 // Invocation of "replaceData(offset,count,arg)" method with count < 0
1996 // should raise an exception.
1997 //
1998 try
1999 {
2000 testNodeData.ReplaceData(10,-3,"ABC");
2001 }
2002 catch(System.Exception ex)
2003 {
2004 computedValue = ex.GetType().ToString();
2005 }
2006 }
2007 catch(System.Exception ex)
2008 {
2009 computedValue = "Exception " + ex.Message;
2010 }
2011
2012 results.expected = expectedValue;
2013 results.actual = computedValue;
2014
2015 util.resetData();
2016
2017 AssertEquals (results.expected, results.actual);
2018 }
2019
2020 //------------------------ End test case core-0034C --------------------------
2021 //
2022 //--------------------------- test case core-0035C ---------------------------
2023 //
2024 // Testing feature - The "insertData(offset,arg)" method raises an
2025 // ArgumentOutOfRangeException if the specified offset is
2026 // negative.
2027 //
2028 // Testing approach - Retrieve the character data from the last child of the
2029 // first employee and invoke its "insertData(offset,arg)"
2030 // method with offset = -5 arg = "ABC". The value
2031 // of the offset is negative and therefore the desired
2032 // exception should be raised.
2033 //
2034 // Semantic Requirements: 28
2035 //
2036 //----------------------------------------------------------------------------
2037
2038 [Test]
2039 public void core0035C()
2040 {
2041 string computedValue = "";
2042 System.Xml.XmlNode testNode = null;
2043 System.Xml.XmlCharacterData testNodeData = null;
2044 string expectedValue = "System.ArgumentOutOfRangeException";
2045
2046 testResults results = new testResults("Core0035C");
2047 try
2048 {
2049 results.description = "The \"insertData(offset,arg)\" method raises an " +
2050 "ArgumentOutOfRangeException if the specified offset is negative.";
2051 //
2052 // Retrieve the targeted data.
2053 //
2054 testNode = util.nodeObject(util.FIRST,util.SIXTH);
2055 testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
2056 //
2057 // Invocation of insertData(offset,arg)" method with offset < 0
2058 // should raise an exception.
2059 //
2060 try
2061 {
2062 testNodeData.InsertData(-5,"ABC");
2063 }
2064 catch(System.Exception ex)
2065 {
2066 computedValue = ex.GetType().ToString();
2067 }
2068 }
2069 catch(System.Exception ex)
2070 {
2071 computedValue = "Exception " + ex.Message;
2072 }
2073
2074 results.expected = expectedValue;
2075 results.actual = computedValue;
2076
2077 util.resetData();
2078
2079 AssertEquals (results.expected, results.actual);
2080 }
2081
2082 //------------------------ End test case core-0035C --------------------------
2083 //
2084 //--------------------------- test case core-0036C ---------------------------
2085 //
2086 // Testing feature - The "insertData(offset,arg)" method raises an
2087 // ArgumentOutOfRangeException if the specified offset is
2088 // greater than the number of 16-bit units in the "data"
2089 // attribute.
2090 //
2091 // Testing approach - Retrieve the character data from the last child of the
2092 // first employee and invoke its "insertData(offset,arg)"
2093 // method with offset = 40 and arg = "ABC". The value of
2094 // the offset is greater than the number of characters in
2095 // the "data" attribute(35) and therefore the intended
2096 // exception should be raised.
2097 //
2098 // Semantic Requirements: 29
2099 //
2100 //----------------------------------------------------------------------------
2101
2102 [Test]
2103 public void core0036C()
2104 {
2105 string computedValue = "";
2106 System.Xml.XmlNode testNode = null;
2107 System.Xml.XmlCharacterData testNodeData = null;
2108 string expectedValue = "System.ArgumentOutOfRangeException";
2109
2110 testResults results = new testResults("Core0036C");
2111 try
2112 {
2113 results.description = "The \"insertData(offset,arg)\" method raises an " +
2114 "ArgumentOutOfRangeException if the specified " +
2115 "offset is greater than the number of 16-bit units " +
2116 "in the \"data\" attribute.<br>";
2117 //
2118 // Retrieve the targeted data.
2119 //
2120 testNode = util.nodeObject(util.FIRST,util.SIXTH);
2121 testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
2122 //
2123 // Invocation of "insertData(offset arg)" method with offset > data
2124 // attribute should raise an exception.
2125 //
2126 try
2127 {
2128 testNodeData.InsertData(40,"ABC");
2129 }
2130 catch(System.Exception ex)
2131 {
2132 computedValue = ex.GetType().ToString();
2133 }
2134 }
2135 catch(System.Exception ex)
2136 {
2137 computedValue = "Exception " + ex.Message;
2138 }
2139
2140 results.expected = expectedValue;
2141 results.actual = computedValue;
2142
2143 util.resetData();
2144
2145 AssertEquals (results.expected, results.actual);
2146 }
2147
2148 //------------------------ End test case core-0036C --------------------------
2149 }
2150 }
Mirror of the official Mono project git repository