mcs/class/System.XML/Test/System.Xml/nist_dom/fundamental/Attr/Attr.cs

   1 //**************************************************************************
   2 //
   3 //
   4 //                       National Institute Of Standards and Technology
   5 //                                     DTS Version 1.0
   6 //
   7 //                                   Attr Interface
   8 //
   9 // Written by: Carmelo Montanez
  10 //
  11 // Ported to System.Xml by: Mizrahi Rafael rafim@mainsoft.com
  12 // Mainsoft Corporation (c) 2003-2004
  13 //
  14 //**************************************************************************
  15 using System;
  16 using System.Xml;
  17 using nist_dom;
  18 using NUnit.Framework;
  19
  20 namespace nist_dom.fundamental
  21 {
  22     [TestFixture]
  23     public class AttrTest//, ITest
  24     {
  25         public static int i = 1;
  26 /*
  27         public testResults[] RunTests()
  28         {
  29             testResults[] tests = new testResults[] {core0001A(), core0002A(), core0003A(),core0004A(),
  30                                                         core0005A(), core0006A(), core0007A(), core0008A(),
  31                                                         core0009A(), core0010A(), core0011A(), core0012A(),
  32                                                         core0013A(), core0014A()};
  33
  34             return tests;
  35         }
  36 */
  37         //------------------------ test case core-0001A ------------------------
  38         //
  39         // Testing feature - The parentNode attribute for an Attr object should
  40         //                   be null.
  41         //
  42         // Testing approach - Retrieve the attribute named "domestic" from the last
  43         //                    child of of the first employee and examine its
  44         //                    parentNode attribute.  This test uses the
  45         //                    "GetNamedItem(name)" method from the NamedNodeMap
  46         //                    interface.
  47         //
  48         // Semantic Requirements: 1
  49         //
  50         //----------------------------------------------------------------------------
  51
  52         [Test]
  53         public void core0001A()
  54         {
  55             object computedValue = null;
  56             object expectedValue = null;
  57             System.Xml.XmlNode testNode = null;
  58             System.Xml.XmlAttribute domesticAttr = null;
  59
  60             testResults results = new testResults("Core0001A");
  61
  62             try
  63             {
  64                 results.description = "The ParentNode attribute should be null for" +
  65                     " an Attr object.";
  66                 //
  67                 //   Retrieve targeted data and examine parentNode attribute.
  68                 //
  69                 testNode = util.nodeObject(util.FIRST, util.SIXTH);
  70                 domesticAttr = (System.Xml.XmlAttribute)testNode.Attributes.GetNamedItem("domestic");
  71                 computedValue = domesticAttr.ParentNode;
  72                 //
  73                 //    Write out results
  74                 //
  75             }
  76             catch(System.Exception ex)
  77             {
  78                 computedValue = "Exception " + ex.Message;
  79             }
  80
  81             results.expected = (expectedValue == null).ToString();
  82             results.actual = (computedValue == null).ToString();
  83             Assert.AreEqual (results.expected, results.actual);
  84             // return results;
  85
  86         }
  87
  88         //------------------------ End test case core-0001A --------------------------
  89         //
  90         //-------------------------  test case core-0002A ----------------------------
  91         //
  92         //
  93         // Written By: Carmelo Montanez
  94         //
  95         // Testing feature - The previousSibling attribute for an Attr object
  96         //                   should be null.
  97         //
  98         // Testing approach - Retrieve the attribute named "domestic" from the last
  99         //                    child of of the first employee and examine its
 100         //                    previousSibling attribute.  This test uses the
 101         //                    "GetNamedItem(name)" method from the NamedNodeMap
 102         //                    interface.
 103         //
 104         // Semantic Requirements: 1
 105         //
 106         //----------------------------------------------------------------------------
 107
 108         [Test]
 109         public void core0002A()
 110         {
 111             object computedValue = null;
 112             object expectedValue = null;
 113             System.Xml.XmlAttribute domesticAttr = null;
 114             System.Xml.XmlNode testNode = null;
 115
 116             testResults results = new testResults("Core0002A");
 117             try
 118             {
 119                 results.description =  "The previousSibling attribute should be " +
 120                     "null for an Attr object.";
 121                 //
 122                 // Retrieve the targeted data and examine its previousSibling attribute.
 123                 //
 124                 testNode = util.nodeObject(util.FIRST,util.SIXTH);
 125                 domesticAttr = (System.Xml.XmlAttribute)testNode.Attributes.GetNamedItem("domestic");
 126                 computedValue = domesticAttr.PreviousSibling;
 127             }
 128             catch(System.Exception ex)
 129             {
 130                 computedValue = "Exception " + ex.Message;
 131             }
 132             //
 133             // Write out results
 134             //
 135             results.expected = (expectedValue == null).ToString();
 136             results.actual = (computedValue == null).ToString();
 137
 138             Assert.AreEqual (results.expected, results.actual);
 139             // return results;
 140         }
 141
 142         //------------------------ End test case core-0002A --------------------------
 143         //
 144         //-------------------------  test case core-0003A ----------------------------
 145         // Written By: Carmelo Montanez
 146         //
 147         // Testing feature - The nextSibling attribute for an Attr object should
 148         //                   be null.
 149         //
 150         // Testing approach - Retrieve the attribute named "domestic" from the
 151         //                    last child of of the first employee and examine
 152         //                    its nextSibling attribute.  This test uses the
 153         //                    "GetNamedItem(name)" method from the NamedNodeMap
 154         //                    interface.
 155         //
 156         // Semantic Requirements: 1
 157         //
 158         //----------------------------------------------------------------------------
 159
 160         [Test]
 161         public void core0003A()
 162         {
 163             object computedValue = null;
 164             object expectedValue = null;
 165             System.Xml.XmlAttribute domesticAttr = null;
 166             System.Xml.XmlNode testNode = null;
 167
 168             testResults results = new testResults("Core0003A");
 169             try
 170             {
 171                 results.description =  "The nextSibling attribute should be null " +
 172                     "for an Attr object.";
 173                 //
 174                 // Retrieve the targeted data and examine its nextSibling attribute.
 175                 //
 176                 testNode = util.nodeObject(util.FIRST,util.SIXTH);
 177                 domesticAttr = (System.Xml.XmlAttribute)testNode.Attributes.GetNamedItem("domestic");
 178                 computedValue = domesticAttr.NextSibling;
 179             }
 180             catch(System.Exception ex)
 181             {
 182                 computedValue = "Exception " + ex.Message;
 183             }
 184             //
 185             // Write out results
 186             //
 187             results.expected = (expectedValue == null).ToString();
 188             results.actual = (computedValue == null).ToString();
 189
 190             Assert.AreEqual (results.expected, results.actual);
 191             // return results;
 192         }
 193
 194         //------------------------ End test case core-0003A --------------------------
 195         //
 196         //-------------------------  test case core-0004A ----------------------------
 197         //
 198         // Written By: Carmelo Montanez
 199         //
 200         // Testing feature - Attr objects may be associated with Element nodes
 201         //                   contained within a DocumentFragment.
 202         //
 203         // Testing approach - Create a new DocumentFragment object and add a newly
 204         //                    created Element node to it (with one attribute).  Once
 205         //                    the element is added, its attribute should be available
 206         //                    as an attribute associated with an Element within a
 207         //                    DocumentFragment.
 208         //
 209         // Semantic Requirements: 2
 210         //
 211         //----------------------------------------------------------------------------
 212
 213         [Test]
 214         public void core0004A()
 215         {
 216             string computedValue = "";
 217             string expectedValue = "domestic";
 218             System.Xml.XmlAttribute domesticAttr = null;
 219
 220             testResults results = new testResults("Core0004A");
 221             try
 222             {
 223                 results.description = "Attr objects may be associated with Element " +
 224                     "nodes contained within a DocumentFragment.";
 225
 226                 System.Xml.XmlDocumentFragment docFragment = util.getDOMDocument().CreateDocumentFragment();
 227                 System.Xml.XmlElement newElement = (System.Xml.XmlElement)util.createNode(util.ELEMENT_NODE,"element1");
 228                 //
 229                 // The new DocumentFragment is empty upon creation.  Set an attribute for
 230                 // a newly created element and add the element to the documentFragment.
 231                 //
 232                 newElement.SetAttribute("domestic","Yes");
 233                 docFragment.AppendChild(newElement);
 234                 //
 235                 // Access the attributes of the only child of the documentFragment
 236                 //
 237                 domesticAttr = (System.Xml.XmlAttribute)docFragment.FirstChild.Attributes.Item(0) ;
 238                 computedValue = domesticAttr.Name;
 239             }
 240             catch(System.Exception ex)
 241             {
 242                 computedValue = "Exception " + ex.Message;
 243             }
 244             //
 245             //  Write out results
 246             //
 247             results.expected = expectedValue;
 248             results.actual = computedValue;
 249
 250             util.resetData();
 251             Assert.AreEqual (results.expected, results.actual);
 252             // return results;
 253         }
 254
 255         //------------------------ End test case core-0004A --------------------------
 256         //
 257         //-------------------------- test case core-0005A ----------------------------
 258         //
 259         // Testing feature - If an Attr is explicitly assigned any value, then that
 260         //                   value is the attribute's effective value.
 261         //
 262         // Testing approach - Retrieve the attribute name "domestic" from  the last
 263         //                    child of of the first employee element and examine its
 264         //                    assigned value.  This test uses the
 265         //                    "GetNamedItem(name)" method from the NamedNodeMap
 266         //                    interface.
 267         //
 268         // Semantic Requirements: 3
 269         //
 270         //----------------------------------------------------------------------------
 271
 272         [Test]
 273         public void core0005A()
 274         {
 275             string computedValue = "";
 276             string expectedValue = "Yes";
 277             System.Xml.XmlAttribute domesticAttr = null;
 278             System.Xml.XmlNode testNode = null;
 279
 280             testResults results = new testResults("Core0005A");
 281             try
 282             {
 283                 results.description = "If an attribute is explicitly assigned any value, " +
 284                     "then that value is the attribute's effective value.";
 285                 //
 286                 //  Retrieve the targeted data and examine its assigned value.
 287                 //
 288                 testNode = util.nodeObject(util.FIRST,util.SIXTH);
 289                 domesticAttr = (System.Xml.XmlAttribute)testNode.Attributes.GetNamedItem("domestic");
 290                 computedValue = domesticAttr.Value;
 291             }
 292             catch(System.Exception ex)
 293             {
 294                 computedValue = "Exception " + ex.Message;
 295             }
 296             //
 297             // Write out results
 298             //
 299             results.expected = expectedValue;
 300             results.actual = computedValue;
 301
 302             Assert.AreEqual (results.expected, results.actual);
 303             // return results;
 304         }
 305
 306         //------------------------ End test case core-0005A --------------------------
 307         //
 308         //-------------------------- test case core-0006A ----------------------------
 309         //
 310         // Testing feature - If there is no explicit value assigned to an attribute
 311         //                   and there is a declaration for this attribute and that
 312         //                   declaration includes a default value, then that default
 313         //                   value is the Attribute's default value.
 314         //
 315         // Testing approach - Retrieve the attribute named "street" from the
 316         //                    last child of of the first employee and examine its
 317         //                    value.  That value should be the value given during
 318         //                    the declaration of the attribute in the DTD file.
 319         //                    This test uses the "GetNamedItem(name)" method from
 320         //                    the NamedNodeMap interface.
 321         //
 322         // Semantic Requirements: 4
 323         //
 324         //----------------------------------------------------------------------------
 325
 326         [Test]
 327         [Category ("NotDotNet")]
 328         public void core0006A()
 329         {
 330             string computedValue = "";
 331             string expectedValue = "Yes";
 332             System.Xml.XmlAttribute streetAttr = null;
 333             System.Xml.XmlNode testNode = null;
 334
 335             testResults results = new testResults("Core0006A");
 336             try
 337             {
 338                 results.description = "If there is no explicit value assigned to an " +
 339                     "attribute and there is a declaration for this " +
 340                     "attribute and  that declaration includes a default " +
 341                     "value, then that default value is the Attribute's " +
 342                     "default value.";
 343                 //
 344                 // Retrieve the targeted data and examine its default value.
 345                 //
 346                 testNode = util.nodeObject(util.FIRST,util.SIXTH);
 347                 streetAttr = (System.Xml.XmlAttribute)testNode.Attributes.GetNamedItem("street");
 348                 computedValue = streetAttr.Value;
 349             }
 350             catch(System.Exception ex)
 351             {
 352                 computedValue = "Exception " + ex.Message;
 353             }
 354             //
 355             // Write out results
 356             //
 357             results.expected = expectedValue;
 358             results.actual = computedValue;
 359
 360             Assert.AreEqual (results.expected, results.actual);
 361             // return results;
 362         }
 363
 364         //------------------------ End test case core-0006A --------------------------
 365         //
 366         //--------------------------  test case core-0007A ---------------------------
 367         //
 368         // Testing feature - The "name" Attribute of an Attribute node.
 369         //
 370         // Testing approach - Retrieve the attribute named "street" from the
 371         //                    last child of the second employee and examine its "name"
 372         //                    attribute.  This test uses the "GetNamedItem(name)"
 373         //                    method from the NamedNodeMap interface.
 374         //
 375         // Semantic Requirements: 5
 376         //
 377         //----------------------------------------------------------------------------
 378
 379         [Test]
 380         public void core0007A()
 381         {
 382             string computedValue = "";
 383             string expectedValue = "street";
 384             System.Xml.XmlAttribute streetAttr = null;
 385             System.Xml.XmlNode testNode = null;
 386
 387             testResults results = new testResults("Core0007A");
 388             try
 389             {
 390                 results.description = "The \"name\" attribute of an Attr object contains " +
 391                     "the name of that attribute.";
 392                 //
 393                 // Retrieve the targeted data and capture its assigned name.
 394                 //
 395                 testNode = util.nodeObject(util.SECOND,util.SIXTH);
 396                 streetAttr = (System.Xml.XmlAttribute)testNode.Attributes.GetNamedItem("street");
 397                 computedValue = streetAttr.Name;
 398             }
 399             catch(System.Exception ex)
 400             {
 401                 computedValue = "Exception " + ex.Message;
 402             }
 403             //
 404             // Write out results
 405             //
 406             results.expected = expectedValue;
 407             results.actual = computedValue;
 408
 409             Assert.AreEqual (results.expected, results.actual);
 410             // return results;
 411         }
 412
 413         //------------------------ End test case core-0007A --------------------------
 414         //
 415         //--------------------------  test case core-0008A ---------------------------
 416         //
 417         // Testing feature - The "specified" attribute of an Attr node should be set
 418         //                   to true if the attribute was explicitly given a value.
 419         //
 420         // Testing approach - Retrieve the attribute named "doestic" from the last
 421         //                    child of the first employee and examine its "specified"
 422         //                    attribute.  It should be set to true.  This test
 423         //                    uses the "GetNamedItem(name)" method from the
 424         //                    NamedNodeMap interface.
 425         //
 426         // Semantic Requirements: 6
 427         //
 428         //----------------------------------------------------------------------------
 429
 430         [Test]
 431         public void core0008A()
 432         {
 433             string computedValue = "";//0;
 434             string expectedValue = "True";
 435             System.Xml.XmlNode testNode = null;
 436             System.Xml.XmlAttribute domesticAttr = null;
 437
 438             testResults results = new testResults("Core0008A");
 439             try
 440             {
 441                 results.description = "The \"specified\" attribute for an Attr object " +
 442                     "should be set to true if the attribute was " +
 443                     "explictly given a value.";
 444                 //
 445                 // Retrieve the targeted data and capture its "specified" value.
 446                 //
 447                 testNode = util.nodeObject(util.FIRST,util.SIXTH);
 448                 domesticAttr = (System.Xml.XmlAttribute)testNode.Attributes.GetNamedItem("domestic");;
 449                 computedValue = domesticAttr.Specified.ToString();
 450             }
 451             catch(System.Exception ex)
 452             {
 453                 computedValue = "Exception " + ex.Message;
 454             }
 455             //
 456             // Write out results
 457             //
 458             results.expected = expectedValue;
 459             results.actual = computedValue;
 460
 461             Assert.AreEqual (results.expected, results.actual);
 462             // return results;
 463         }
 464
 465         //------------------------ End test case core-0008A --------------------------
 466         //
 467         //--------------------------  test case core-0009A ---------------------------
 468         //
 469         // Testing feature - The "specified" attribute for an Attr node should be
 470         //                   set to false if the attribute was not explicitly given
 471         //                   a value.
 472         //
 473         // Testing approach - Retrieve the attribute named "street"(not explicity
 474         //                    given a value) from the last child of the first employee
 475         //                    and examine its "specified" attribute.  It should be
 476         //                    set to false.  This test uses the
 477         //                    "GetNamedItem(name)" method from the NamedNodeMap
 478         //                    interface.
 479         //
 480         // Semantic Requirements: 6
 481         //
 482         //----------------------------------------------------------------------------
 483
 484         [Test]
 485         public void core0009A()
 486         {
 487             string computedValue = "";//0;
 488             string expectedValue = "False";
 489             System.Xml.XmlAttribute streetAttr = null;
 490             System.Xml.XmlNode testNode = null;
 491
 492             testResults results = new testResults("Core0009A");
 493             try
 494             {
 495                 results.description = "The \"specified\" attribute for an Attr node " +
 496                     "should be set to false if the attribute was " +
 497                     "not explictly given a value.";
 498                 //
 499                 // Retrieve the targeted data and capture its "specified" attribute.
 500                 //
 501                 testNode = util.nodeObject(util.FIRST,util.SIXTH);
 502                 streetAttr = (System.Xml.XmlAttribute)testNode.Attributes.GetNamedItem("street");
 503                 computedValue = streetAttr.Specified.ToString();
 504             }
 505             catch(System.Exception ex)
 506             {
 507                 computedValue = "Exception " + ex.Message;
 508             }
 509             //
 510             // Write out results
 511             //
 512             results.expected = expectedValue;
 513             results.actual = computedValue;
 514
 515             Assert.AreEqual (results.expected, results.actual);
 516             // return results;
 517         }
 518
 519         //------------------------ End test case core-0009A --------------------------
 520         //
 521         //--------------------------  test case core-0010A ---------------------------
 522         //
 523         // Testing feature - The "specified" attribute for an Attr node should be
 524         //                   automatically flipped to true if value of the attribute
 525         //                   is changed (even its ends up having a default DTD value)
 526         //
 527         // Testing approach - Retrieve the attribute named "street" from the last
 528         //                    child of the third employee and change its value to "Yes"
 529         //                    (which is its default DTD value).  This should cause the
 530         //                    "specified" attribute to be flipped to true.  This test
 531         //                    makes use of the "setAttribute(name,value )" method from
 532         //                    the Element interface and the "GetNamedItem(name)"
 533         //                    method from the NamedNodeMap interface.
 534         //
 535         // Semantic Requirements: 7
 536         //
 537         //----------------------------------------------------------------------------
 538
 539         [Test]
 540         public void core0010A()
 541         {
 542             string computedValue = "";//"";
 543             string expectedValue = "True";
 544             System.Xml.XmlAttribute streetAttr = null;
 545             System.Xml.XmlElement testNode = null;
 546
 547             testResults results = new testResults("Core0010A");
 548             try
 549             {
 550                 results.description = "The \"specified\" attribute for an Attr node " +
 551                     "should be flipped to true if the attribute value " +
 552                     "is changed (even it changed to its default value).";
 553                 //
 554                 // Retrieve the targeted data and set a new attribute for it, then
 555                 // capture its "specified" attribute.
 556                 //
 557                 testNode = (System.Xml.XmlElement)util.nodeObject(util.THIRD,util.FIFTH);
 558                 testNode.SetAttribute("street","Yes");//testNode.node.setAttribute("street","Yes");
 559                 streetAttr = (System.Xml.XmlAttribute)testNode.Attributes.GetNamedItem("street");
 560                 computedValue = streetAttr.Specified.ToString();
 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             Assert.AreEqual (results.expected, results.actual);
 573             // return results;
 574         }
 575
 576         //------------------------ End test case core-0010A --------------------------
 577         //
 578         //--------------------------  test case core-0011A ---------------------------
 579         //
 580         // Testing feature - To respecify the attribute to its default value from the
 581         //                   DTD, the attribute must be deleted.  The implementation
 582         //                   will then make a new attribute available with the
 583         //                   "specified" attribute set to false.
 584
 585         // Testing approach - Retrieve the attribute named "street" from the last
 586         //                    child of the third employee and delete it.  The
 587         //                    implementation should then create a new attribute with
 588         //                    its default value and "specified" set to false.  This
 589         //                    test uses the "removeAttribute(name)" from the Element
 590         //                    interface and the "GetNamedItem(name)" method from the
 591         //                    NamedNodeMap interface.
 592         //
 593         // Semantic Requirements: 8
 594         //
 595         //----------------------------------------------------------------------------
 596
 597         [Test]
 598         public void core0011A()
 599         {
 600             string computedValue = "";//"";
 601             string expectedValue = "False";
 602             System.Xml.XmlAttribute streetAttr = null;
 603             System.Xml.XmlElement testNode = null;
 604
 605             testResults results = new testResults("Core0011A");
 606             try
 607             {
 608                 results.description = "Re-setting an attribute to its default value " +
 609                     "requires that the attribute be deleted.  The " +
 610                     "implementation should create a new attribute " +
 611                     "with its \"specified\" attribute set to false.";
 612                 //
 613                 // Retrieve the targeted data, remove the "street" attribute and capture
 614                 // its specified attribute.
 615                 //
 616                 testNode = (System.Xml.XmlElement)util.nodeObject(util.THIRD,util.SIXTH);
 617                 testNode.RemoveAttribute("street");//testNode.node.removeAttribute("street");
 618                 streetAttr = (System.Xml.XmlAttribute)testNode.Attributes.GetNamedItem("street");
 619                 computedValue = streetAttr.Specified.ToString();
 620             }
 621             catch(System.Exception ex)
 622             {
 623                 computedValue = "Exception " + ex.Message;
 624             }
 625             //
 626             // Write out results
 627             //
 628             results.expected = expectedValue;
 629             results.actual = computedValue;
 630
 631             Assert.AreEqual (results.expected, results.actual);
 632             // return results;
 633         }
 634
 635         //------------------------ End test case core-0011A --------------------------
 636         //
 637         //--------------------------  test case core-0012A ---------------------------
 638         //
 639         // Testing feature - Upon retrieval, the "value" of an attribute is returned
 640         //                   as a string with characters and general entity references
 641         //                   replaced with their values.
 642
 643         // Testing approach - Retrieve the attribute named "street" from the last
 644         //                    child of the fourth employee and examine its value
 645         //                    attribute.  This value should be "Yes" after the
 646         //                    EntityReference is replaced with its value.   This
 647         //                    test uses the "GetNamedItem(name)" method from
 648         //                    the NamedNodeMap interface.
 649         //
 650         // Semantic Requirements: 9
 651         //
 652         //----------------------------------------------------------------------------
 653
 654         [Test]
 655         public void core0012A()
 656         {
 657             string computedValue = "";
 658             string expectedValue = "Yes";
 659             System.Xml.XmlAttribute streetAttr = null;
 660             System.Xml.XmlNode testNode = null;
 661
 662             testResults results = new testResults("Core0012A");
 663             try
 664             {
 665                 results.description = "Upon retrieval the \"value\" attribute of an Attr" +
 666                     "object is returned as a string with any Entity " +
 667                     "References replaced with their values.";
 668                 //
 669                 // Retrieve the targeted data.
 670                 //
 671                 testNode = util.nodeObject(util.FOURTH,util.SIXTH);
 672                 streetAttr = (System.Xml.XmlAttribute)testNode.Attributes.GetNamedItem("street");
 673                 computedValue = streetAttr.Value;
 674             }
 675             catch(System.Exception ex)
 676             {
 677                 computedValue = "Exception " + ex.Message;
 678             }
 679             //
 680             //    Write out results
 681             //
 682             results.expected = expectedValue;
 683             results.actual = computedValue;
 684
 685             Assert.AreEqual (results.expected, results.actual);
 686             // return results;
 687         }
 688
 689         //------------------------ End test case core-0012A --------------------------
 690         //
 691         //--------------------------  test case core-0013A ---------------------------
 692         //
 693         // Testing feature - On setting, the "value" attribute of an Attr node
 694         //                   creates a Text node with the unparsed content of
 695         //                   the string.
 696
 697         // Testing approach - Retrieve the attribute named "street" from the last
 698         //                    child of the fourth employee and assign the "Y%ent1;"
 699         //                    string to its value attribute.  This value is not yet
 700         //                    parsed and therefore should still be the same upon
 701         //                    retrieval.  This test uses the "GetNamedItem(name)"
 702         //                    method from the NamedNodeMap interface.
 703         //
 704         // Semantic Requirements: 10
 705         //
 706         //----------------------------------------------------------------------------
 707
 708         [Test]
 709         public void core0013A()
 710         {
 711             string computedValue = "";
 712             string expectedValue = "Y%ent1;";
 713             System.Xml.XmlAttribute streetAttr = null;
 714             System.Xml.XmlNode testNode = null;
 715
 716             testResults results = new testResults("Core0013A");
 717             try
 718             {
 719                 results.description = "On setting, the \"value\" attribute of an Attr " +
 720                     "object creates a Text node with the unparsed " +
 721                     "content of the string.";
 722                 //
 723                 // Retrieve the targeted data, assign a value to it and capture its
 724                 // "value" attribute.
 725                 //
 726                 testNode = util.nodeObject(util.FOURTH,util.SIXTH);
 727                 streetAttr = (System.Xml.XmlAttribute)testNode.Attributes.GetNamedItem("street");
 728                 streetAttr.Value = "Y%ent1;";
 729                 computedValue = streetAttr.Value;
 730             }
 731             catch(System.Exception ex)
 732             {
 733                 computedValue = "Exception " + ex.Message;
 734             }
 735             //
 736             // Write out results
 737             //
 738             results.expected = expectedValue;
 739             results.actual = computedValue;
 740
 741             Assert.AreEqual (results.expected, results.actual);
 742             // return results;
 743         }
 744
 745         //------------------------ End test case core-0013A --------------------------
 746         //
 747         //--------------------------  test case core-0014A ---------------------------
 748         //
 749         // Testing feature - Setting the "value" attribute raises a
 750         //                   NO_MODIFICATION_ALLOWED_ERR Exception if the
 751         //                   node is readonly.
 752         //
 753         // Testing approach - Retrieve the first attribute of the Entity node named
 754         //                    "ent4" and attempt to change its value attribute.
 755         //                    Since the descendants of Entity nodes are readonly, the
 756         //                    desired exception should be raised.
 757         //
 758         // Semantic Requirements: 11
 759         //
 760         //----------------------------------------------------------------------------
 761
 762         [Test]
 763         [Category ("NotDotNet")] // MS DOM is buggy
 764         public void core0014A()
 765         {
 766             string computedValue = "";
 767             System.Xml.XmlNode testNode = null;
 768             System.Xml.XmlAttribute readOnlyAttribute = null;
 769             string expectedValue = "System.ArgumentException";//util.NO_MODIFICATION_ALLOWED_ERR;
 770
 771             testResults results = new testResults("Core0014A");
 772             try
 773             {
 774                 results.description =  "Setting the \"value\" attribute raises a " +
 775                     "NO_MODIFICATION_ALLOWED_ERR Exception if " +
 776                     "the node is readonly.";
 777
 778                 //
 779                 // Retrieve the targeted data.
 780                 //
 781                 testNode = util.getEntity("ent4");
 782                 readOnlyAttribute = (System.Xml.XmlAttribute)testNode.FirstChild.Attributes.Item(0);
 783                 //
 784                 // attempt to set a value on a readonly node should raise an exception.
 785                 //
 786                 try
 787                 {
 788                     readOnlyAttribute.Value = "ABCD";
 789                 }
 790                 catch (ArgumentException ex)
 791                 {
 792                     computedValue = ex.GetType ().FullName;
 793                 }
 794             }
 795             catch(System.Exception ex)
 796             {
 797                 computedValue = "Exception " + ex.Message;
 798             }
 799             results.expected = expectedValue;
 800             results.actual = computedValue;
 801
 802             util.resetData();
 803
 804             Assert.AreEqual (results.expected, results.actual);
 805             // return results;
 806         }
 807         //------------------------ End test case core-0014A --------------------------
 808     }
 809
 810 }